Comparison Module

Decklist comparison functionality with enhanced type safety and patterns.

class simulchip.comparison.CardInfo[source]

Bases: object

Detailed information about a card in a decklist.

code: str
title: str
pack_code: str
pack_name: str
type_code: str
faction_code: str
required_count: int
owned_count: int
missing_count: int
property is_identity: bool

Check if this card is an identity.

property is_fully_owned: bool

Check if all required copies are owned.

property ownership_ratio: float

Get ratio of owned to required cards.

__init__(code, title, pack_code, pack_name, type_code, faction_code, required_count, owned_count, missing_count)
Parameters:

  • code (str)

  • title (str)

  • pack_code (str)

  • pack_name (str)

  • type_code (str)

  • faction_code (str)

  • required_count (int)

  • owned_count (int)

  • missing_count (int)

Return type:

None

class simulchip.comparison.DecklistStats[source]

Bases: object

Statistics for a decklist comparison.

total_cards: int = 0
owned_cards: int = 0
missing_cards: int = 0
unique_cards: int = 0
unique_owned: int = 0
unique_missing: int = 0
property completion_percentage: float

Calculate deck completion percentage.

property is_complete: bool

Check if all cards are owned.

__init__(total_cards=0, owned_cards=0, missing_cards=0, unique_cards=0, unique_owned=0, unique_missing=0)
Parameters:

  • total_cards (int)

  • owned_cards (int)

  • missing_cards (int)

  • unique_cards (int)

  • unique_owned (int)

  • unique_missing (int)

Return type:

None

class simulchip.comparison.ComparisonResult[source]

Bases: object

Comprehensive result of comparing a decklist against a collection.

decklist_id: str
decklist_name: str
identity: CardInfo
stats: DecklistStats
cards_by_pack: Dict[str, List[CardInfo]]
cards_by_faction: Dict[str, List[CardInfo]]
missing_cards: List[CardInfo]
owned_cards: List[CardInfo]
all_cards: List[CardInfo]
property identity_title: str

Get identity title for backwards compatibility.

property identity_faction: str

Get identity faction for backwards compatibility.

property total_cards: int

Get total cards for backwards compatibility.

property owned_cards_count: int

Get owned cards count for backwards compatibility.

property missing_cards_count: int

Get missing cards count for backwards compatibility.

property missing_by_pack: Dict[str, List[CardInfo]]

Get missing cards grouped by pack for backwards compatibility.

property owned_by_pack: Dict[str, List[CardInfo]]

Get owned cards grouped by pack for backwards compatibility.

__init__(decklist_id, decklist_name, identity, stats, cards_by_pack=<factory>, cards_by_faction=<factory>, missing_cards=<factory>, owned_cards=<factory>, all_cards=<factory>)
Parameters:
Return type:

None

exception simulchip.comparison.DecklistComparisonError[source]

Bases: Exception

Custom exception for comparison errors.

class simulchip.comparison.DecklistComparer[source]

Bases: object

Compare decklists against local collection with validation.

IDENTITY_TYPE_CODE: Final[str] = 'identity'
__init__(api_client, collection_manager)[source]

Initialize comparer with validation.

Parameters:
Raises:

TypeError – If arguments are of incorrect type

Return type:

None

compare_decklist(decklist_id)[source]

Compare a decklist against local collection with comprehensive analysis.

Parameters:

decklist_id (str) – NetrunnerDB decklist ID

Return type:

ComparisonResult

Returns:

Detailed comparison result

Raises:
get_proxy_cards(comparison_result)[source]

Get list of cards that need proxies.

Parameters:

comparison_result (ComparisonResult) – Result from compare_decklist

Return type:

List[CardInfo]

Returns:

List of cards that need proxies, sorted by pack and title

get_proxy_cards_for_generation(comparison_result, all_cards=False)[source]

Get list of cards for proxy generation with all_cards option.

Parameters:

  • comparison_result (ComparisonResult) – Result from compare_decklist

  • all_cards (bool) – If True, return all cards; if False, return only missing cards

Return type:

List[CardInfo]

Returns:

List of cards for proxy generation

format_comparison_report(comparison_result)[source]

Format comparison result as a readable report.

Parameters:

comparison_result (ComparisonResult) – Result from compare_decklist

Return type:

str

Returns:

Formatted report string

get_pack_requirements(comparison_result)[source]

Get pack requirements for missing cards.

Parameters:

comparison_result (ComparisonResult) – Result from compare_decklist

Return type:

Dict[str, Dict[str, int]]

Returns:

Dictionary mapping pack names to card requirements