def __init__(self, pdgid, pdg_name, mass=attr_dict['mass'].default, mass_upper=attr_dict['mass_upper'].default, mass_lower=attr_dict['mass_lower'].default, width=attr_dict['width'].default, width_upper=attr_dict['width_upper'].default, width_lower=attr_dict['width_lower'].default, three_charge=attr_dict['_three_charge'].default, I=attr_dict['I'].default, G=attr_dict['G'].default, P=attr_dict['P'].default, C=attr_dict['C'].default, anti_flag=attr_dict['anti_flag'].default, rank=attr_dict['rank'].default, status=attr_dict['status'].default, quarks=attr_dict['quarks'].default, latex_name=attr_dict['latex_name'].default):
    self.pdgid = __attr_converter_pdgid(pdgid)
    self.pdg_name = pdg_name
    self.mass = __attr_converter_mass(mass)
    self.mass_upper = __attr_converter_mass_upper(mass_upper)
    self.mass_lower = __attr_converter_mass_lower(mass_lower)
    self.width = __attr_converter_width(width)
    self.width_upper = __attr_converter_width_upper(width_upper)
    self.width_lower = __attr_converter_width_lower(width_lower)
    self._three_charge = __attr_converter__three_charge(three_charge)
    self.I = __attr_converter_I(I)
    self.G = __attr_converter_G(G)
    self.P = __attr_converter_P(P)
    self.C = __attr_converter_C(C)
    self.anti_flag = __attr_converter_anti_flag(anti_flag)
    self.rank = rank
    self.status = __attr_converter_status(status)
    self.quarks = __attr_converter_quarks(quarks)
    self.latex_name = latex_name

def describe(self):
    # type: () -> str
    "Make a nice high-density string for a particle's properties."
    if self.pdgid == 0:
        return "Name: Unknown"
    val = """Name: {self!s:<14} ID: {self.pdgid:<12} Latex: {latex_name}
  = {mass}
th_or_lifetime}
harge)        = {Q:<6}  J (total angular) = {self.J!s:<7}  P (space parity) = {P}
harge parity) = {C:<6}  I (isospin)       = {self.I!s:<7}  G (G-parity)     = {G}
format(
        self=self,
        G=Parity_undo[self.G],
        C=Parity_undo[self.C],
        Q=self._str_charge(),
        P=Parity_undo[self.P],
        mass=self._str_mass(),
        width_or_lifetime=self._width_or_lifetime(),
        latex_name=self._repr_latex_(),
    )
    if self.spin_type != SpinType.Unknown:
        val += "    SpinType: {self.spin_type!s}\n".format(self=self)
    if self.quarks:
        val += "    Quarks: {self.quarks}\n".format(self=self)
    val += "    Antiparticle name: {iself.name} (antiparticle status: {self.anti_flag.name})".format(
        iself=self.invert(), self=self
    )
    return val

def invert(self):
    # type: () -> Particle
    "Get the antiparticle."
    if self.anti_flag == Inv.Barred or (
        self.anti_flag == Inv.ChargeInv and self.three_charge != Charge.o
    ):
        return self.from_pdgid(-self.pdgid)
    else:
        return copy(self)

@classmethod
def all(cls):
    # type: () -> Set[Particle]
    """
    Access, hence get hold of, the internal particle data CSV table,
    loading it from the default location if no table has yet been loaded.
    All `Particle` (instances) are returned as a list.
    """
    if not cls.table_loaded():
        cls.load_table()
    return cls._table if cls._table is not None else set()

@classmethod
def dump_table(
    cls,
    exclusive_fields=(),  # type: Iterable[str]
    exclude_fields=(),  # type: Iterable[str]
    n_rows=-1,
    filter_fn=None,  # type: Optional[Callable[[Particle], bool]]
    filename=None,  # type: Optional[str]
    tablefmt="simple",
    floatfmt=".12g",
    numalign="decimal",
):
    # type: (...) -> Optional[str]
    """
    Dump the internal particle data CSV table,
    loading it from the default location if no table has yet been loaded.
    The table attributes are those of the class. By default all attributes
    are used as table fields. Their complete list is:
        pdgid
        pdg_name
        mass
        mass_upper
        mass_lower
        width
        width_upper
        width_lower
        three_charge
        I
        G
        P
        C
        anti_flag
        rank
        status
        quarks
        latex_name
    Optionally dump to a file.
    Parameters
    ----------
    exclusive_fields: list, optional, default is []
        Exclusive list of fields to print out.
    exclude_fields: list, optional, default is []
        List of table fields to exclude in the printout.
        Relevant only when exclusive_fields is not given.
    n_rows: int, optional, defaults to all rows
        Number of table rows to print out.
    filter_fn: function, optional, default is None
        Apply a filter to each particle.
        See findall(...) for typical use cases.
    filename: str, optional, default is None
        Name of file where to dump the table.
        By default the table is dumped to stdout.
    tablefmt: str, optional, default is 'simple'
        Table formatting option, see the tabulate's package
        tabulate function for a description of available options.
        The most common options are:
        'plain', 'simple', 'grid', 'rst', 'html', 'latex'.
    floatfmt: str, optional, default is '.12g'
        Number formatting, see the tabulate's package
        tabulate function for a description of available options.
    numalign: str or None, oprional, default is 'decimal'
        Column alignment for numbers, see the tabulate's package
        tabulate function for a description of available options.
    Returns
    -------
    str or None if filename is None or not, respectively.
    Note
    ----
    Uses the `tabulate` package.
    Examples
    --------
    print(Particle.dump_table())
    print(Particle.dump_table(n_rows=5))
    print(Particle.dump_table(exclusive_fields=['pdgid', 'pdg_name']))
    print(Particle.dump_table(filter_fn=lambda p: p.pdgid.has_bottom))
    Particle.dump_table(filename='output.txt', tablefmt='rst')
    """
    from tabulate import tabulate
    if not cls.table_loaded():
        cls.load_table()
    # Get all table headers from the class attributes
    tbl_names = [a.name for a in Particle.__attrs_attrs__]  # type: ignore
    # ... and replace '_three_charge' with the better, public property
    tbl_names[tbl_names.index("_three_charge")] = "three_charge"
    if exclusive_fields:
        tbl_names = list(exclusive_fields)
    else:
        for fld in exclude_fields:
            try:
                tbl_names.remove(fld)
            except:
                pass
    # Start with the full table
    tbl_all = sorted(cls.all())
    # Apply a filter, if specified
    if filter_fn is not None:
        tbl_all = cls.findall(filter_fn)
    # In any case, only dump a given number of rows?
    if n_rows >= 0:
        tbl_all = tbl_all[:n_rows]
    # Build all table rows
    tbl = []
    for p in tbl_all:
        tbl.append([getattr(p, attr) for attr in tbl_names])
    if filename:
        filename = str(filename)  # Conversion to handle pathlib on Python < 3.6
        with open(filename, "w") as outfile:
            print(
                tabulate(
                    tbl,
                    headers=tbl_names,
                    tablefmt=tablefmt,
                    floatfmt=floatfmt,
                    numalign=numalign,
                ),
                file=outfile,
            )
        return None
    else:
        return tabulate(
            tbl,
            headers=tbl_names,
            tablefmt=tablefmt,
            floatfmt=floatfmt,
            numalign=numalign,
        )

@classmethod
def empty(cls):
    # type: () -> Particle
    "Make a new empty particle."
    return cls(0, "Unknown", anti_flag=Inv.Same)

@classmethod
def find(cls, *args, **search_terms):
    # type: (...) -> Particle
    """
    Require that the search returns one and only one result.
    The method otherwise raises a ParticleNotFound or RuntimeError exception.
    See `findall` for full listing of parameters.
    Raises
    ------
    ParticleNotFound
        If no matching particle is found in the loaded data table(s).
    RuntimeError
        If too many particles match the search criteria.
    """
    results = cls.findall(*args, **search_terms)
    if len(results) == 1:
        return results[0]
    elif len(results) == 0:
        raise ParticleNotFound(
            "Did not find particle matching query: {}".format(search_terms)
        )
    else:
        raise RuntimeError("Found too many particles")

@classmethod
def findall(
    cls,
    filter_fn=None,  # type: Optional[Callable[[Particle], bool]]
    particle=None,  # type: Optional[bool]
    **search_terms  # type: Any
):
    # type: (...) -> List[Particle]
    """
    Search for a particle, returning a list of candidates.
    The first and only positional argument is given each particle
    candidate, and returns True/False. Example:
        >>> Particle.findall(lambda p: 'p' in p.name)    # doctest: +SKIP
        # Returns list of all particles with p somewhere in name
    You can pass particle=True/False to force a particle or antiparticle.
    If this is not callable, it will do a "fuzzy" search on the name. So this is identical:
        >>> Particle.findall('p')    # doctest: +SKIP
        # Returns list of all particles with p somewhere in name (same as example above)
    You can also pass keyword arguments, which are either called with the
    matching property if they are callable, or are compared if they are not.
    This would do an exact search on the name, instead of a fuzzy search:
       >>> # Returns proton and antiproton only
       >>> Particle.findall(pdg_name='p')    # doctest: +NORMALIZE_WHITESPACE
       [<Particle: name="p", pdgid=2212, mass=938.272081 ± 0.000006 MeV>,
        <Particle: name="p~", pdgid=-2212, mass=938.272081 ± 0.000006 MeV>,
        <Particle: name="p", pdgid=1000010010, mass=938.272081 ± 0.000006 MeV>,
        <Particle: name="p~", pdgid=-1000010010, mass=938.272081 ± 0.000006 MeV>]
       >>> # Returns proton only
       >>> Particle.findall(pdg_name='p', particle=True)    # doctest: +NORMALIZE_WHITESPACE
       [<Particle: name="p", pdgid=2212, mass=938.272081 ± 0.000006 MeV>,
       <Particle: name="p", pdgid=1000010010, mass=938.272081 ± 0.000006 MeV>]
    Versatile searches require a (lambda) function as argument:
    >>> # Get all neutral beauty hadrons
    >>> Particle.findall(lambda p: p.pdgid.has_bottom and p.charge==0)    # doctest: +SKIP
    >>>
    >>> # Trivially find all pseudoscalar charm mesons
    >>> Particle.findall(lambda p: p.pdgid.is_meson and p.pdgid.has_charm and p.spin_type==SpinType.PseudoScalar)  # doctest: +SKIP
    See also ``find``, which throws an exception if the particle is not found or too many are found.
    """
    # Note that particle can be called by position to keep compatibility with Python 2, but that behavior should
    # not be used and will be removed when support for Python 2.7 is dropped.
    results = set()
    # Filter out values
    for item in cls.all():
        # At this point, continue if a match fails
        # particle=True is particle, False is antiparticle, and None is both
        if particle is not None:
            if particle and int(item) < 0:
                continue
            elif (not particle) and int(item) > 0:
                continue
        # If a filter function is passed, evaluate and skip if False
        if filter_fn is not None:
            if callable(filter_fn):
                # Just skip exceptions, which are there for good reasons
                # Example: calls to Particle.ctau for particles given
                #          default negative, and hence invalid, widths
                try:
                    if not filter_fn(item):
                        continue
                except TypeError:  # skip checks such as 'lambda p: p.width > 0',
                    continue  # which fail when width=None
            else:
                if not (filter_fn in item.name):
                    continue
        # At this point, if you break, you will not add a match
        for term, value in search_terms.items():
            # If pvalue cannot be accessed, skip this particle
            # (invalid lifetime, for example)
            try:
                pvalue = getattr(item, term)
            except ValueError:
                break
            # Callables are supported
            if callable(value):
                try:
                    if not value(pvalue):
                        break
                except TypeError:  # catch issues with None values
                    break
            # And, finally, just compare if nothing else matched
            elif pvalue != value:
                break
        # If the loop was not broken
        else:
            results.add(item)
    # Matches are sorted so the top one is "best"
    return sorted(results)

@classmethod
def flavio_all(cls):
    return {particle for particle in cls.all() if particle.flavio_name}

@classmethod
def from_evtgen_name(cls, name):
    # type: (str) -> Particle
    """
    Get a particle from an EvtGen particle name, as in .dec decay files.
    Raises
    ------
    ParticleNotFound
        If `from_pdgid` returns no match.
    MatchingIDNotFound
        If the matching EvtGen name - PDG ID done internally is unsuccessful.
    """
    return cls.from_pdgid(EvtGenName2PDGIDBiMap[name])

@classmethod
def from_flavio_name(cls, flavio_name):
    return cls.from_pdgid(cls.PDG_PARTICLES[flavio_name])

@classmethod
def from_pdgid(cls, value):
    # type: (SupportsInt) -> Particle
    """
    Get a particle from a PDGID. Uses by default the package
    extended PDG data table.
    Raises
    ------
    InvalidParticle
        If the input PDG ID is an invalid identification code.
    ParticleNotFound
        If no matching PDG ID is found in the loaded data table(s).
    """
    if not is_valid(value):
        raise InvalidParticle("Input PDGID {0} is invalid!".format(value))
    for item in cls.all():
        if item.pdgid == value:
            return item
    else:
        raise ParticleNotFound("Could not find PDGID {0}".format(value))

@classmethod
def from_string(cls, name):
    # type: (str) -> Particle
    "Get a particle from a PDG style name - returns the best match."
    matches = cls.from_string_list(name)
    if matches:
        return matches[0]
    else:
        raise ParticleNotFound("{0} not found in particle table".format(name))

@classmethod
def from_string_list(cls, name):
    # type: (str) -> List[Particle]
    "Get a list of particles from a PDG style name."
    # Forcible override
    particle = None
    short_name = name
    if "~" in name:
        short_name = name.replace("~", "")
        particle = False
    # Try the simplest searches first
    list_can = cls.findall(name=name, particle=particle)
    if list_can:
        return list_can
    else:
        list_can = cls.findall(pdg_name=short_name, particle=particle)
        if list_can:
            return list_can
    mat_str = getname.match(short_name)
    if mat_str is None:
        return []
    mat = mat_str.groupdict()
    if particle is False:
        mat["bar"] = "bar"
    try:
        return cls._from_group_dict_list(mat)
    except ParticleNotFound:
        return []

@classmethod
def load_table(cls, filename=None, append=False, _name=None):
    # type: (Union[None, str, TextIO], bool, Optional[str]) -> None
    """
    Load a particle data CSV table. Optionally append to the existing data already loaded if append=True.
    As a special case, if this is called with append=True and the table is not loaded, the default will
    be loaded first before appending (set append=False if you don't want this behavior).
    A parameter is also included that should be considered private for now. It is _name, which
    will override the filename for the stored filename in _table_names.
    """
    if append and not cls.table_loaded():
        cls.load_table(append=False)  # default load
    elif not append:
        cls._table = set()
        cls._table_names = []
    # Tell MyPy that this is true
    assert cls._table is not None
    assert cls._table_names is not None
    if filename is None:
        with data.open_text(data, "particle2020.csv") as f:
            cls.load_table(f, append=append, _name="particle2020.csv")
        with data.open_text(data, "nuclei2020.csv") as f:
            cls.load_table(f, append=True, _name="nuclei2020.csv")
        return
    elif not hasattr(filename, "read"):
        cls._table_names.append(str(filename))
        # Conversion to handle pathlib on Python < 3.6:
        open_file = open(str(filename))
    else:
        assert not isinstance(filename, str)  # Tell typing that this is true
        tmp_name = _name or getattr(filename, "name")
        cls._table_names.append(
            tmp_name or "{0!r} {1}".format(filename, len(cls._table_names))
        )
        open_file = filename
    with open_file as f:
        r = csv.DictReader(l for l in f if not l.startswith("#"))
        for v in r:
            try:
                value = int(v["ID"])
                # Replace the previous value if it exists
                # We can remove an int; ignore typing thinking we need a particle
                if value in cls._table:
                    cls._table.remove(value)  # type: ignore
                cls._table.add(
                    cls(
                        pdgid=value,
                        mass=float(v["Mass"]),
                        mass_upper=float(v["MassUpper"]),
                        mass_lower=float(v["MassLower"]),
                        width=float(v["Width"]),
                        width_upper=float(v["WidthUpper"]),
                        width_lower=float(v["WidthLower"]),
                        I=v["I"],
                        G=int(v["G"]),
                        P=int(v["P"]),
                        C=int(v["C"]),
                        anti_flag=int(v["Anti"]),
                        three_charge=int(v["Charge"]),
                        rank=int(v["Rank"]),
                        status=int(v["Status"]),
                        pdg_name=v["Name"],
                        quarks=v["Quarks"],
                        latex_name=v["Latex"],
                    )
                )
            except ValueError:
                pass

@classmethod
def table_loaded(cls):
    # type: () -> bool
    """
    Check to see if the table is loaded.
    """
    return not cls._table is None

@classmethod
def table_names(cls):
    # type: () -> Tuple[str, ...]
    """
    Return the list of names loaded.
    Note
    ----
    Calling this class method will load the default table,
    if no table has so far been loaded.
    Check with table_loaded() first if you don't want this loading
    to be triggered by the call.
    """
    if cls._table_names is None:
        cls.load_table()
    if cls._table_names is not None:
        return tuple(cls._table_names)  # make a copy to avoid user manipulation
    else:
        return tuple()