monopoly-core 0.9.0__py3-none-any.whl

monopoly/__init__.py

@@ -0,0 +1,3 @@
+from monopoly.log import get_logger
+
+logger = get_logger()

monopoly/banks/__init__.py

@@ -0,0 +1,99 @@
+import logging
+from dataclasses import Field, fields
+from itertools import product
+from typing import Type
+
+from monopoly.constants import EncryptionIdentifier, MetadataIdentifier
+
+from ..examples.example_bank import ExampleBank
+from .base import BankBase
+from .citibank import Citibank
+from .dbs import Dbs
+from .hsbc import Hsbc
+from .ocbc import Ocbc
+from .standard_chartered import StandardChartered
+
+banks: list[Type[BankBase]] = [
+    Citibank,
+    Dbs,
+    ExampleBank,
+    Hsbc,
+    Ocbc,
+    StandardChartered,
+]
+
+logger = logging.getLogger(__name__)
+
+
+class UnsupportedBankError(Exception):
+    """Raised when a processor cannot be found for a specific bank"""
+
+
+def detect_bank(
+    metadata_items: list[EncryptionIdentifier | MetadataIdentifier],
+) -> Type[BankBase] | None:
+    """
+    Reads the encryption metadata or actual metadata (if the PDF is not encrypted),
+    and checks for a bank based on unique identifiers.
+    """
+    for bank in banks:
+        if is_bank_identified(metadata_items, bank):
+            return bank
+    return None
+
+
+def is_bank_identified(
+    metadata_items: list[EncryptionIdentifier | MetadataIdentifier],
+    bank: Type[BankBase],
+) -> bool:
+    """
+    Checks if a bank is identified based on a list of metadata items.
+    """
+    for identifier, metadata in product(
+        bank.identifiers, metadata_items
+    ):  # type: ignore
+        logger.debug(
+            "Comparing bank %s identifier %s against PDF metadata %s",
+            bank.__name__,
+            identifier,
+            metadata,
+        )
+
+        if all(
+            check_matching_field(field, metadata, identifier)
+            for field in fields(metadata)
+        ):
+            logger.debug("Match found for bank %s", bank.__name__)
+            return True
+
+    return False
+
+
+def check_matching_field(
+    field: Field,
+    metadata: EncryptionIdentifier | MetadataIdentifier,
+    identifier: EncryptionIdentifier | MetadataIdentifier,
+) -> bool:
+    """
+    Checks if a field in the metadata matches the corresponding identifier field.
+    """
+    # Only compare matching identifier types
+    if type(metadata) is not type(identifier):
+        return False
+
+    field_value = getattr(metadata, field.name)
+    identifier_value = getattr(identifier, field.name)
+
+    # allow for partial string matching
+    partial_string_match = (
+        isinstance(field.type(), str) and identifier_value in field_value
+    )
+
+    # other types should match exactly
+    full_match = identifier_value == field_value
+
+    if any([partial_string_match, full_match]):
+        logger.debug("Match: %s - %s", identifier_value, field_value)
+        return True
+
+    return False

monopoly/banks/base.py

@@ -0,0 +1,54 @@
+import logging
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from pydantic import SecretStr
+
+from monopoly.config import CreditStatementConfig, DebitStatementConfig, PdfConfig
+from monopoly.constants import EncryptionIdentifier, MetadataIdentifier
+
+logger = logging.getLogger(__name__)
+
+
+class BankBase(ABC):
+    """
+    Abstract class to handle initialization of common variables
+    that are shared between bank processor classes.
+
+    Ensures consistency between bank classes.
+    """
+
+    credit_config: Optional[CreditStatementConfig] = None
+    debit_config: Optional[DebitStatementConfig] = None
+    # pdf_config defaults to an empty object if not overriden
+    pdf_config: PdfConfig = PdfConfig()
+
+    def __init__(self, generic=False):
+        self.validate_config(generic)
+        self.populate_pdf_config()
+
+    def validate_config(self, generic: bool):
+        # Basic validation to ensure required attributes are set
+        if not generic:
+            if self.credit_config is None and self.debit_config is None:
+                raise NotImplementedError(
+                    f"{self.__class__.__name__} "
+                    "must implement either `credit_config` or `debit_config`"
+                )
+
+    def populate_pdf_config(self):
+        # Ensure that PDF config always exists
+        if not self.pdf_config:
+            self.pdf_config = PdfConfig()
+            logger.info(f"{self.__class__.__name__}: Using default `pdf_config`")
+
+    @property
+    @abstractmethod
+    def identifiers(self) -> list[EncryptionIdentifier | MetadataIdentifier]:
+        raise NotImplementedError("Identifiers must be defined")
+
+    @property
+    def passwords(self) -> Optional[list[SecretStr]]:
+        if self.passwords:
+            return self.passwords
+        return None

monopoly/banks/citibank/__init__.py

@@ -0,0 +1,3 @@
+from .citibank import Citibank
+
+__all__ = ["Citibank"]

monopoly/banks/citibank/citibank.py

@@ -0,0 +1,36 @@
+import logging
+
+from monopoly.config import CreditStatementConfig, PdfConfig, passwords
+from monopoly.constants import (
+    BankNames,
+    CreditTransactionPatterns,
+    MetadataIdentifier,
+    StatementBalancePatterns,
+)
+
+from ..base import BankBase
+
+logger = logging.getLogger(__name__)
+
+
+class Citibank(BankBase):
+    credit_config = CreditStatementConfig(
+        bank_name=BankNames.CITIBANK,
+        statement_date_pattern=r"Statement\sDate\s+(.*)",
+        prev_balance_pattern=StatementBalancePatterns.CITIBANK,
+        transaction_pattern=CreditTransactionPatterns.CITIBANK,
+    )
+
+    pdf_config = PdfConfig(
+        page_bbox=(20, 0, 595, 840),
+        page_range=(0, -3),
+    )
+
+    identifiers = [
+        MetadataIdentifier(
+            creator="Ricoh Americas Corporation, AFP2PDF",
+            producer="Ricoh Americas Corporation, AFP2PDF",
+        )
+    ]
+
+    passwords = passwords.citibank_pdf_passwords

monopoly/banks/dbs/__init__.py

@@ -0,0 +1,3 @@
+from .dbs import Dbs
+
+__all__ = ["Dbs"]

monopoly/banks/dbs/dbs.py

@@ -0,0 +1,40 @@
+import logging
+
+from monopoly.config import CreditStatementConfig, DebitStatementConfig
+from monopoly.constants import (
+    BankNames,
+    CreditTransactionPatterns,
+    DebitTransactionPatterns,
+    EncryptionIdentifier,
+    MetadataIdentifier,
+    StatementBalancePatterns,
+)
+
+from ..base import BankBase
+
+logger = logging.getLogger(__name__)
+
+
+class Dbs(BankBase):
+    credit_config = CreditStatementConfig(
+        bank_name=BankNames.DBS,
+        statement_date_pattern=r"(\d{2}\s[A-Za-z]{3}\s\d{4})",
+        multiline_transactions=False,
+        transaction_pattern=CreditTransactionPatterns.DBS,
+        prev_balance_pattern=StatementBalancePatterns.DBS,
+    )
+
+    debit_config = DebitStatementConfig(
+        bank_name=BankNames.DBS,
+        statement_date_pattern=r"(\d{2}\s[A-Za-z]{3}\s\d{4})",
+        multiline_transactions=True,
+        debit_statement_identifier=r"(WITHDRAWAL.*DEPOSIT.*BALANCE)",
+        transaction_pattern=DebitTransactionPatterns.DBS,
+    )
+
+    identifiers = [
+        EncryptionIdentifier(
+            pdf_version=1.4, algorithm=2, revision=3, length=128, permissions=-1852
+        ),
+        MetadataIdentifier(creator="Quadient CXM AG"),
+    ]

monopoly/banks/hsbc/__init__.py

@@ -0,0 +1,3 @@
+from .hsbc import Hsbc
+
+__all__ = ["Hsbc"]

monopoly/banks/hsbc/hsbc.py

@@ -0,0 +1,40 @@
+import logging
+
+from monopoly.config import CreditStatementConfig, PdfConfig, passwords
+from monopoly.constants import (
+    BankNames,
+    CreditTransactionPatterns,
+    EncryptionIdentifier,
+    MetadataIdentifier,
+    StatementBalancePatterns,
+)
+
+from ..base import BankBase
+
+logger = logging.getLogger(__name__)
+
+
+class Hsbc(BankBase):
+    credit_config = CreditStatementConfig(
+        bank_name=BankNames.HSBC,
+        statement_date_pattern=r"Statement From .* to (\d{2}\s[A-Z]{3}\s\d{4})",
+        prev_balance_pattern=StatementBalancePatterns.HSBC,
+        transaction_pattern=CreditTransactionPatterns.HSBC,
+        multiline_transactions=True,
+    )
+
+    pdf_config = PdfConfig(
+        page_bbox=(0, 0, 379, 842),
+    )
+
+    identifiers = [
+        EncryptionIdentifier(
+            pdf_version=1.6, algorithm=4, revision=4, length=128, permissions=-1804
+        ),
+        MetadataIdentifier(
+            title="PRJ_BEAGLE_ST_CNS_SGH_APP_Orchid",
+            creator="OpenText Exstream",
+        ),
+    ]
+
+    passwords = passwords.hsbc_pdf_passwords

monopoly/banks/ocbc/__init__.py

@@ -0,0 +1,3 @@
+from .ocbc import Ocbc
+
+__all__ = ["Ocbc"]

monopoly/banks/ocbc/ocbc.py

@@ -0,0 +1,43 @@
+import logging
+
+from monopoly.config import CreditStatementConfig, DebitStatementConfig, passwords
+from monopoly.constants import (
+    BankNames,
+    CreditTransactionPatterns,
+    DebitTransactionPatterns,
+    EncryptionIdentifier,
+    MetadataIdentifier,
+    StatementBalancePatterns,
+)
+
+from ..base import BankBase
+
+logger = logging.getLogger(__name__)
+
+
+class Ocbc(BankBase):
+    credit_config = CreditStatementConfig(
+        bank_name=BankNames.OCBC,
+        statement_date_pattern=r"(\d{2}\-\d{2}\-\d{4})",
+        prev_balance_pattern=StatementBalancePatterns.OCBC,
+        transaction_pattern=CreditTransactionPatterns.OCBC,
+    )
+
+    debit_config = DebitStatementConfig(
+        bank_name=BankNames.OCBC,
+        statement_date_pattern=r"TO\s(\d+\s[A-Za-z]{3}\s\d{4})",
+        debit_statement_identifier=r"(Withdrawal.*Deposit.*Balance)",
+        transaction_pattern=DebitTransactionPatterns.OCBC,
+        multiline_transactions=True,
+    )
+
+    identifiers = [
+        EncryptionIdentifier(
+            pdf_version=1.4, algorithm=4, revision=4, length=128, permissions=-1036
+        ),
+        MetadataIdentifier(
+            creator="pdfgen", producer="Streamline PDFGen for OCBC Group"
+        ),
+    ]
+
+    passwords = passwords.ocbc_pdf_passwords

monopoly/banks/standard_chartered/__init__.py

@@ -0,0 +1,3 @@
+from .standard_chartered import StandardChartered
+
+__all__ = ["StandardChartered"]

monopoly/banks/standard_chartered/standard_chartered.py

@@ -0,0 +1,36 @@
+import logging
+
+from monopoly.config import CreditStatementConfig, PdfConfig, passwords
+from monopoly.constants import (
+    BankNames,
+    CreditTransactionPatterns,
+    MetadataIdentifier,
+    StatementBalancePatterns,
+)
+
+from ..base import BankBase
+
+logger = logging.getLogger(__name__)
+
+
+class StandardChartered(BankBase):
+    credit_config = CreditStatementConfig(
+        bank_name=BankNames.STANDARD_CHARTERED,
+        statement_date_pattern=r"(\d{2}\s\w+\s\d{4})",
+        prev_balance_pattern=StatementBalancePatterns.STANDARD_CHARTERED,
+        transaction_pattern=CreditTransactionPatterns.STANDARD_CHARTERED,
+    )
+
+    pdf_config = PdfConfig(
+        page_range=(0, -1),
+        page_bbox=(0, 0, 580, 820),
+    )
+
+    identifiers = [
+        MetadataIdentifier(
+            title="eStatement",
+            producer="iText",
+        )
+    ]
+
+    passwords = passwords.standard_chartered_pdf_passwords