counterparty 0.1.6__py3-none-any.whl

counterparty/parsers/merchref/merch_ref_parser.py

@@ -0,0 +1,47 @@
+import re
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.lstrip(",")
+    line = re.sub(r"[,\s]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+MERCHANT_REF_SIMPLE_RE = re.compile(
+    r"^[A-Z0-9 .&'-]+?\s+[A-Z0-9-]{2,}\s+\d{6,}\s+\d{6,}$"
+)
+
+MERCHANT_REF_CONTEXT_RE = re.compile(
+    r"""
+    ^
+    [A-Z .&'-]+
+    (?:\s+[A-Z0-9]{2,})+
+    \s+[A-Z .&]{3,}
+    \s+[A-Z0-9]{6,}
+    $
+    """,
+    re.VERBOSE
+)
+
+def is_merchant_reference(line: str) -> bool:
+    norm = normalize_narrative(line)
+    return bool(
+        MERCHANT_REF_SIMPLE_RE.match(norm)
+        or MERCHANT_REF_CONTEXT_RE.match(norm)
+    )
+
+
+
+def parse_merchant_reference(line: str) -> dict:
+    norm = normalize_narrative(line)
+    parts = norm.split()
+
+    return {
+        "RAW": line,
+        "FORMAT": "MERCHANT_REFERENCE",
+        "ENTITY": " ".join(parts[:-3]),
+        "REFERENCE_BLOCK": " ".join(parts[-3:]),
+    }
+
+

counterparty/parsers/misc/cardp.py

@@ -0,0 +1,61 @@
+import re
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.lstrip(",")
+    line = re.sub(r"[,\s]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+CARD_PAYMENT_RECOGNISE_RE = re.compile(
+    r"""
+    ^[A-Z0-9 .&'-]+
+    \s+
+    (ONLINE|POS)\s+PMT
+    \s+
+    \d{8,}$
+    """,
+    re.VERBOSE
+)
+
+def is_card_payment(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+
+    # hard guard: exclude known rails / processors
+    if any(k in norm for k in (
+        "ACH", "WIRE", "REF ", "VAID", "RMR", "VENDOR", "AVIDPAY", "DISBURSE", "TFR"
+    )):
+        return False
+
+    return bool(CARD_PAYMENT_RECOGNISE_RE.search(norm))
+
+CARD_PAYMENT_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<MERCHANT_NAME>.+?)\s+
+    (?P<CHANNEL>ONLINE|POS)\s+PMT
+    \s+
+    (?P<REFERENCE_ID>\d+)
+    $
+    """,
+    re.VERBOSE
+)
+
+def parse_card_payment(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    m = CARD_PAYMENT_PARSE_RE.search(norm)
+    if not m:
+        return {"META": norm}
+
+    return {
+        "RAW": line,
+        "FORMAT": "CARD_PAYMENT",
+        "ENTITY": m.group("MERCHANT_NAME"),
+        "CHANNEL": m.group("CHANNEL"),
+        "REFERENCE_ID": m.group("REFERENCE_ID"),
+        "META": norm
+    }

counterparty/parsers/misc/invo.py

@@ -0,0 +1,78 @@
+import re
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.lstrip(",")
+    line = re.sub(r"[,\s]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+INVOICE_REFERENCE_RECOGNISE_RE = re.compile(
+    r".+\/INVOICE\s+\w+\s+.+"
+)
+
+INVOICE_ALT_RECOGNISE_RE = re.compile(
+    r"^.+?\s+INVOICE\s+\d{6}\s+[A-Z0-9]+(?:[A-Z0-9]+)?$", 
+    re.IGNORECASE
+)
+
+def is_invoice_reference(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+    return bool(INVOICE_REFERENCE_RECOGNISE_RE.search(norm)) or bool(INVOICE_ALT_RECOGNISE_RE.search(norm))
+
+
+INVOICE_REFERENCE_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<ENTITY_NAME>.+?)\/
+    INVOICE\s+
+    (?P<INVOICE_NO>[A-Z0-9]+)
+    \s+
+    (?P<SERVICE_PROVIDER>.+)
+    $
+    """,
+    re.VERBOSE
+)
+INVOICE_ALT_PARSE_RE = re.compile(
+    r"^(?P<ENTITY_NAME>.+?)\s+INVOICE\s+(?P<DATE>\d{6})\s+(?P<INVOICE_NO>[A-Z0-9]+(?:[A-Z0-9]+)?)$",
+    re.IGNORECASE
+)
+
+def parse_invoice_reference(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    # first try slash /INVOICE format
+    m = INVOICE_REFERENCE_PARSE_RE.search(norm)
+    if m:
+        return {
+            "RAW": line,
+            "FORMAT": "INVOICE_REFERENCE",
+            "ENTITY": m.group("ENTITY_NAME"),
+            "DOCUMENT_TYPE": "INVOICE",
+            "INVOICE_NO": m.group("INVOICE_NO"),
+            "SERVICE_PROVIDER": m.group("SERVICE_PROVIDER"),
+            "META": norm
+        }
+
+    # try alternate format
+    m2 = INVOICE_ALT_PARSE_RE.search(norm)
+    if m2:
+        return {
+            "RAW": line,
+            "FORMAT": "INVOICE_REFERENCE",
+            "ENTITY": m2.group("ENTITY_NAME"),
+            "DOCUMENT_TYPE": "INVOICE",
+            "INVOICE_NO": m2.group("INVOICE_NO"),
+            "DATE": m2.group("DATE"),
+            "META": norm
+        }
+
+    return {
+        "RAW": line,
+        "META": norm, 
+        "ERROR": "INVOICE_PARSE_FAILED"
+    }
+

counterparty/parsers/misc/webt.py

@@ -0,0 +1,55 @@
+import re
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.lstrip(",")
+    line = re.sub(r"[,\s]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+WEB_TRANSFER_RECOGNISE_RE = re.compile(
+    r"\bWEB\s+TFR\s+FR\s+\d+"
+)
+
+def is_web_transfer(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+    return bool(WEB_TRANSFER_RECOGNISE_RE.search(norm))
+
+WEB_TRANSFER_PARSE_RE = re.compile(
+    r"""
+    ^
+    WEB\s+TFR\s+FR\s+
+    (?P<SOURCE_REF>\d+)
+    \s+
+    (?P<DESCRIPTION>.+?)
+    \s+
+    (?P<TRAILING_REFS>(\d+[,\s]?)+)
+    $
+    """,
+    re.VERBOSE
+)
+
+def parse_web_transfer(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    m = WEB_TRANSFER_PARSE_RE.search(norm)
+    if not m:
+        return {
+            "RAW": line,
+            "META": norm
+        }
+
+    refs = re.findall(r"\d+", m.group("TRAILING_REFS"))
+
+    return {
+        "RAW": line,
+        "FORMAT": "WEB_TRANSFER",
+        "CHANNEL": "WEB",
+        "SOURCE_REF": m.group("SOURCE_REF"),
+        "DESCRIPTION": m.group("DESCRIPTION").strip(),
+        "REFERENCE_IDS": refs,
+        "META": norm
+    }

counterparty/parsers/paypal/paypal.py

@@ -0,0 +1,118 @@
+import re
+import json
+
+
+# NORMALIZATION
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = re.sub(r"^[,|]+", "", line)
+    line = re.sub(r"[\\|,]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+
+
+# PAYPAL RECOGNIZERS
+
+PAYPAL_RDC_RE = re.compile(
+    r"\bPAYPAL\b.*\bRDC\b.*\bDEP\s+CR\b",
+    re.IGNORECASE
+)
+
+PAYPAL_ACH_RETURN_PARSE_RE = re.compile(
+    r"""
+    PAYPAL\s+
+    BANKBK\s+
+    IBTRANSFER\s+
+    ACH\s+RTN
+    \s*-\s*
+    (?P<RETURN_DATE>\d{1,2}/\d{1,2}/\d{4})
+    \s*-\s*
+    (?P<TRACE_BLOCK>[\d\s\-]+)
+    """,
+    re.VERBOSE
+)
+
+
+
+# CLASSIFIER
+
+def classify_paypal(line: str) -> str | None:
+    norm = normalize_narrative(line)
+
+    if "PAYPAL" not in norm:
+        return None
+
+    if PAYPAL_ACH_RETURN_PARSE_RE.search(norm):
+        return "PAYPAL_ACH_RETURN"
+
+    if PAYPAL_RDC_RE.search(norm):
+        return "PAYPAL_RDC_DEPOSIT"
+
+    return "PAYPAL_OTHER"
+
+
+
+# PARSERS
+
+
+def parse_paypal_rdc(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    # find 6-digit token for deposit code
+    deposit_code = None
+    m = re.search(r"\b(\d{6})\b", norm)
+    if m:
+        deposit_code = m.group(1)
+
+    return {
+        "RAW": line,
+        "FORMAT": "PAYPAL_RDC_DEPOSIT",
+        "PROCESSOR": "PAYPAL",
+        "RAIL": "RDC",
+        "DIRECTION": "CREDIT",
+        "deposit_code": deposit_code,
+    }
+
+
+def parse_paypal_ach_return(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    m = PAYPAL_ACH_RETURN_PARSE_RE.search(norm)
+    if not m:
+        return {
+            "RAW": line,
+            "META": norm,
+            "ERROR": "PAYPAL_ACH_RETURN_PARSE_FAILED"
+        }
+
+    trace_parts = re.findall(r"\d+", m.group("TRACE_BLOCK"))
+
+    return {
+        "RAW": line,
+        "TRANS_TYPE": "PAYPAL_ACH_RETURN",
+        "RETURN_DATE": m.group("RETURN_DATE"),
+        "TRACE_NUMBERS": trace_parts,
+        "RAW_TRACE_BLOCK": m.group("TRACE_BLOCK"),
+    }
+
+
+def parse_paypal(line: str) -> dict | None:
+    cls = classify_paypal(line)
+
+    if cls == "PAYPAL_RDC_DEPOSIT":
+        return parse_paypal_rdc(line)
+
+    if cls == "PAYPAL_ACH_RETURN":
+        return parse_paypal_ach_return(line)
+
+    if cls == "PAYPAL_OTHER":
+        return {
+            "RAW": line,
+            "FORMAT": "PAYPAL_OTHER",
+        }
+
+    return None
+

counterparty/parsers/processor_eft/peft.py

@@ -0,0 +1,110 @@
+import re
+
+# NORMALIZATION
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.lstrip(",")
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+
+
+# PROCESSOR EFT REGEX (TIGHTENED)
+PROCESSOR_EFT_RECOGNISE_RE = re.compile(
+    r"""
+    ^
+    (?P<proc>[A-Z][A-Z0-9 .,&'-]{0,60})   # processor name
+    \s+
+    (?P<code>[A-Z]{2,6})                  # processor code (min 2 chars)
+    (?P<batch>\d{3,9})?                   # optional batch / id
+    (?:
+        \s+(?P<date>\d{6}) |              # YYMMDD
+        \s+(?P<date_dash>\d{2}-\d{2}-\d{2})
+    )?
+    (?:\s+(?P<refs>[^:]+))?               # refs, no colon allowed
+    $
+    """,
+    re.VERBOSE
+)
+
+
+_BANK_NAME_PATTERNS = [
+    r"PNC",
+    r"CHASE",
+    r"CITI",
+    r"BANK\s+OF\s+AMERICA",
+    r"BOFA",
+    r"WELLS\s+FARGO",
+    r"CAPITAL\s+ONE",
+    r"U\.S\.?BANK",
+    r"US\s+BANK",
+    r"TDBANK",
+    r"TD\s+BANK"
+]
+_BANK_NAME_RE = re.compile(r"^(?:" + r"|".join(_BANK_NAME_PATTERNS) + r")\b")
+
+
+
+# PEFT DETECTION (HARDENED)
+def is_processor_eft(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+
+    if ":" in norm:
+        return False
+
+    if re.search(r"\b(NAME|RECEIVER|SENDER)\b", norm):
+        return False
+
+    if re.search(r"\b(COMP\s+ID|COMPANY\s+ID|MERCHANT)\b", norm):
+        return False
+
+    if re.search(r"\bREMOTE\s+DEPOSIT\b", norm):
+        return False
+
+    if re.search(r"\bMOBILE\s+DEPOSIT\b", norm):
+        return False
+
+    if re.search(r"\bFUNDS\s+TRANSFER\b", norm):
+        return False
+
+    if re.search(r"\bFRMDEP\b", norm):
+        return False
+
+    if re.search(r"\b(ACH|WIRE|FED|RDC|CARD)\b", norm):
+        return False
+
+    if "INTEREST" in norm and _BANK_NAME_RE.match(norm):
+        return False
+
+    # ---- FINAL STRUCTURAL CHECK ----
+    return bool(PROCESSOR_EFT_RECOGNISE_RE.fullmatch(norm))
+
+
+
+# PEFT PARSER
+def parse_processor_eft(line: str) -> dict:
+    norm = normalize_narrative(line)
+    m = PROCESSOR_EFT_RECOGNISE_RE.fullmatch(norm)
+
+    if not m:
+        return {
+            "RAW": line,
+            "META": norm,
+            "ERROR": "PROCESSOR_EFT_PARSE_FAILED"
+        }
+
+    ref_block = m.group("refs") or ""
+    refs = [r for r in re.split(r"[\s,]+", ref_block) if r]
+
+    return {
+        "RAW": line,
+        "TRANS_TYPE": "PROCESSOR_EFT",
+        "ENTITY": m.group("proc").strip(),
+        "PROCESSOR_CODE": m.group("code"),
+        "BATCH_ID": m.group("batch"),
+        "DATE": m.group("date") or m.group("date_dash"),
+        "REFERENCE_IDS": refs,
+    }

counterparty/parsers/remittance/remi.py

@@ -0,0 +1,79 @@
+import re
+
+
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+
+    line = line.lstrip(",")
+    line = re.sub(r"[,\s]+$", "", line)
+    line = re.sub(r"\s+", " ", line)
+
+    return line.strip().upper()
+
+
+# -------------------------------
+# Recognition
+# -------------------------------
+def is_remittance_advice(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+
+    return "TRN*" in norm and "RMR*" in norm
+
+
+# -------------------------------
+# Regexes
+# -------------------------------
+REMITTANCE_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<PREFIX>.*?)
+    \s*
+    TRN\*(?P<TRN_SEQ>\d+)\*(?P<TRN_REF>[^\\]+)
+    \\
+    (?P<RMR_SEGMENT>RMR\*.+)
+    $
+    """,
+    re.VERBOSE,
+)
+
+RMR_REF_RE = re.compile(r"RMR\*[^*]*\*([^\\]+)")
+ID_TOKEN_RE = re.compile(r"\b[A-Z0-9]{8,}\b")
+
+
+# -------------------------------
+# Parser
+# -------------------------------
+def parse_remittance_advice(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    m = REMITTANCE_PARSE_RE.search(norm)
+    if not m:
+        return {
+            "RAW": line,
+            "FORMAT": "REMITTANCE_ADVICE",
+            "META": norm,
+            "ERROR": "REMITTANCE_PARSE_FAILED",
+        }
+
+    rmr_raw = m.group("RMR_SEGMENT")
+
+    # operative entity comes from RMR*
+    cp_match = RMR_REF_RE.search(rmr_raw)
+    entity = cp_match.group(1).strip() if cp_match else None
+
+    # opaque references (no semantic guessing)
+    refs = list(set(ID_TOKEN_RE.findall(norm)))
+
+    return {
+        "RAW": line,
+        "FORMAT": "REMITTANCE_ADVICE",
+        "TRANS_TYPE": "EDI_REMITTANCE_FRAGMENT",
+        "ENTITY": entity,
+        "TRN_SEQUENCE": m.group("TRN_SEQ"),
+        "TRN_REFERENCE": m.group("TRN_REF"),
+        "RMR_RAW": rmr_raw,
+        "REMITTANCE_REFS": refs,
+    }

counterparty/parsers/swift/swift_parser.py

@@ -0,0 +1,97 @@
+import re
+from counterparty.key_engine.keys import KEYS, INLINE_KEYS
+from counterparty.util import norm
+
+KEYS = sorted(set(KEYS), key=len, reverse=True)
+INLINE_KEYS = sorted(INLINE_KEYS, key=len, reverse=True)
+
+ALLOWED = {' ', ':', '=',',', '/', '\\', '_', '#','-'}
+
+SWIFT_RE = re.compile(r"\b(UETR|SWIFT|S\.W\.I\.F\.T|MT(1\d{2}|2\d{2}|9\d{2}))\b|:\d{2}[A-Z]?:", re.I)
+
+def is_swift(text: str) -> bool:
+    t = norm(text)
+    return bool(t and SWIFT_RE.search(t))
+
+
+def is_standalone(text, i, k_len):
+    before = text[i - 1] if i > 0 else ' '
+    after  = text[i + k_len] if i + k_len < len(text) else ' '
+    return before in ALLOWED and after in ALLOWED
+
+
+def find_keys(text, key_list):
+    found = {}
+    reserved = []
+
+    for k in key_list:
+        k_len = len(k)
+        for i in range(len(text) - k_len + 1):
+            if text[i:i + k_len] != k:
+                continue
+            if not is_standalone(text, i, k_len):
+                continue
+            if any(s <= i < e for s, e in reserved):
+                continue
+
+            found[i] = k
+            reserved.append((i, i + k_len))
+
+    return dict(sorted(found.items()))
+
+# V2 — INLINE KEY SPLITTER
+def split_inline_keys(text: str):
+    marks = find_keys(text, INLINE_KEYS)
+    if not marks: return text.strip()
+
+    idx = [0] + list(marks.keys()) + [len(text)]
+    out = {}
+    out["value"] = text[:idx[1]].strip()
+
+    for i in range(1, len(idx) - 1):
+        start, end = idx[i], idx[i + 1]
+        k = marks[start]
+        z = start + len(k)
+        while z < len(text) and not text[z].isalnum():
+            z += 1
+
+        out[k] = text[z:end].strip()
+    return out
+
+
+def swift_parser_v2(v1_output: dict):
+    out = {}
+    for k, v in v1_output.items():
+        if isinstance(v, str):
+            out[k] = split_inline_keys(v)
+        else:
+            out[k] = v
+    return out
+
+# V1 — swift PARSER
+def swift_parser_v1(narr: str):
+    marks = find_keys(narr, KEYS)
+    idx = [0] + list(marks.keys()) + [len(narr)]
+    out = {}
+    out["META"] = narr[:idx[1]].strip()
+    for i in range(1, len(idx) - 1):
+        start, end = idx[i], idx[i + 1]
+        k = marks[start]
+        z = start + len(k)
+        while z < len(narr) and not narr[z].isalnum():
+            z += 1
+        out[k] = narr[z:end].strip()
+
+    return out
+
+# PIPELINE
+def swift_parser(narr: str):
+    v1 = swift_parser_v1(narr)
+    v2 = swift_parser_v2(v1)
+    return {
+        "RAW": narr,
+        **v2
+    }
+
+if __name__ == "__main__":
+    pass