counterparty 0.1.6__py3-none-any.whl

counterparty/parsers/LAT_AM/pattern4.py

@@ -0,0 +1,128 @@
+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()
+
+
+# ========================
+# IDENTIFICATION PATTERNS
+# ========================
+pattern4_qrs = re.compile(
+    r"^PIX QRS",
+    re.IGNORECASE
+)
+
+pattern4_qrcode = re.compile(
+    r"PIX.*QR CODE|PIX-RECEB|PIX-ENVIADO|PIX-RECEBIMENTO|PIX DEVOLVID",
+    re.IGNORECASE
+)
+
+
+def is_pattern4(line: str) -> bool:
+    if not line:
+        return False
+    txt = normalize_narrative(line)
+    return bool(pattern4_qrs.search(txt) or pattern4_qrcode.search(txt))
+
+
+# ========================
+# QRS PAYLOAD PARSER
+# ========================
+def parse_qrs_payload(txt: str):
+    raw = txt.replace("PIX QRS", "").strip()
+    tokens = raw.split()
+
+    # 1️⃣ counterparty
+    name = []
+    idx = 0
+    for idx, t in enumerate(tokens):
+        if re.search(r"[0-9/]", t):
+            break
+        name.append(t)
+    counterparty = " ".join(name).strip() if name else None
+
+    # 2️⃣ movement date
+    movement_date = None
+    for t in tokens:
+        m = re.match(r"[A-Z]*([0-9]{2})/([0-9]{2})", t)
+        if m:
+            dd, mm = m.groups()
+            movement_date = f"2025-{mm}-{dd}"
+            break
+
+    # 3️⃣ capture the code + the aux
+    remainder = tokens[len(name):]
+
+    codes = [x for x in remainder if not re.search(r"[A-Z]*[0-9]{2}/[0-9]{2}", x)]
+
+    pix_reference_code = codes[0] if len(codes) >= 1 else None
+    pix_aux_code = codes[1] if len(codes) >= 2 else None
+
+    return counterparty, movement_date, pix_reference_code, pix_aux_code
+
+
+# ========================
+# MAIN PARSER
+# ========================
+def parse_pattern4(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    # ----------------------
+    # QRS static pattern
+    # ----------------------
+    if pattern4_qrs.search(txt):
+        counterparty, movement_date, ref, aux = parse_qrs_payload(txt)
+        return {
+            "ENTITY": counterparty,
+            "payment_system": "PIX",
+            "direction": None,
+            "payment_method": "PIX_QR_STATIC",
+            "transaction_type": "INSTANT_PAYMENT",
+            "movement_date": movement_date,
+            "pix_reference_code": ref,
+            "pix_aux_code": aux
+        }
+
+    # ----------------------
+    # QR directional or devolvido
+    # ----------------------
+    if pattern4_qrcode.search(txt):
+
+        if "DEVOLVID" in txt:
+            direction = "REVERSAL"
+        elif "RECEB" in txt:
+            direction = "INCOMING"
+        elif "ENVIADO" in txt:
+            direction = "OUTGOING"
+        else:
+            direction = None
+
+        payment_method = "QR_CODE" if "QR CODE" in txt else None
+
+        return {
+            "ENTITY": None,
+            "payment_system": "PIX",
+            "direction": direction,
+            "payment_method": payment_method,
+            "transaction_type": "INSTANT_PAYMENT",
+            "movement_date": None,
+            "pix_reference_code": None,
+            "pix_aux_code": None
+        }
+
+    return None
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern5.py

@@ -0,0 +1,54 @@
+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()
+
+
+pattern5 = re.compile(
+    r"^DB.*RV",
+    re.IGNORECASE
+)
+
+
+def is_pattern5(line: str) -> bool:
+    if not line:
+        return False
+    return bool(pattern5.search(normalize_narrative(line)))
+
+
+def parse_pattern5(line: str) -> dict | None:
+    if not line:
+        return None
+    
+    txt = normalize_narrative(line)
+
+    if not is_pattern5(txt):
+        return None
+
+    # capture last numeric token
+    ref = None
+    nums = re.findall(r"[0-9]+", txt)
+    if nums:
+        ref = nums[-1]
+
+    return {
+        "transaction_type": "INTERNAL_REVERSAL",
+        "entry_side": "DEBIT",
+        "is_reversal": True,
+        "ledger_bucket": "CF",
+        "posting_scope": "INTERNAL",
+        "reference_id": ref,
+        "ENTITY": None
+    }
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern6.py

@@ -0,0 +1,141 @@
+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()
+
+
+pattern6 = re.compile(
+    r"^066|^MOV POS",
+    re.IGNORECASE
+)
+
+
+def is_pattern6(line: str) -> bool:
+    if not line:
+        return False
+    return bool(pattern6.search(normalize_narrative(line)))
+
+
+def parse_mov_pos(txt: str) -> dict | None:
+    """
+    Handles: MOV POS IVALEY6380 4747130055
+    → merchant: IVALEY
+    → merchant_id: 4747130055
+    """
+
+    if not txt.startswith("MOV POS"):
+        return None
+
+    parts = txt.split()
+
+    # must have at least: MOV POS <merchant+num> <merchant_id>
+    if len(parts) < 4:
+        return None
+
+    merchant_token = parts[2]
+    merchant_id = None
+
+    # last token must be merchant id (large numeric)
+    tail = parts[-1]
+    if re.match(r"^[0-9]{6,}$", tail):
+        merchant_id = tail
+
+    # strip trailing digits from merchant_token
+    m = re.match(r"([A-Z]+)", merchant_token)
+    merchant = m.group(1) if m else merchant_token
+
+    return {
+        "transaction_type": "CARD_PAYMENT",
+        "direction": "OUTGOING",
+        "channel": "POS",
+        "merchant": merchant,
+        "merchant_id": merchant_id,
+        "card_type": "DEBIT",
+        "card_network": None,
+        "is_ecommerce": False,
+        "is_domestic": True
+    }
+
+
+def parse_pattern6(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    if not is_pattern6(txt):
+        return None
+
+    # MOV POS mode (new feature)
+    if txt.startswith("MOV POS"):
+        return parse_mov_pos(txt)
+
+    # ===== existing 066 mode below =====
+    bank_txn_code = "066"
+    direction = "OUTGOING"
+
+    # POS indicator (with or without dots)
+    pos_match = bool(re.search(r"P\.?O\.?S", txt))
+
+    # SERVICE PAYMENT POS
+    if "PAGO SERVICIO" in txt:
+        return {
+            "transaction_type": "SERVICE_PAYMENT",
+            "direction": direction,
+            "channel": "POS",
+            "payment_instrument": "CARD",
+            "bank_txn_code": bank_txn_code
+        }
+
+    # E-COMMERCE
+    if "E-COMMERCE" in txt:
+        return {
+            "transaction_type": "CARD_PAYMENT",
+            "direction": direction,
+            "card_type": "DEBIT",
+            "channel": "ECOMMERCE",
+            "card_network": None,
+            "is_ecommerce": True,
+            "is_domestic": True,
+            "bank_txn_code": bank_txn_code
+        }
+
+    # POS + BANCARD
+    if pos_match and "BANCARD" in txt:
+        return {
+            "transaction_type": "CARD_PAYMENT",
+            "direction": direction,
+            "card_type": "DEBIT",
+            "channel": "POS",
+            "card_network": "BANCARD",
+            "is_ecommerce": False,
+            "is_domestic": True,
+            "bank_txn_code": bank_txn_code
+        }
+
+    # generic POS
+    if pos_match:
+        return {
+            "transaction_type": "CARD_PAYMENT",
+            "direction": direction,
+            "card_type": "DEBIT",
+            "channel": "POS",
+            "card_network": None,
+            "is_ecommerce": False,
+            "is_domestic": True,
+            "bank_txn_code": bank_txn_code
+        }
+
+    return None
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern7.py

@@ -0,0 +1,116 @@
+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()
+
+
+pattern7 = re.compile(
+    r"TRASPASO",
+    re.IGNORECASE
+)
+
+
+def is_pattern7(line: str) -> bool:
+    if not line:
+        return False
+    txt = normalize_narrative(line)
+    return "TRASPASO" in txt and ("A CTA" in txt or "A CUENTA" in txt)
+
+
+def extract_reference_account(txt: str) -> str | None:
+    m = re.search(r"A CTA\s*:?\s*([0-9]{8,})", txt)
+    return m.group(1) if m else None
+
+
+def extract_tax_amount(txt: str) -> float | None:
+    m = re.search(r"IVA\s+([0-9]+\.[0-9]+)", txt)
+    if not m:
+        return None
+    try:
+        return float(m.group(1))
+    except:
+        return None
+
+
+def extract_beneficiary_account(txt: str) -> str | None:
+    m = re.search(r"A CUENTA\s+([0-9]{8,})", txt)
+    return m.group(1) if m else None
+
+
+def extract_rfc(txt: str) -> str | None:
+    m = re.search(r"RFC\.?([A-Z0-9]+)", txt)
+    if m:
+        return m.group(1)
+    m = re.search(r"R\.F\.C\.?([A-Z0-9]+)", txt)
+    if m:
+        return m.group(1)
+    return None
+
+
+def extract_beneficiary_name(txt: str, acct: str | None) -> str | None:
+    if not acct:
+        return None
+
+    idx = txt.find(acct)
+    if idx == -1:
+        return None
+    tail = txt[idx + len(acct):].strip()
+
+    parts = []
+    for t in tail.split():
+        if t.startswith(("RFC", "R.F.C", "IVA")):
+            break
+        if re.match(r"[0-9]{4,}", t):
+            break
+        parts.append(t)
+
+    if not parts:
+        return None
+
+    return " ".join(parts).strip()
+
+
+def infer_direction(txt: str) -> str:
+    incoming_markers = ["CR", "ABONO", "ACRED", "RECIBIDO", "INGRESO"]
+    for mark in incoming_markers:
+        if mark in txt:
+            return "INCOMING"
+    return "OUTGOING"
+
+
+def parse_pattern7(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    if not is_pattern7(txt):
+        return None
+
+    direction = infer_direction(txt)
+    reference_acct = extract_reference_account(txt)
+    tax_amount = extract_tax_amount(txt)
+    beneficiary_acct = extract_beneficiary_account(txt)
+    rfc = extract_rfc(txt)
+    name = extract_beneficiary_name(txt, beneficiary_acct)
+
+    return {
+        "transaction_type": "ACCOUNT_TRANSFER",
+        "direction": direction,
+        "beneficiary_name": name,
+        "beneficiary_account": beneficiary_acct,
+        "tax_amount": tax_amount,
+        "reference_account": reference_acct,
+        "rfc": rfc
+    }
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern8.py

@@ -0,0 +1,134 @@
+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()
+
+
+pattern8 = re.compile(
+    r"(CONTRACARGO|CHARGEBACK)",
+    re.IGNORECASE
+)
+
+
+def is_pattern8(line: str) -> bool:
+    if not line:
+        return False
+    txt = normalize_narrative(line)
+    return bool(pattern8.search(txt))
+
+
+def extract_merchant(txt: str) -> str | None:
+    """
+    CC D LOCALREST DIDI 08934620 ...
+    → merchant = LOCALREST DIDI
+    """
+    m = re.search(r"CC\s+D\s+(.+?)\s+[0-9]{4,}", txt)
+    if not m:
+        return None
+
+    raw = m.group(1).strip()
+
+    # remove known filler tokens if present
+    banned = {"AFIL.", "CONTRACARGO", "APLICADO"}
+    parts = [w for w in raw.split() if w not in banned]
+
+    merchant = " ".join(parts).strip()
+    return merchant if merchant else None
+
+
+def extract_last4(txt: str) -> str | None:
+    # TARJ.NO.42686031
+    m = re.search(r"TARJ\.NO\.([0-9]{8,})", txt)
+    if not m:
+        return None
+    digits = m.group(1)
+    return digits[-4:]
+
+
+def extract_date(txt: str) -> str | None:
+    # F.TRANS.02-10-2025
+    m = re.search(r"F\.TRANS\.([0-9]{2})-([0-9]{2})-([0-9]{4})", txt)
+    if not m:
+        return None
+    dd, mm, yyyy = m.groups()
+    return f"{yyyy}-{mm}-{dd}"
+
+
+def extract_auth(txt: str) -> str | None:
+    # NO.AUT.379320
+    m = re.search(r"NO\.AUT\.([0-9]+)", txt)
+    return m.group(1) if m else None
+
+
+def extract_reason_code(txt: str) -> str | None:
+    # RAZON 0068
+    m = re.search(r"RAZON\s+([0-9]{4})", txt)
+    return m.group(1) if m else None
+
+
+def extract_reason(txt: str) -> str | None:
+    """
+    Capture all text after reason code until TARJREFERENCIA
+    Example:
+    RAZON 0068 VENTA NO RECONOCIDA POR TARJETAHABIENTE TARJREFERENCIA <num>
+    """
+    m = re.search(
+        r"RAZON\s+[0-9]{4}\s+(.+?)\s+TARJREFERENCIA",
+        txt
+    )
+    if m:
+        return m.group(1).strip()
+
+    # fallback: until end
+    m = re.search(r"RAZON\s+[0-9]{4}\s+(.+)$", txt)
+    if m:
+        return m.group(1).strip()
+
+    return None
+
+
+def extract_reference(txt: str) -> str | None:
+    # TARJREFERENCIA 74518995275208389346204
+    m = re.search(r"TARJREFERENCIA\s+([0-9]+)", txt)
+    return m.group(1) if m else None
+
+
+def parse_pattern8(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    if not is_pattern8(txt):
+        return None
+
+    merchant = extract_merchant(txt)
+    last4 = extract_last4(txt)
+    date = extract_date(txt)
+    auth = extract_auth(txt)
+    reason_code = extract_reason_code(txt)
+    reason = extract_reason(txt)
+    ref = extract_reference(txt)
+
+    return {
+        "transaction_type": "CARD_CHARGEBACK",
+        "direction": "INCOMING",
+        "merchant": merchant,
+        "card_last_digits": last4,
+        "authorization_code": auth,
+        "transaction_date": date,
+        "chargeback_reason_code": reason_code,
+        "chargeback_reason": reason,
+        "network_reference": ref
+    }
+
+
+if __name__ == "__main__":
+    pass

counterparty/parsers/LAT_AM/pattern9.py

@@ -0,0 +1,86 @@
+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()
+
+
+pattern9 = re.compile(
+    r"ACH\s+CREDIT.*CITIDIRECT",
+    re.IGNORECASE
+)
+
+
+def is_pattern9(line: str) -> bool:
+    if not line:
+        return False
+    txt = normalize_narrative(line)
+    return bool(pattern9.search(txt))
+
+
+def extract_our_ref(txt: str) -> str | None:
+    m = re.search(r"OUR REF\s*#\s*([0-9]+)", txt)
+    return m.group(1) if m else None
+
+
+def extract_aba(txt: str) -> str | None:
+    m = re.search(r"RECEIVING BANK\s*#\s*([0-9]+)", txt)
+    return m.group(1) if m else None
+
+
+def extract_receiver_account(txt: str) -> str | None:
+    m = re.search(r"RECEIVER\s*A/C\s*#\s*([0-9]+)", txt)
+    return m.group(1) if m else None
+
+
+def extract_receiver_name(txt: str) -> str | None:
+    # RECEIVER; GLAMOUR GOODS CORP.
+    m = re.search(r"RECEIVER;\s+(.+?)\s+(ADDENDA|RECEIVING|OUR REF|CREDIT|PT/|$)", txt)
+    if m:
+        return m.group(1).strip()
+    return None
+
+
+def extract_addenda(txt: str) -> str | None:
+    # ADDENDA INFORMATION AMAZON/BTN/535428119865
+    m = re.search(r"ADDENDA INFORMATION\s+(.+)$", txt)
+    if m:
+        return m.group(1).strip()
+    return None
+
+
+def parse_pattern9(line: str) -> dict | None:
+    if not line:
+        return None
+
+    txt = normalize_narrative(line)
+
+    if not is_pattern9(txt):
+        return None
+
+    our_ref = extract_our_ref(txt)
+    aba = extract_aba(txt)
+    acct = extract_receiver_account(txt)
+    name = extract_receiver_name(txt)
+    addenda = extract_addenda(txt)
+
+    return {
+        "transaction_type": "ACH_CREDIT",
+        "direction": "OUTGOING",
+        "originating_platform": "CITIDIRECT",
+        "receiving_bank_aba": aba,
+        "receiver_account": acct,
+        "receiver_name": name,
+        "addenda_information": addenda,
+        "our_reference": our_ref
+    }
+
+
+if __name__ == "__main__":
+    pass