CardInventory

Bases: UserDict

Represents an inventory of unique Flesh and Blood cards.

This is essentially a dict[InventoryItem, int], where the value of a particular key denotes the number of copies in the inventory.

Note

This class inherits collections.UserDict, and thus supports any common dict methods.

Warning

Note that since this object is essentially a dict, calling len() on it will not return the total number of cards in the inventory. Instead, it returns the total number of different types of cards in the inventory. To get the overall number of cards in the inventory, use the count() method.

Attributes:

Name	Type	Description
data	dict[InventoryItem, int]	The underlying dict of InventoryItem objects.

Source code in fab/inventory.py

class CardInventory(UserDict):
    '''
    Represents an inventory of unique Flesh and Blood cards.

    This is essentially a `dict[InventoryItem, int]`, where the value of a
    particular key denotes the number of copies in the inventory.

    Note:
      This class inherits `collections.UserDict`, and thus supports any common
      `dict` methods.

    Tip: Warning
      Note that since this object is essentially a `dict`, calling `len()` on it
      will _not_ return the total number of cards in the inventory. Instead, it
      returns the total number of _different types_ of cards in the inventory.
      To get the overall number of cards in the inventory, use the `count()`
      method.

    Attributes:
      data: The underlying `dict` of `InventoryItem` objects.
    '''
    data: dict[InventoryItem, int]

    def add(
        self,
        identifier: str,
        rarity: str,
        foiling: str,
        count: int = 1,
        edition: str = 'U',
    ) -> None:
        '''
        Adds one or more copies of a unique card to this inventory.

        This method builds a `InventoryItem` object from the specified
        parameters. To add a pre-built `InventoryItem` object to the collection,
        use `add_item()`. If the inventory already contains the specified card,
        its count is increased by the value specified (to set the count, use
        `set()`).

        Args:
          count: The number of copies to add to the inventory.
          edition: The edition code of the card (see `meta.EDITIONS`).
          foiling: The foiling code of the card (see `meta.FOILINGS`).
          identifier: The identifier of the card to add.
          rarity: The rarity code of the card (see `meta.RARITIES`).
        '''
        if not edition in EDITIONS:
            raise ValueError(f'specified card edition code not one of {list(EDITIONS.keys())}')
        if not foiling in FOILINGS:
            raise ValueError(f'specified card foiling code not one of {list(FOILINGS.keys())}')
        if not rarity in RARITIES:
            raise ValueError(f'specified card rarity code not one of {list(RARITIES.keys())}')
        self.add_item(
            item = InventoryItem(
              identifier = identifier,
              rarity = rarity,
              edition = edition,
              foiling = foiling
            ),
            count = count
        )

    def add_item(self, item: InventoryItem, count: int = 1) -> None:
        '''
        Adds one or more copies of a card inventory item to this inventory.

        If the inventory already contains the specified item, its count is
        increased by the value specified (to set the count, use `set_item()`).

        Args:
          item: The card inventory item to add.
          count: The number of copies to add to the inventory.
        '''
        if count <= 0:
            raise ValueError('specified count is not a positive integer value')
        if not item in self:
            self[item] = count
        else:
            self[item] += count

    def count(self) -> int:
        '''
        Computes the total number of cards in this inventory.

        Return:
          The total number of cards in the inventory.
        '''
        return sum(self.data.values())

    def edition_counts(self) -> dict[str, int]:
        '''
        Returns the counts of each edition code contained in this card inventory.

        Returns:
          A `dict` representing the counts of each edition code contained in the inventory.
        '''
        res = {}
        for k, v in self.data.items():
            if k.edition in res:
                res[k.edition] += v
            else:
                res[k.edition] = v
        return res

    def editions(self) -> list[str]:
        '''
        Returns the set of edition codes contained in this card inventory.

        Returns:
          A unique `list` of all card set edition codes contained in the card inventory.
        '''
        res = []
        for i in self.data.keys():
            res.append(i.edition)
        return list(set(res))

    def foiling_counts(self) -> dict[str, int]:
        '''
        Returns the counts of each foiling code contained in this card inventory.

        Returns:
          A `dict` representing the counts of each foiling code contained in the inventory.
        '''
        res = {}
        for k, v in self.data.items():
            if k.foiling in res:
                res[k.foiling] += v
            else:
                res[k.foiling] = v
        return res

    def foilings(self) -> list[str]:
        '''
        Returns the set of foiling codes contained in this card inventory.

        Returns:
          A unique `list` of all card set foiling codes contained in the card inventory.
        '''
        res = []
        for i in self.data.keys():
            res.append(i.foiling)
        return list(set(res))

    @staticmethod
    def from_dict(data: dict[str, int]) -> CardInventory:
        '''
        Parses a new card inventory from the specified `dict` representation.

        Args:
          data: The `dict` representation to parse.

        Returns:
          A new `CardInventory` from the parsed data.
        '''
        res = {}
        for k, v in data.items():
            res[InventoryItem.from_str(k)] = v
        return CardInventory(res)

    @staticmethod
    def from_json(jsonstr: str) -> CardInventory:
        '''
        Parses a new card inventory from the specified JSON string representation.

        Args:
          jsonstr: The JSON string representation to parse.

        Returns:
          A new `CardInventory` from the parsed data.
        '''
        return CardInventory.from_dict(json.loads(jsonstr))

    def identifier_counts(self) -> dict[str, int]:
        '''
        Returns the counts of each identifier contained in this card inventory.

        Returns:
          A `dict` representing the counts of each identifier contained in the inventory.
        '''
        res = {}
        for k, v in self.data.items():
            if k.identifier in res:
                res[k.identifier] += v
            else:
                res[k.identifier] = v
        return res

    def identifiers(self) -> list[str]:
        '''
        Returns the set of identifiers contained in this card inventory.

        Returns:
          A unique `list` of all card set identifiers contained in the card inventory.
        '''
        res = []
        for i in self.data.keys():
            res.append(i.identifier)
        return list(set(res))

    @staticmethod
    def load(file_path: str) -> CardInventory:
        '''
        Loads a card inventory from the specified `.json` file.

        Args:
          file_path: The `.json` file path from which to load the inventory.

        Returns:
          The parsed card inventory object loaded from the specified file path.
        '''
        with open(os.path.expanduser(file_path), 'r') as f:
            if file_path.endswith('.json'):
                return CardInventory.from_json(f.read())
            else:
                raise Exception('specified file path is not a JSON file')

    def lookup(
        self,
        edition: Optional[str] = None,
        foiling: Optional[str] = None,
        identifier: Optional[str] = None,
        rarity: Optional[str] = None,
        set: Optional[str] = None
    ) -> CardInventory:
        '''
        Returns a subset of the card inventory based on the specified search parameters.

        This is akin to filtering the inventory. Any arguments with `None`
        values are ignored.

        Args:
          edition: The edition code of cards to include in the result.
          foiling: The foiling code of cards to include in the result.
          identifier: The identifier of cards to include in the result.
          rarity: The rarity of cards to include in the result.
          set: The card set code of cards to include in the result.

        Returns:
          A subset of the inventory filtered by the specified arguments.
        '''
        res = {}
        for k, v in self.data.items():
            if not edition is None and not k.edition == edition: continue
            if not foiling is None and not k.foiling == foiling: continue
            if not identifier is None and not k.identifier == identifier: continue
            if not rarity is None and not k.rarity == rarity: continue
            if not set is None and not k.identifier.startswith(set): continue
            res[k] = v
        return CardInventory(res)

    def rarities(self) -> list[str]:
        '''
        Returns the set of rarity codes contained in this card inventory.

        Returns:
          A unique `list` of all card set rarity codes contained in the card inventory.
        '''
        res = []
        for i in self.data.keys():
            res.append(i.rarity)
        return list(set(res))

    def rarity_counts(self) -> dict[str, int]:
        '''
        Returns the counts of each rarity code contained in this card inventory.

        Returns:
          A `dict` representing the counts of each rarity code contained in the inventory.
        '''
        res = {}
        for k, v in self.data.items():
            if k.rarity in res:
                res[k.rarity] += v
            else:
                res[k.rarity] = v
        return res

    def save(self, file_path: str) -> None:
        '''
        Saves the card inventory to the specified `.json` file path.

        Args:
          file_path: The `.json` file path to save to.
        '''
        with open(os.path.expanduser(file_path), 'w') as f:
            if file_path.endswith('.json'):
                f.write(self.to_json())
            else:
                raise Exception('specified file path is not a JSON file')

    def set(
        self,
        identifier: str,
        rarity: str,
        foiling: str,
        count: int = 1,
        edition: str = 'U',
    ) -> None:
        '''
        Sets the number of copies associated with a unique card.

        This method builds a `InventoryItem` object from the specified
        parameters. To set a pre-built `InventoryItem` object in the collection,
        use `set_item()`. To add to the current count associated with an item,
        use `add()`.

        Note:
          Setting a card's count to `0` does not delete the item from the
          inventory but rather simply sets the count to `0`. This is useful for
          tracking when you _used_ to own a card, or when _plan_ to obtain a
          copy of a particular card.

        Args:
          count: The number of copies to set the inventory count to.
          edition: The edition code of the card (see `meta.EDITIONS`).
          foiling: The foiling code of the card (see `meta.FOILINGS`).
          identifier: The identifier of the card.
          rarity: The rarity code of the card (see `meta.RARITIES`).
        '''
        if not edition in EDITIONS:
            raise ValueError(f'specified card edition code not one of {list(EDITIONS.keys())}')
        if not foiling in FOILINGS:
            raise ValueError(f'specified card foiling code not one of {list(FOILINGS.keys())}')
        if not rarity in RARITIES:
            raise ValueError(f'specified card rarity code not one of {list(RARITIES.keys())}')
        self.set_item(
            item = InventoryItem(
              identifier = identifier,
              rarity = rarity,
              edition = edition,
              foiling = foiling
            ),
            count = count
        )

    def set_item(self, item: InventoryItem, count: int = 1) -> None:
        '''
        Sets the number of copies of a card inventory item in this inventory.

        If the inventory already contains the specified item, its count is
        increased by the value specified (to set the count, use `set_item()`).

        Note:
          Setting a card's count to `0` does not delete the item from the
          inventory but rather simply sets the count to `0`. This is useful for
          tracking when you _used_ to own a card, or when _plan_ to obtain a
          copy of a particular card.

        Args:
          item: The card inventory item.
          count: The number of copies to set.
        '''
        if count < 0:
            raise ValueError('specified count is not zero or a positive integer value')
        self[item] = count

    def to_cardlist(self, catalog: Optional[CardList] = None) -> CardList:
        '''
        Converts this unique card inventory into a list of generic
        representations of cards.

        Note:
          To instantiate the card list this way, a card catalog (`CardList`)
          must be provided, defaulting to `card.CARD_CATALOG`.

        Args:
          catalog: The card catalog to use as a reference, defaulting to `card.CARD_CATALOG` if `None`.

        Returns:
          A `CardList` object containing the generic represenations of the cards contained within this inventory.
        '''
        cards = []
        for k, v in self.data.items():
            for _ in range(0, v):
                cards.append(k.to_card(catalog=catalog))
        return CardList(cards)

    def to_dict(self) -> dict[str, int]:
        '''
        Converts the inventory object into a raw dictionary of python
        primitives.

        Returns:
          A raw `dict` representation of the card inventory.
        '''
        data = {}
        for k, v in self.data.items():
            data[k.to_str()] = v
        return data

    def to_json(self) -> str:
        '''
        Computes the JSON string representation of the inventory.

        Returns:
          The JSON string representation of the card inventory.
        '''
        return json.dumps(self.to_dict(), indent=JSON_INDENT)

add(identifier, rarity, foiling, count=1, edition='U')

Adds one or more copies of a unique card to this inventory.

This method builds a InventoryItem object from the specified parameters. To add a pre-built InventoryItem object to the collection, use add_item(). If the inventory already contains the specified card, its count is increased by the value specified (to set the count, use set()).

Parameters:

Name	Type	Description	Default
count	int	The number of copies to add to the inventory.	1
edition	str	The edition code of the card (see meta.EDITIONS).	'U'
foiling	str	The foiling code of the card (see meta.FOILINGS).	required
identifier	str	The identifier of the card to add.	required
rarity	str	The rarity code of the card (see meta.RARITIES).	required

Source code in fab/inventory.py

def add(
    self,
    identifier: str,
    rarity: str,
    foiling: str,
    count: int = 1,
    edition: str = 'U',
) -> None:
    '''
    Adds one or more copies of a unique card to this inventory.

    This method builds a `InventoryItem` object from the specified
    parameters. To add a pre-built `InventoryItem` object to the collection,
    use `add_item()`. If the inventory already contains the specified card,
    its count is increased by the value specified (to set the count, use
    `set()`).

    Args:
      count: The number of copies to add to the inventory.
      edition: The edition code of the card (see `meta.EDITIONS`).
      foiling: The foiling code of the card (see `meta.FOILINGS`).
      identifier: The identifier of the card to add.
      rarity: The rarity code of the card (see `meta.RARITIES`).
    '''
    if not edition in EDITIONS:
        raise ValueError(f'specified card edition code not one of {list(EDITIONS.keys())}')
    if not foiling in FOILINGS:
        raise ValueError(f'specified card foiling code not one of {list(FOILINGS.keys())}')
    if not rarity in RARITIES:
        raise ValueError(f'specified card rarity code not one of {list(RARITIES.keys())}')
    self.add_item(
        item = InventoryItem(
          identifier = identifier,
          rarity = rarity,
          edition = edition,
          foiling = foiling
        ),
        count = count
    )

add_item(item, count=1)

Adds one or more copies of a card inventory item to this inventory.

If the inventory already contains the specified item, its count is increased by the value specified (to set the count, use set_item()).

Parameters:

Name	Type	Description	Default
item	InventoryItem	The card inventory item to add.	required
count	int	The number of copies to add to the inventory.	1

Source code in fab/inventory.py

def add_item(self, item: InventoryItem, count: int = 1) -> None:
    '''
    Adds one or more copies of a card inventory item to this inventory.

    If the inventory already contains the specified item, its count is
    increased by the value specified (to set the count, use `set_item()`).

    Args:
      item: The card inventory item to add.
      count: The number of copies to add to the inventory.
    '''
    if count <= 0:
        raise ValueError('specified count is not a positive integer value')
    if not item in self:
        self[item] = count
    else:
        self[item] += count

count()

Computes the total number of cards in this inventory.

Return

The total number of cards in the inventory.

Source code in fab/inventory.py

def count(self) -> int:
    '''
    Computes the total number of cards in this inventory.

    Return:
      The total number of cards in the inventory.
    '''
    return sum(self.data.values())

edition_counts()

Returns the counts of each edition code contained in this card inventory.

Returns:

Type	Description
dict[str, int]	A dict representing the counts of each edition code contained in the inventory.

Source code in fab/inventory.py

def edition_counts(self) -> dict[str, int]:
    '''
    Returns the counts of each edition code contained in this card inventory.

    Returns:
      A `dict` representing the counts of each edition code contained in the inventory.
    '''
    res = {}
    for k, v in self.data.items():
        if k.edition in res:
            res[k.edition] += v
        else:
            res[k.edition] = v
    return res

editions()

Returns the set of edition codes contained in this card inventory.

Returns:

Type	Description
list[str]	A unique list of all card set edition codes contained in the card inventory.

Source code in fab/inventory.py

def editions(self) -> list[str]:
    '''
    Returns the set of edition codes contained in this card inventory.

    Returns:
      A unique `list` of all card set edition codes contained in the card inventory.
    '''
    res = []
    for i in self.data.keys():
        res.append(i.edition)
    return list(set(res))

foiling_counts()

Returns the counts of each foiling code contained in this card inventory.

Returns:

Type	Description
dict[str, int]	A dict representing the counts of each foiling code contained in the inventory.

Source code in fab/inventory.py

def foiling_counts(self) -> dict[str, int]:
    '''
    Returns the counts of each foiling code contained in this card inventory.

    Returns:
      A `dict` representing the counts of each foiling code contained in the inventory.
    '''
    res = {}
    for k, v in self.data.items():
        if k.foiling in res:
            res[k.foiling] += v
        else:
            res[k.foiling] = v
    return res

foilings()

Returns the set of foiling codes contained in this card inventory.

Returns:

Type	Description
list[str]	A unique list of all card set foiling codes contained in the card inventory.

Source code in fab/inventory.py

def foilings(self) -> list[str]:
    '''
    Returns the set of foiling codes contained in this card inventory.

    Returns:
      A unique `list` of all card set foiling codes contained in the card inventory.
    '''
    res = []
    for i in self.data.keys():
        res.append(i.foiling)
    return list(set(res))

from_dict(data) staticmethod

Parses a new card inventory from the specified dict representation.

Parameters:

Name	Type	Description	Default
data	dict[str, int]	The dict representation to parse.	required

Returns:

Type	Description
CardInventory	A new CardInventory from the parsed data.

Source code in fab/inventory.py

@staticmethod
def from_dict(data: dict[str, int]) -> CardInventory:
    '''
    Parses a new card inventory from the specified `dict` representation.

    Args:
      data: The `dict` representation to parse.

    Returns:
      A new `CardInventory` from the parsed data.
    '''
    res = {}
    for k, v in data.items():
        res[InventoryItem.from_str(k)] = v
    return CardInventory(res)

from_json(jsonstr) staticmethod

Parses a new card inventory from the specified JSON string representation.

Parameters:

Name	Type	Description	Default
jsonstr	str	The JSON string representation to parse.	required

Returns:

Type	Description
CardInventory	A new CardInventory from the parsed data.

Source code in fab/inventory.py

@staticmethod
def from_json(jsonstr: str) -> CardInventory:
    '''
    Parses a new card inventory from the specified JSON string representation.

    Args:
      jsonstr: The JSON string representation to parse.

    Returns:
      A new `CardInventory` from the parsed data.
    '''
    return CardInventory.from_dict(json.loads(jsonstr))

identifier_counts()

Returns the counts of each identifier contained in this card inventory.

Returns:

Type	Description
dict[str, int]	A dict representing the counts of each identifier contained in the inventory.

Source code in fab/inventory.py

def identifier_counts(self) -> dict[str, int]:
    '''
    Returns the counts of each identifier contained in this card inventory.

    Returns:
      A `dict` representing the counts of each identifier contained in the inventory.
    '''
    res = {}
    for k, v in self.data.items():
        if k.identifier in res:
            res[k.identifier] += v
        else:
            res[k.identifier] = v
    return res

identifiers()

Returns the set of identifiers contained in this card inventory.

Returns:

Type	Description
list[str]	A unique list of all card set identifiers contained in the card inventory.

Source code in fab/inventory.py

def identifiers(self) -> list[str]:
    '''
    Returns the set of identifiers contained in this card inventory.

    Returns:
      A unique `list` of all card set identifiers contained in the card inventory.
    '''
    res = []
    for i in self.data.keys():
        res.append(i.identifier)
    return list(set(res))

load(file_path) staticmethod

Loads a card inventory from the specified .json file.

Parameters:

Name	Type	Description	Default
file_path	str	The .json file path from which to load the inventory.	required

Returns:

Type	Description
CardInventory	The parsed card inventory object loaded from the specified file path.

Source code in fab/inventory.py

@staticmethod
def load(file_path: str) -> CardInventory:
    '''
    Loads a card inventory from the specified `.json` file.

    Args:
      file_path: The `.json` file path from which to load the inventory.

    Returns:
      The parsed card inventory object loaded from the specified file path.
    '''
    with open(os.path.expanduser(file_path), 'r') as f:
        if file_path.endswith('.json'):
            return CardInventory.from_json(f.read())
        else:
            raise Exception('specified file path is not a JSON file')

lookup(edition=None, foiling=None, identifier=None, rarity=None, set=None)

Returns a subset of the card inventory based on the specified search parameters.

This is akin to filtering the inventory. Any arguments with None values are ignored.

Parameters:

Name	Type	Description	Default
edition	Optional[str]	The edition code of cards to include in the result.	None
foiling	Optional[str]	The foiling code of cards to include in the result.	None
identifier	Optional[str]	The identifier of cards to include in the result.	None
rarity	Optional[str]	The rarity of cards to include in the result.	None
set	Optional[str]	The card set code of cards to include in the result.	None

Returns:

Type	Description
CardInventory	A subset of the inventory filtered by the specified arguments.

Source code in fab/inventory.py

def lookup(
    self,
    edition: Optional[str] = None,
    foiling: Optional[str] = None,
    identifier: Optional[str] = None,
    rarity: Optional[str] = None,
    set: Optional[str] = None
) -> CardInventory:
    '''
    Returns a subset of the card inventory based on the specified search parameters.

    This is akin to filtering the inventory. Any arguments with `None`
    values are ignored.

    Args:
      edition: The edition code of cards to include in the result.
      foiling: The foiling code of cards to include in the result.
      identifier: The identifier of cards to include in the result.
      rarity: The rarity of cards to include in the result.
      set: The card set code of cards to include in the result.

    Returns:
      A subset of the inventory filtered by the specified arguments.
    '''
    res = {}
    for k, v in self.data.items():
        if not edition is None and not k.edition == edition: continue
        if not foiling is None and not k.foiling == foiling: continue
        if not identifier is None and not k.identifier == identifier: continue
        if not rarity is None and not k.rarity == rarity: continue
        if not set is None and not k.identifier.startswith(set): continue
        res[k] = v
    return CardInventory(res)

rarities()

Returns the set of rarity codes contained in this card inventory.

Returns:

Type	Description
list[str]	A unique list of all card set rarity codes contained in the card inventory.

Source code in fab/inventory.py

def rarities(self) -> list[str]:
    '''
    Returns the set of rarity codes contained in this card inventory.

    Returns:
      A unique `list` of all card set rarity codes contained in the card inventory.
    '''
    res = []
    for i in self.data.keys():
        res.append(i.rarity)
    return list(set(res))

rarity_counts()

Returns the counts of each rarity code contained in this card inventory.

Returns:

Type	Description
dict[str, int]	A dict representing the counts of each rarity code contained in the inventory.

Source code in fab/inventory.py

def rarity_counts(self) -> dict[str, int]:
    '''
    Returns the counts of each rarity code contained in this card inventory.

    Returns:
      A `dict` representing the counts of each rarity code contained in the inventory.
    '''
    res = {}
    for k, v in self.data.items():
        if k.rarity in res:
            res[k.rarity] += v
        else:
            res[k.rarity] = v
    return res

save(file_path)

Saves the card inventory to the specified .json file path.

Parameters:

Name	Type	Description	Default
file_path	str	The .json file path to save to.	required

Source code in fab/inventory.py

def save(self, file_path: str) -> None:
    '''
    Saves the card inventory to the specified `.json` file path.

    Args:
      file_path: The `.json` file path to save to.
    '''
    with open(os.path.expanduser(file_path), 'w') as f:
        if file_path.endswith('.json'):
            f.write(self.to_json())
        else:
            raise Exception('specified file path is not a JSON file')

set(identifier, rarity, foiling, count=1, edition='U')

Sets the number of copies associated with a unique card.

This method builds a InventoryItem object from the specified parameters. To set a pre-built InventoryItem object in the collection, use set_item(). To add to the current count associated with an item, use add().

Note

Setting a card's count to 0 does not delete the item from the inventory but rather simply sets the count to 0. This is useful for tracking when you used to own a card, or when plan to obtain a copy of a particular card.

Parameters:

Name	Type	Description	Default
count	int	The number of copies to set the inventory count to.	1
edition	str	The edition code of the card (see meta.EDITIONS).	'U'
foiling	str	The foiling code of the card (see meta.FOILINGS).	required
identifier	str	The identifier of the card.	required
rarity	str	The rarity code of the card (see meta.RARITIES).	required

Source code in fab/inventory.py

def set(
    self,
    identifier: str,
    rarity: str,
    foiling: str,
    count: int = 1,
    edition: str = 'U',
) -> None:
    '''
    Sets the number of copies associated with a unique card.

    This method builds a `InventoryItem` object from the specified
    parameters. To set a pre-built `InventoryItem` object in the collection,
    use `set_item()`. To add to the current count associated with an item,
    use `add()`.

    Note:
      Setting a card's count to `0` does not delete the item from the
      inventory but rather simply sets the count to `0`. This is useful for
      tracking when you _used_ to own a card, or when _plan_ to obtain a
      copy of a particular card.

    Args:
      count: The number of copies to set the inventory count to.
      edition: The edition code of the card (see `meta.EDITIONS`).
      foiling: The foiling code of the card (see `meta.FOILINGS`).
      identifier: The identifier of the card.
      rarity: The rarity code of the card (see `meta.RARITIES`).
    '''
    if not edition in EDITIONS:
        raise ValueError(f'specified card edition code not one of {list(EDITIONS.keys())}')
    if not foiling in FOILINGS:
        raise ValueError(f'specified card foiling code not one of {list(FOILINGS.keys())}')
    if not rarity in RARITIES:
        raise ValueError(f'specified card rarity code not one of {list(RARITIES.keys())}')
    self.set_item(
        item = InventoryItem(
          identifier = identifier,
          rarity = rarity,
          edition = edition,
          foiling = foiling
        ),
        count = count
    )

set_item(item, count=1)

Sets the number of copies of a card inventory item in this inventory.

If the inventory already contains the specified item, its count is increased by the value specified (to set the count, use set_item()).

Note

Setting a card's count to 0 does not delete the item from the inventory but rather simply sets the count to 0. This is useful for tracking when you used to own a card, or when plan to obtain a copy of a particular card.

Parameters:

Name	Type	Description	Default
item	InventoryItem	The card inventory item.	required
count	int	The number of copies to set.	1

Source code in fab/inventory.py

def set_item(self, item: InventoryItem, count: int = 1) -> None:
    '''
    Sets the number of copies of a card inventory item in this inventory.

    If the inventory already contains the specified item, its count is
    increased by the value specified (to set the count, use `set_item()`).

    Note:
      Setting a card's count to `0` does not delete the item from the
      inventory but rather simply sets the count to `0`. This is useful for
      tracking when you _used_ to own a card, or when _plan_ to obtain a
      copy of a particular card.

    Args:
      item: The card inventory item.
      count: The number of copies to set.
    '''
    if count < 0:
        raise ValueError('specified count is not zero or a positive integer value')
    self[item] = count

to_cardlist(catalog=None)

Converts this unique card inventory into a list of generic representations of cards.

Note

To instantiate the card list this way, a card catalog (CardList) must be provided, defaulting to card.CARD_CATALOG.

Parameters:

Name	Type	Description	Default
catalog	Optional[CardList]	The card catalog to use as a reference, defaulting to card.CARD_CATALOG if None.	None

Returns:

Type	Description
CardList	A CardList object containing the generic represenations of the cards contained within this inventory.

Source code in fab/inventory.py

def to_cardlist(self, catalog: Optional[CardList] = None) -> CardList:
    '''
    Converts this unique card inventory into a list of generic
    representations of cards.

    Note:
      To instantiate the card list this way, a card catalog (`CardList`)
      must be provided, defaulting to `card.CARD_CATALOG`.

    Args:
      catalog: The card catalog to use as a reference, defaulting to `card.CARD_CATALOG` if `None`.

    Returns:
      A `CardList` object containing the generic represenations of the cards contained within this inventory.
    '''
    cards = []
    for k, v in self.data.items():
        for _ in range(0, v):
            cards.append(k.to_card(catalog=catalog))
    return CardList(cards)

to_dict()

Converts the inventory object into a raw dictionary of python primitives.

Returns:

Type	Description
dict[str, int]	A raw dict representation of the card inventory.

Source code in fab/inventory.py

def to_dict(self) -> dict[str, int]:
    '''
    Converts the inventory object into a raw dictionary of python
    primitives.

    Returns:
      A raw `dict` representation of the card inventory.
    '''
    data = {}
    for k, v in self.data.items():
        data[k.to_str()] = v
    return data

to_json()

Computes the JSON string representation of the inventory.

Returns:

Type	Description
str	The JSON string representation of the card inventory.

Source code in fab/inventory.py

def to_json(self) -> str:
    '''
    Computes the JSON string representation of the inventory.

    Returns:
      The JSON string representation of the card inventory.
    '''
    return json.dumps(self.to_dict(), indent=JSON_INDENT)