counterparty 0.1.6__py3-none-any.whl

counterparty/parsers/LAT_AM/LAT_AM_Entry.py

@@ -0,0 +1,91 @@
+from counterparty.parsers.LAT_AM.pattern1 import is_pattern1, parse_pattern1
+from counterparty.parsers.LAT_AM.pattern2 import is_pattern2, parse_pattern2
+from counterparty.parsers.LAT_AM.pattern3 import is_pattern3, parse_pattern3
+from counterparty.parsers.LAT_AM.pattern4 import is_pattern4, parse_pattern4
+from counterparty.parsers.LAT_AM.pattern5 import is_pattern5, parse_pattern5
+from counterparty.parsers.LAT_AM.pattern6 import is_pattern6, parse_pattern6
+from counterparty.parsers.LAT_AM.pattern7 import is_pattern7, parse_pattern7
+from counterparty.parsers.LAT_AM.pattern8 import is_pattern8, parse_pattern8
+from counterparty.parsers.LAT_AM.pattern9 import is_pattern9, parse_pattern9
+from counterparty.parsers.LAT_AM.pattern10 import is_pattern10, parse_pattern10
+from counterparty.parsers.LAT_AM.pattern11 import is_pattern11, parse_pattern11
+from counterparty.parsers.LAT_AM.pattern12 import is_pattern12, parse_pattern12
+
+
+def is_LATAM(line: str) -> int | None:
+    if not line:
+        return None
+
+    line = line.strip()
+    if not line:
+        return None
+
+    if is_pattern1(line):
+        return 1
+    if is_pattern2(line):
+        return 2
+    if is_pattern3(line):
+        return 3
+    if is_pattern4(line):
+        return 4
+    if is_pattern5(line):
+        return 5
+    if is_pattern6(line):
+        return 6
+    if is_pattern7(line):
+        return 7
+    if is_pattern8(line):
+        return 8
+    if is_pattern9(line):
+        return 9
+    if is_pattern10(line):
+        return 10
+    if is_pattern11(line):
+        return 11
+    if is_pattern12(line):
+        return 12
+
+    return None
+
+def LATAM_parse(line: str) -> dict | None:
+    
+    pat_no = is_LATAM(line)
+    if pat_no is None:
+        return None
+
+    print(f"LATIN AMERICAN Pattern-{pat_no}\n")
+
+    res = None
+    if pat_no == 1:
+        res = parse_pattern1(line)
+    elif pat_no == 2:
+        res = parse_pattern2(line)
+    elif pat_no == 3:
+        res = parse_pattern3(line)
+    elif pat_no == 4:
+        res = parse_pattern4(line)
+    elif pat_no == 5:
+        res = parse_pattern5(line)
+    elif pat_no == 6:
+        res = parse_pattern6(line)
+    elif pat_no == 7:
+        res = parse_pattern7(line)
+    elif pat_no == 8:
+        res = parse_pattern8(line)
+    elif pat_no == 9:
+        res = parse_pattern9(line)
+    elif pat_no == 10:
+        res = parse_pattern10(line)
+    elif pat_no == 11:
+        res = parse_pattern11(line)
+    elif pat_no == 12:
+        res = parse_pattern12(line)
+
+    if isinstance(res, dict):
+        # Ensure RAW is first key
+        return {
+            "RAW": line,
+            **res
+        }
+
+    return res

counterparty/parsers/LAT_AM/pattern1.py

@@ -0,0 +1,169 @@
+import re
+from typing import Dict, Optional
+
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.upper()
+    line = re.sub(r"^[,|\\]+", "", line)
+    line = re.sub(r"[\\|,]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip()
+
+
+def is_pattern1(line: str) -> bool:
+    return normalize_narrative(line).startswith("/PT/")
+
+
+def is_pattern1a(line: str) -> bool:
+    txt = normalize_narrative(line)
+    return bool(re.match(r"^/PT/DE/EI/", txt))
+
+
+def is_pattern1b(line: str) -> bool:
+    txt = normalize_narrative(line)
+
+    if not txt.startswith("/PT/"):
+        return False
+
+    parts = [p for p in txt.split("/") if p]
+    if len(parts) < 6:
+        return False
+
+    kv = 0
+    i = 1
+    while i + 1 < len(parts):
+        k = parts[i]
+        v = parts[i + 1]
+        if 1 <= len(k) <= 4 and v:
+            kv += 1
+            i += 2
+        else:
+            i += 1
+
+    return kv >= 3
+
+
+def is_pattern1c(line: str) -> bool:
+    txt = normalize_narrative(line)
+    if not txt.startswith("/PT/"):
+        return False
+    return True
+
+
+def detect_pattern1_variant(line: str) -> str:
+    if is_pattern1a(line):
+        return "1A"
+    if is_pattern1b(line):
+        return "1B"
+    if is_pattern1c(line):
+        return "1C"
+    return "UNKNOWN"
+
+
+pattern1a_full = re.compile(
+    r"^/([A-Z/]+)\s+REF\.?\s+(\d+)\s+A\sF/V\s+(.+?)\s+([A-Z0-9]{2,5})\s+([0-9]{2})(?:/([A-Z0-9]{2,10})/([0-9]{1,5})/([A-Z0-9]+))?$",
+    re.IGNORECASE
+)
+
+pattern1a_short = re.compile(
+    r"^/([A-Z/]+)([0-9]+)?(?:[-\s]+(.+))?$",
+    re.IGNORECASE
+)
+
+
+def parse_pattern1a(line: str) -> Optional[Dict]:
+    txt = normalize_narrative(line)
+
+    m = pattern1a_full.match(txt)
+    if m:
+        (
+            flags_raw,
+            reference_id,
+            beneficiary,
+            internal_code,
+            seq_no,
+            tag,
+            code,
+            action
+        ) = m.groups()
+
+        return {
+            "variant": "1A",
+            "transaction_type": "PAYMENT",
+            "flags": [f for f in flags_raw.split("/") if f],
+            "reference_id": reference_id,
+            "beneficiary": beneficiary.strip(),
+            "internal_code": internal_code,
+            "sequence_number": seq_no,
+            "control_tag": tag,
+            "control_code": code,
+            "transaction_action": action,
+        }
+
+    m = pattern1a_short.match(txt)
+    if m:
+        flags_raw, internal_code, detail = m.groups()
+        return {
+            "variant": "1A",
+            "transaction_type": "PAYMENT",
+            "flags": [f for f in flags_raw.split("/") if f],
+            "internal_code": internal_code,
+            "detail": detail,
+        }
+
+    return None
+
+
+def parse_pattern1b(line: str) -> Dict:
+    txt = normalize_narrative(line)
+    parts = [p for p in txt.split("/") if p]
+
+    fields = {}
+    i = 1
+    while i + 1 < len(parts):
+        k = parts[i]
+        v = parts[i + 1]
+        if 1 <= len(k) <= 4:
+            if k not in fields:
+                fields[k] = v.strip()
+            i += 2
+        else:
+            i += 1
+
+    return {
+        "variant": "1B",
+        "transaction_type": "SETTLEMENT",
+        "flags": [parts[0]],
+        **fields
+    }
+
+
+def parse_pattern1c(line: str) -> Dict:
+    txt = normalize_narrative(line)
+    parts = [p for p in txt.split("/") if p]
+
+    return {
+        "variant": "1C",
+        "transaction_type": "PATTERN1_PARTIAL",
+        "tokens": parts
+    }
+
+
+def parse_pattern1(line: str) -> Optional[Dict]:
+    if not is_pattern1(line):
+        return None
+
+    v = detect_pattern1_variant(line)
+
+    if v == "1A":
+        return parse_pattern1a(line)
+
+    if v == "1B":
+        return parse_pattern1b(line)
+
+    if v == "1C":
+        return parse_pattern1c(line)
+
+    return {}

counterparty/parsers/LAT_AM/pattern10.py

@@ -0,0 +1,76 @@
+import re
+import json
+
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.upper()
+    line = re.sub(r"[\\|,]+", " ", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip()
+
+
+pattern10 = re.compile(
+    r"/IDCODE/",
+    re.IGNORECASE
+)
+
+
+def is_pattern10(line: str) -> bool:
+    if not line:
+        return False
+    txt = normalize_narrative(line)
+    return bool(pattern10.search(txt))
+
+
+def extract_payer_id(txt: str) -> str | None:
+    m = re.search(r"/IDCODE/([A-Z0-9]+)/", txt)
+    return m.group(1) if m else None
+
+
+def extract_collection_code(txt: str) -> str | None:
+    m = re.search(r"/COLLEC/([A-Z0-9]+)/", txt)
+    return m.group(1) if m else None
+
+
+def extract_payer_name(txt: str) -> str | None:
+    m = re.search(r"/PAYER/([^/]+)/", txt)
+    if m:
+        return m.group(1).strip()
+    return None
+
+
+def extract_info(txt: str) -> str | None:
+    m = re.search(r"/INFO/(.+)$", txt)
+    if m:
+        return m.group(1).strip()
+    return None
+
+
+def parse_pattern10(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    if not is_pattern10(txt):
+        return None
+
+    payer_id = extract_payer_id(txt)
+    coll = extract_collection_code(txt)
+    name = extract_payer_name(txt)
+    info = extract_info(txt)
+
+    return {
+        "transaction_type": "ACH_COLLECTION",
+        "direction": "INCOMING",
+        "payer_name": name,
+        "payer_id": payer_id,
+        "collection_code": coll,
+        "info_text": info
+    }
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern11.py

@@ -0,0 +1,76 @@
+import re
+import json
+
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.upper()
+    line = re.sub(r"^[,|\\]+", "", line)
+    line = re.sub(r"[\\|,]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip()
+
+
+card_keywords = [
+    "DINERS CLUB",
+    "DINERS",
+    "VISA",
+    "VISANET",
+    "MASTERCARD",
+    "AMEX",
+    "AMERICAN EXPRESS",
+    "DISCOVER",
+    "REDCARD",
+    "PROSA"
+]
+
+
+pattern11 = re.compile(
+    "|".join(card_keywords),
+    re.IGNORECASE
+)
+
+
+def is_pattern11(line: str) -> bool:
+    if not line:
+        return False
+    txt = normalize_narrative(line)
+    return bool(pattern11.search(txt))
+
+
+def extract_posting_code(txt: str) -> str | None:
+    # leading alphanumeric block e.g. 2401DE
+    m = re.match(r"([A-Z0-9]+)", txt)
+    return m.group(1) if m else None
+
+
+def extract_network(txt: str) -> str | None:
+    for w in card_keywords:
+        if w in txt:
+            return w
+    return None
+
+
+def parse_pattern11(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    if not is_pattern11(txt):
+        return None
+
+    posting_code = extract_posting_code(txt)
+    network = extract_network(txt)
+
+    return {
+        "transaction_type": "CARD_PAYMENT",
+        "direction": "OUTGOING",
+        "card_network": network,
+        "posting_code": posting_code
+    }
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern12.py

@@ -0,0 +1,99 @@
+import re
+import json
+
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.upper()
+    line = re.sub(r"[\\|,]+", " ", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip()
+
+
+pattern12 = re.compile(r"\bSPEI\b", re.IGNORECASE)
+
+
+def is_pattern12(line: str) -> bool:
+    if not line:
+        return False
+    txt = normalize_narrative(line)
+    return "SPEI" in txt
+
+
+def infer_direction(txt: str) -> str | None:
+    if any(x in txt for x in ["ENVIADO", "SALIENTE"]):
+        return "OUTGOING"
+    if any(x in txt for x in ["RECIBIDO", "ABONO", "INGRESO"]):
+        return "INCOMING"
+    if any(x in txt for x in ["DEVUELTO", "RECHAZADO", "REVERSO"]):
+        return "RETURNED"
+    return None
+
+
+def extract_reference(txt: str) -> str | None:
+    nums = re.findall(r"\b([0-9]{10,})\b", txt)
+    if not nums:
+        return None
+    return max(nums, key=len)
+
+
+def extract_originating_bank(txt: str) -> str | None:
+    m = re.search(
+        r"SPEI\s+(ENVIADO|SALIENTE|RECIBIDO|ABONO|INGRESO|DEVUELTO|RECHAZADO|REVERSO)\s+(.+?)\s+[0-9]",
+        txt
+    )
+    if m:
+        return m.group(2).strip()
+    return None
+
+
+def extract_counterparty(txt: str, reference: str | None) -> str | None:
+    if not reference:
+        return None
+
+    m = re.search(reference + r"\s+(.+)$", txt)
+    if not m:
+        return None
+
+    tail = m.group(1).strip()
+    tokens = tail.split()
+
+    ctpty = []
+    for t in tokens:
+        # purely numeric long token → stop
+        if re.match(r"^[0-9]{6,}$", t):
+            break
+        # extremely long alphanumeric code → stop
+        if re.match(r"^[A-Z0-9]{12,}$", t):
+            break
+        ctpty.append(t)
+
+    return " ".join(ctpty) if ctpty else None
+
+
+def parse_pattern12(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    if not is_pattern12(txt):
+        return None
+
+    direction = infer_direction(txt)
+    reference = extract_reference(txt)
+    bank = extract_originating_bank(txt)
+    counterparty = extract_counterparty(txt, reference)
+
+    return {
+        "transaction_type": "SPEI_TRANSFER",
+        "direction": direction,
+        "originating_bank": bank,
+        "ENTITY": counterparty,
+        "reference_id": reference
+    }
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern2.py

@@ -0,0 +1,102 @@
+import re
+import json
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.upper()
+    line = re.sub(r"^[,|\\]+", "", line)
+    line = re.sub(r"[\\|,]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip()
+
+pattern2 = re.compile(
+    r"^/[A-Z]{3}/\d{4}-PAGO TRANSFERENCIA",
+    re.IGNORECASE
+)
+
+def is_pattern2(line: str) -> bool:
+    if not line:
+        return False
+    line_n = normalize_narrative(line)
+    return bool(pattern2.search(line_n))
+
+pattern2_parse = re.compile(
+    r"""
+    ^
+    /([A-Z]{3})                 # ledger class
+    /([0-9]{4})-PAGO\sTRANSFERENCIA\s
+    ([A-Z]+)                    # clearing system (SPEI)
+    /([A-Z]+)                   # channel marker (HTC)
+    /([A-Z]+)                   # operation type (TRF)
+    /([A-Z]+)                   # account flag (AIN)
+    /(.+)$                      # data block
+    """,
+    re.IGNORECASE | re.VERBOSE
+)
+
+RESERVED_TOKENS = {"RFC", "IVA", "REF", "TAX", "NUM", "ID"}
+
+def extract_counterparty(raw: str) -> str | None:
+    tokens = raw.split()
+    clean = []
+    for t in tokens:
+        if t in RESERVED_TOKENS:
+            break
+        clean.append(t)
+    if not clean:
+        return None
+    return " ".join(clean).strip()
+
+def extract_rfc(raw: str) -> str | None:
+    match = re.search(r"RFC\s+([A-Z0-9]+)", raw)
+    return match.group(1) if match else None
+
+def extract_iva(raw: str) -> str | None:
+    match = re.search(r"IVA\s+([0-9]+)", raw)
+    return match.group(1) if match else None
+
+def parse_pattern2(line: str) -> dict | None:
+    if not line:
+        return None
+
+    line_n = normalize_narrative(line)
+    match = pattern2_parse.match(line_n)
+    if not match:
+        return None
+
+    (
+        ledger_class,
+        txn_code,
+        clearing_system,
+        channel_marker,
+        op_code,
+        acct_flag,
+        raw
+    ) = match.groups()
+
+    result = {
+        "ledger_class": ledger_class,
+        "transaction_code": txn_code,
+        "transaction_category": "PAYMENT",
+        "transaction_type": "ACCOUNT_TRANSFER",
+        "operation_type": "TRANSFER",
+        "clearing_system": clearing_system,
+        "is_interbank": True,
+        "account_based": (acct_flag == "AIN"),
+        "channel_marker": channel_marker,
+        "ENTITY": extract_counterparty(raw)
+    }
+
+    rfc = extract_rfc(raw)
+    if rfc:
+        result["ENTITY_TAX_ID"] = rfc
+
+    iva = extract_iva(raw)
+    if iva:
+        result["tax_rate"] = iva
+
+    return result
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern3.py

@@ -0,0 +1,75 @@
+import re
+import json
+
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.upper()
+    line = re.sub(r"^[,|\\]+", "", line)
+    line = re.sub(r"[\\|,]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip()
+
+
+pattern3 = re.compile(
+    r"^/?(MERCHANT PAYMENT|TRANSACTION REVERSAL)\s*RRN",
+    re.IGNORECASE
+)
+
+
+def is_pattern3(line: str) -> bool:
+    if not line:
+        return False
+    return bool(pattern3.search(normalize_narrative(line)))
+
+
+pattern3_parse = re.compile(
+    r"""
+    ^/?(MERCHANT\ PAYMENT|TRANSACTION\ REVERSAL)\s*RRN\ 
+    ([0-9]+)              # rrn
+    \s+
+    ([0-9]+)              # merchant id
+    \s+
+    ([0-9]{6})$           # ddmmyy
+    """,
+    re.IGNORECASE | re.VERBOSE
+)
+
+
+def parse_pattern3(line: str) -> dict | None:
+    if not line:
+        return None
+
+    line_n = normalize_narrative(line)
+    match = pattern3_parse.match(line_n)
+    if not match:
+        return None
+
+    prefix, rrn, merchant_id, ddmmyy = match.groups()
+
+    # convert DDMMYY => YYYY-MM-DD
+    day   = ddmmyy[0:2]
+    month = ddmmyy[2:4]
+    year  = "20" + ddmmyy[4:6]
+    date_fmt = f"{year}-{month}-{day}"
+
+    # dynamic classification:
+    if prefix == "TRANSACTION REVERSAL":
+        category = "MERCHANT_REVERSAL"
+        direction = "INCOMING"
+    else:
+        category = "MERCHANT_PAYMENT"
+        direction = "OUTGOING"
+
+    return {
+        "transaction_category": category,
+        "direction": direction,
+        "rrn": rrn,
+        "merchant_id": merchant_id,
+        "processing_date": date_fmt
+    }
+
+
+if __name__ == "__main__":
+    pass