counterparty 0.1.6__py3-none-any.whl

counterparty/parsers/ach/ach_parser.py

@@ -0,0 +1,190 @@
+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 = {' ', ':', '=', ',', '/', '\\', '_', '#', '-'}
+
+
+ACH_RE = re.compile(
+    r"\b(ACH|A\.?C\.?H|ODFI|RDFI|TRACE(\s*NO|\s*NUMBER)?|"
+    r"COMPANY\s*ID|ENTRY\s*DESC|DISCRETIONARY|"
+    r"SEC\s*(CCD|PPD|CTX|WEB|TEL|POP)|CCD|PPD|CTX|WEB)\b",
+    re.I
+)
+
+ACH_EXCLUDE_RE = re.compile(
+    r"\b(WIRE|FEDWIRE|FED\s*REF|IMAD|OMAD|UETR|MT\d{3}|"
+    r"SWIFT|IBAN|ORG=|OBK=|IBK=|BBK=|BNF=|CARD|CHECK|RDC)\b",
+    re.I
+)
+
+ACH_RETURN_RE = re.compile(
+    r"\b(ACH\s*RTN|ACH\s*RETURN|RETURNED\s*ACH|ACH\s*REVERSAL)\b",
+    re.I
+)
+
+ACH_RETURN_REASON_RE = re.compile(
+    r"\b(NOT\s*AUTHORIZED|UNAUTHORIZED|CUSTOMER\s*ADVISES|"
+    r"DISPUTE|REVERSAL)\b",
+    re.I
+)
+
+BANK_PREFIX_RE = re.compile(
+    r"^[A-Z][A-Z0-9&.\- ]{3,30}BK\b",
+    re.I
+)
+
+REF_RE = re.compile(
+    r"\b([A-Z]{2,6}\d{5,}|ITD\d+|TRACE\d+)\b",
+    re.I
+)
+
+
+def is_ach(text: str) -> bool:
+    t = norm(text)
+    return bool(t and not ACH_EXCLUDE_RE.search(t) and ACH_RE.search(t))
+
+
+def ach_return_parser(narr: str):
+    t = norm(narr)
+    if not t:
+        return None
+
+    if not ACH_RETURN_RE.search(t):
+        return None
+
+    out = {
+        "RAW": narr,
+        "txn_type": "ACH_RETURN",
+        "rail": "ACH",
+        "category": "BANK_ADJUSTMENT",
+    }
+
+    m = BANK_PREFIX_RE.search(t)
+    if m:
+        out["bank"] = m.group().strip()
+
+    m = ACH_RETURN_REASON_RE.search(t)
+    if m:
+        out["return_reason"] = m.group().upper()
+
+    m = REF_RE.search(t)
+    if m:
+        out["reference"] = m.group()
+
+    try:
+        a = ACH_RETURN_RE.search(t).end()
+        name = t[a:]
+        name = re.sub(r"\b(CUSTOMER\s+ADV\S*|ADV\S*)\b", "", name, flags=re.I)
+        name = re.sub(r"\s{2,}", " ", name).strip(" -:,")
+        if name:
+            out["ENTITY"] = name
+    except Exception:
+        pass
+
+    return out
+
+
+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 normalize_key(k: str):
+    if k in ("REMAR K", "R EMARK", "REMA RK", "REMARK"):
+        return "REMARK"
+    return k
+
+
+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()))
+
+
+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]
+        raw_k = marks[start]
+        k = normalize_key(raw_k)
+
+        z = start + len(raw_k)
+        while z < len(text) and not text[z].isalnum():
+            z += 1
+
+        out[k] = text[z:end].strip()
+
+    return out
+
+
+def ach_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
+
+
+def ach_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]
+        raw_k = marks[start]
+        k = normalize_key(raw_k)
+
+        z = start + len(raw_k)
+        while z < len(narr) and not narr[z].isalnum():
+            z += 1
+
+        out[k] = narr[z:end].strip()
+
+    return out
+
+
+def ach_parser(narr: str):
+    rtn = ach_return_parser(narr)
+    if rtn:
+        return rtn
+
+    v1 = ach_parser_v1(narr)
+    v2 = ach_parser_v2(v1)
+    return {
+        "RAW": narr,
+        **v2
+    }

counterparty/parsers/avidpay/avidp_check_parser.py

@@ -0,0 +1,82 @@
+import re
+
+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()
+
+AVIDPAY_CHECK_RECOGNISE_RE = re.compile(
+    r"(?:^|[\s\-])AVIDPAY(?!.*\bACH\b).*REF\*?CK\*?\d+\*",
+)
+
+
+def is_avidpay_check(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+    return bool(AVIDPAY_CHECK_RECOGNISE_RE.search(norm))
+
+AVIDPAY_CHECK_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<CTPTY_NAME>.+?)
+    [\s\-]*
+    AVIDPAY
+    \s*
+    REF\*?CK\*?(?P<CHECK_NO>\d+)\*
+    (?P<PAYEE>.+?)
+    $
+    """,
+    re.VERBOSE
+)
+
+AVIDPAY_CHECK_CCD_PARSE_RE = re.compile(
+    r"""
+    AVIDPAY
+    .*?
+    REF\*CK\*
+    (?P<CHECK_NO>\d+)
+    \*
+    (?P<PAYEE>.+)
+    $
+    """,
+    re.VERBOSE
+)
+
+
+def parse_avidpay_check(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    # Variant 1: backslash-delimited (existing one)
+    m = AVIDPAY_CHECK_PARSE_RE.search(norm)
+    if m:
+        return {
+            "RAW": line,
+            "TRANS_TYPE": "AVIDPAY_CHECK",
+            "CHECK_NO": m.group("CHECK_NO"),
+            "ENTITY": m.group("PAYEE").strip(),
+            "VARIANT": "LOCKBOX"
+        }
+
+    # Variant 2: CCD / ACH embedded AVIDPAY
+    m = AVIDPAY_CHECK_CCD_PARSE_RE.search(norm)
+    if m:
+        return {
+            "RAW": line,
+            "TRANS_TYPE": "AVIDPAY_CHECK",
+            "CHECK_NO": m.group("CHECK_NO"),
+            "ENTITY": m.group("PAYEE").strip(),
+            "VARIANT": "CCD"
+        }
+
+    return {
+        "RAW": line,
+        "META": norm,
+        "ERROR": "AVIDPAY_CHECK_PARSE_FAILED"
+    }
+
+
+if __name__=='__main__':
+    pass

counterparty/parsers/avidpay/avidp_gen_parser.py

@@ -0,0 +1,59 @@
+import re
+from .avidp_check_parser import is_avidpay_check
+
+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()
+
+AVIDPAY_GENERIC_RECOGNISE_RE = re.compile(
+    r"\bAVIDPAY\b\s+REFCK\d+\*.+$"
+)
+
+def is_avidpay_generic(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+
+    # exclude full check grammar (those are handled earlier)
+    if is_avidpay_check(norm):
+        return False
+
+    return bool(AVIDPAY_GENERIC_RECOGNISE_RE.search(norm))
+
+AVIDPAY_GENERIC_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<COUNTERPARTY_NAME>.+?)\-?
+    AVIDPAY\s+
+    REFCK(?P<CHECK_NO>\d+)
+    \*
+    (?P<PAYEE_NAME>.+)
+    $
+    """,
+    re.VERBOSE
+)
+
+def parse_avidpay_generic(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    m = AVIDPAY_GENERIC_PARSE_RE.search(norm)
+    if not m:
+        return {
+            "RAW": line,
+            "META": norm
+        }
+
+    return {
+        "RAW": line,
+        "FORMAT": "AVIDPAY_GENERIC",
+        "PROCESSOR": "AVIDPAY",
+        "PAYMENT_METHOD": "CHECK",
+        "ENTITY": m.group("COUNTERPARTY_NAME").rstrip("-"),
+        "CHECK_NO": m.group("CHECK_NO"),
+        "PAYEE_NAME": m.group("PAYEE_NAME"),
+        "META": norm
+    }

counterparty/parsers/directdebit/directdeb.py

@@ -0,0 +1,80 @@
+import re
+
+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()
+
+DIRECT_DEBIT_RE = re.compile(
+    r"""
+    \b(
+        DIRECT\s+DEB(IT)? |
+        DIRECT\s+DEBIT |
+        PAYMENT |
+        PYMT |
+        WITHDRAW(AL)? |
+        AUTO(PAY)? |
+        SUBSCRIPT(ION)? |
+        MEMBERSHIP |
+        RENT
+    )\b
+    """,
+    re.VERBOSE
+)
+
+
+DIRECT_DEBIT_EXCLUDE_RE = re.compile(
+    r"""
+    \b(
+        ACH |
+        WIRE |
+        CARD |
+        RDC |
+        CHECK |
+        PAYPAL |
+        AVIDPAY |
+        TRANSACTION REF. |
+        RMR |
+        VENDORPYMT
+    )\b
+    """,
+    re.VERBOSE
+)
+
+def is_direct_debit(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+
+    if DIRECT_DEBIT_EXCLUDE_RE.search(norm):
+        return False
+
+    return bool(DIRECT_DEBIT_RE.search(norm))
+
+REF_RE = re.compile(r"\b[A-Z0-9\-]{6,}\b")
+
+def parse_direct_debit(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    tokens = norm.split()
+
+    counterparty_parts = []
+    for t in tokens:
+        if t in {"DIRECT", "DEBIT", "DEB", "PYMT", "PAYMENT", "PURCHASE"}:
+            break
+        counterparty_parts.append(t)
+
+    counterparty = " ".join(counterparty_parts).strip() or None
+
+    refs = REF_RE.findall(norm)
+
+    return {
+        "RAW": line,
+        "TRANS_TYPE": "DIRECT_DEBIT",
+        "ENTITY": counterparty,
+        "REFERENCE_IDS": refs,
+    }
+

counterparty/parsers/disbursement/disb_parser.py

@@ -0,0 +1,72 @@
+import re
+
+# 1. Normalization (run ONCE before any recognition/parsing)
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.lstrip(",")
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+
+
+# 2. Recognition regex
+DISBURSEMENT_RECOGNISE_RE = re.compile(
+    r"\bDISBURSEME\b\s+\d{6}\s+VAID-\d+(?:VAID-\d+)?"
+)
+
+
+
+def is_disbursement_narrative(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+    return bool(DISBURSEMENT_RECOGNISE_RE.search(norm))
+
+
+# 3. Parsing regex
+DISBURSEMENT_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<CTPTY_NAME>.+?)\s+
+    DISBURSEME\s+
+    (?P<DATE>\d{6})\s+
+    VAID-(?P<VAID>\d+)
+    """,
+    re.VERBOSE
+)
+
+VAID_ALL_RE = re.compile(r"VAID-(\d+)")
+
+DISBURSEMENT_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<CTPTY_NAME>.+?)\s+
+    DISBURSEME\s+
+    (?P<DATE>\d{6})
+    """,
+    re.VERBOSE
+)
+
+def parse_disbursement_narrative(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    m = DISBURSEMENT_PARSE_RE.search(norm)
+    if not m:
+        return {}
+
+    vaids = VAID_ALL_RE.findall(norm)
+
+    return {
+        "RAW": line,
+        "ENTITY": m.group("CTPTY_NAME"),
+        "TRANS_TYPE": "DISBURSEMENT",
+        "VALUE_DATE": m.group("DATE"),
+        "VAID": vaids,              
+    }
+
+
+
+if __name__=='__main__':
+    pass
+

counterparty/parsers/fundsTransfer/fundsTrans_parser.py

@@ -0,0 +1,80 @@
+import re
+
+# 1. NORMALIZATION
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.lstrip(",")
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+
+
+# 2. RECOGNIZER 
+FUNDS_TRANSFER_RECOGNISE_RE = re.compile(
+    r"\b(FUNDS|SWEEP)\b.*\b(TO|FROM|FRMDEP)\b"
+)
+
+def is_funds_transfer_frmdep(line: str) -> bool:
+    return bool(FUNDS_TRANSFER_RECOGNISE_RE.search(normalize_narrative(line)))
+
+
+
+# 3. PARSER 
+FUNDS_TRANSFER_PARSE_RE = re.compile(
+    r"""
+    (?:REF\s+(?P<REF_NO>\w+)\s+)?              
+    (?:FUNDS|SWEEP)\s+
+    (?:TRANSF(?:ER|R)\s+)?                     
+
+    (?:
+        FRMDEP\s+(?P<FROM_ACCOUNT>\d+|[X*]+\d+) |
+        FROM\s+.*?(?P<FROM_ACCOUNT2>\d+|[X*]+\d+) |
+        TO\s+.*?(?P<TO_ACCOUNT>\d+|[X*]+\d+)
+    )
+    """,
+    re.VERBOSE
+)
+
+
+# 4. FEE NORMALIZATION
+def normalize_fee_text(text: str) -> str:
+    t = re.sub(r"\s+", " ", text.upper())
+    t = re.sub(r"\bMONTH\s*LY\b", "MONTHLY", t)
+    t = re.sub(
+        r"\b(MGMT|MGM|MANAG(E|EMENT)?)\s*(FEE|FE|EE)\b",
+        "MANAGEMENT FEE",
+        t
+    )
+    return t.strip()
+
+
+
+# 5. FINAL PARSER
+def parse_funds_transfer_frmdep(line: str) -> dict:
+    norm = normalize_narrative(line)
+    m = FUNDS_TRANSFER_PARSE_RE.search(norm)
+
+    if not m:
+        return {}
+
+    out = {
+        "RAW": line,
+        "TRANS_TYPE": "INTERNAL_FUNDS_TRANSFER",
+    }
+
+    if m.group("REF_NO"):
+        out["REF_NO"] = m.group("REF_NO")
+
+    from_acct = m.group("FROM_ACCOUNT") or m.group("FROM_ACCOUNT2")
+    to_acct = m.group("TO_ACCOUNT")
+
+    if from_acct:
+        out["FROM_ACCOUNT"] = from_acct
+        out["DIRECTION"] = "DEBIT"
+
+    if to_acct:
+        out["TO_ACCOUNT"] = to_acct
+        out["DIRECTION"] = "CREDIT"
+
+    return out

counterparty/parsers/generic/all_parser.py

@@ -0,0 +1,91 @@
+import json
+from counterparty.key_engine.keys import KEYS, INLINE_KEYS
+
+KEYS = sorted(set(KEYS), key=len, reverse=True)
+INLINE_KEYS = sorted(INLINE_KEYS, key=len, reverse=True)
+
+ALLOWED = {' ', ':', '=',',', '/', '\\', '_', '#','-',';','-'}
+
+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()))
+
+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 all_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
+
+
+def all_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
+
+def all_parser(narr: str):
+    v1 = all_parser_v1(narr)
+    v2 = all_parser_v2(v1)
+    return {
+        "RAW": narr,
+        **v2
+    }