counterparty 0.1.6__py3-none-any.whl

counterparty/parsers/vendorpay/vp_parser.py

@@ -0,0 +1,54 @@
+import re
+
+# 1. NORMALIZATION (shared)
+def normalize_narrative(line: str) -> str:
+    if not line:
+        return ""
+    line = line.strip(",")
+    line = re.sub(r"\s+", " ", line)
+    return line.strip().upper()
+
+
+
+# 2. IDENTIFICATION REGEX
+VENDOR_PAY_RECOGNISE_RE = re.compile(
+    r"\bVENDOR\s+PAY\b.*\b\d+\b$"
+)
+
+
+def is_vendor_pay_narrative(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+    return bool(VENDOR_PAY_RECOGNISE_RE.search(norm))
+
+
+
+# 3. PARSING REGEX
+VENDOR_PAY_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<CTPTY_NAME>.+?)\s+
+    VENDOR\s+PAY\s+
+    (?P<MANAGER_NAME>.+?)\s+
+    (?P<VENDOR_PAY_ID>\d+)
+    $
+    """,
+    re.VERBOSE
+)
+
+
+def parse_vendor_pay_narrative(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    match = VENDOR_PAY_PARSE_RE.search(norm)
+    if not match:
+        return {}
+
+    return {
+        "RAW": line,
+        "ENTITY": match.group("CTPTY_NAME"),
+        "TRANS_TYPE": "VENDOR_PAY",
+        "MANAGER_NAME": match.group("MANAGER_NAME"),
+        "VENDOR_PAY_ID": match.group("VENDOR_PAY_ID"),
+    }

counterparty/parsers/vendorpymt/vpymt_parser.py

@@ -0,0 +1,132 @@
+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()
+
+
+VENDORPYMT_RMR_RE = re.compile(
+    r"VENDORPYMT\s*RMR\*IV\*.+\*\*\d",
+)
+
+VENDORPYMT_REMIT_RECOGNISE_RE = re.compile(
+    r"VENDORPYMT.*RMR\*IV\*"
+)
+
+
+
+def is_vendor_payment_rmr(line: str) -> bool:
+    return bool(VENDORPYMT_RMR_RE.search(normalize_narrative(line)))
+
+
+def is_vendor_payment_remittance(line: str) -> bool:
+    norm = normalize_narrative(line)
+    if not norm:
+        return False
+
+    # exclude invoice+amount version (handled elsewhere)
+    if "**" in norm:
+        return False
+
+    return bool(VENDORPYMT_REMIT_RECOGNISE_RE.search(norm))
+
+
+
+# PARSER REGEX
+VENDORPYMT_RMR_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<COUNTERPARTY_NAME>.+?)
+    [\s\-]*
+    VENDORPYMT\s*RMR(?:\*IV\*)
+    (?P<INVOICE_NO>(?:[A-Z0-9]+\s?)+)
+    \*\*
+    (?P<AMOUNT>(?:\d+\s+)?\d+(?:\.\d{2})?)
+    """,
+    re.VERBOSE
+)
+
+
+
+VENDORPYMT_REMIT_PARSE_RE = re.compile(
+    r"""
+    ^
+    (?P<COUNTERPARTY_NAME>.+?)
+    \s+VENDORPYMT\b
+    \s*
+    (?P<META_BLOCK>.*?)       
+    \s*
+    RMR\*IV\*
+    (?P<REMIT_BLOCK>.+)
+    $
+    """,
+    re.VERBOSE
+)
+
+
+
+INVOICE_RE = re.compile(r"RMR(?:\*IV\*|IV)([A-Z0-9]+)")
+AMOUNT_RE  = re.compile(r"\*\*\s*([\d ]+(?:\.\d{2})?)")
+
+
+# PARSER
+def parse_vendor_payment_rmr(line: str) -> dict:
+    norm = normalize_narrative(line).rstrip("\\")
+    m = VENDORPYMT_RMR_PARSE_RE.search(norm)
+    if not m:
+        return {
+            "RAW": line,
+            "META": norm,
+            "ERROR": "VENDORPYMT_RMR_PARSE_FAILED"
+        }
+
+    raw_amt = m.group("AMOUNT").replace(" ", "")
+    if "." not in raw_amt and len(raw_amt) > 2:
+        amt = f"{int(raw_amt[:-2])}.{raw_amt[-2:]}"
+    else:
+        amt = raw_amt
+
+    invoice_ids = m.group("INVOICE_NO").split()
+
+    return {
+        "RAW": line,
+        "ENTITY": m.group("COUNTERPARTY_NAME").rstrip("- "),
+        "TRANS_TYPE": "VENDOR_PAYMENT_RMR",
+        "INVOICE_NO": invoice_ids,
+        "AMOUNT": amt,
+    }
+
+
+
+def parse_vendor_payment_remittance(line: str) -> dict:
+    norm = normalize_narrative(line)
+
+    m = VENDORPYMT_REMIT_PARSE_RE.search(norm)
+    if not m:
+        return {
+            "RAW": line,
+            "META": norm,
+            "ERROR": "VENDORPYMT_REMIT_PARSE_FAILED"
+        }
+
+    remit_block = m.group("REMIT_BLOCK")
+
+    remit_ids = re.findall(r"\b\d{4,}\b", remit_block)
+
+    return {
+        "RAW": line,
+        "ENTITY": m.group("COUNTERPARTY_NAME").strip(),
+        "TRANS_TYPE": "VENDOR_PAYMENT_REMITTANCE",
+        "VENDOR_META": m.group("META_BLOCK").strip(),
+        "REMITTANCE_IDS": remit_ids,
+        "RAW_REMIT_BLOCK": remit_block
+    }
+
+
+
+if __name__=='__main__':
+    pass

counterparty/parsers/wire/wire_parser.py

@@ -0,0 +1,137 @@
+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 = {' ', ':', '=', '/', '\\', '_', ',', '-'}
+
+WIRE_TOKENS = [
+    ("WIRE TRANSFER", 3),
+    ("FEDWIRE", 3),
+    ("SWIFT", 2),
+    ("BIC", 2),
+    ("IBAN", 2),
+    ("ABA", 2),
+    ("RTN", 2),
+    ("IMAD", 2),
+    ("OMAD", 2),
+    ("FWT", 2),
+    ("WIRE", 1),
+]
+
+WIRE_RE_PARTS = [(re.compile(re.escape(k), re.I), w) for k, w in WIRE_TOKENS]
+
+
+def is_wire(text: str) -> bool:
+    if not text:
+        return False
+
+    t = norm(text)
+
+    structural_hits = 0
+
+    if re.search(r'\bBIC\b|BIC:', t): structural_hits += 2
+    if re.search(r'\bABA\b|ABA:', t): structural_hits += 2
+    if re.search(r'\bIBAN\b|IBAN:', t): structural_hits += 2
+    if re.search(r'\bBNK ID\b|\bBANK ID\b', t): structural_hits += 2
+    if re.search(r'\bINSTG BNK\b|\bINSTD BNK\b', t): structural_hits += 2
+
+    if re.search(r'/[A-Z]{1,4}/[A-Z]{1,4}/', text):
+        structural_hits += 2
+
+    keyword_hits = 0
+    if "WIRE TRANSFER" in t: keyword_hits += 1
+    elif "WIRE" in t: keyword_hits += 0.5
+
+    return structural_hits >= 2 and (structural_hits + keyword_hits) >= 3
+
+
+
+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 wire_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 wire_parser_v2(v1_output: dict):
+    out = {}
+    for k, v in v1_output.items():
+        if 'WIRE' in k or 'SRC' in k:
+            out[k] = v
+        elif isinstance(v, str):
+            out[k] = split_inline_keys(v)
+        else:
+            out[k] = v
+    return out
+
+
+def wire_parser(narr: str):
+    v1 = wire_parser_v1(narr)
+    v2 = wire_parser_v2(v1)
+    return {
+        "RAW": narr,
+        **v2
+    }

counterparty/route.py

@@ -0,0 +1,116 @@
+# routes to respective parsers
+
+from counterparty.parsers.disbursement.disb_parser import parse_disbursement_narrative,is_disbursement_narrative
+from counterparty.parsers.fundsTransfer.fundsTrans_parser import parse_funds_transfer_frmdep,is_funds_transfer_frmdep
+from counterparty.parsers.vendorpay.vp_parser import parse_vendor_pay_narrative,is_vendor_pay_narrative
+from counterparty.parsers.vendorpymt.vpymt_parser import parse_vendor_payment_rmr, parse_vendor_payment_remittance,is_vendor_payment_remittance,is_vendor_payment_rmr
+from counterparty.parsers.avidpay.avidp_check_parser import parse_avidpay_check,is_avidpay_check
+from counterparty.parsers.avidpay.avidp_gen_parser import parse_avidpay_generic,is_avidpay_generic
+from counterparty.parsers.misc.cardp import parse_card_payment,is_card_payment
+from counterparty.parsers.misc.invo import parse_invoice_reference,is_invoice_reference
+from counterparty.parsers.misc.webt import parse_web_transfer,is_web_transfer
+from counterparty.parsers.remittance.remi import parse_remittance_advice,is_remittance_advice
+from counterparty.parsers.merchref.merch_ref_parser import parse_merchant_reference,is_merchant_reference
+from counterparty.parsers.paypal.paypal import parse_paypal,classify_paypal
+from counterparty.parsers.processor_eft.peft import parse_processor_eft,is_processor_eft
+from counterparty.parsers.directdebit.directdeb import parse_direct_debit,is_direct_debit
+from counterparty.parsers.LAT_AM.LAT_AM_Entry import LATAM_parse,is_LATAM
+
+from counterparty.parsers.wire.wire_parser import wire_parser,is_wire
+from counterparty.parsers.ach.ach_parser import ach_parser,is_ach
+from counterparty.parsers.swift.swift_parser import swift_parser,is_swift
+
+from counterparty.parsers.generic.all_parser import all_parser
+
+from counterparty.key_engine.key_detector import KeyDetector
+from counterparty.routines import routine1
+from counterparty.util import normalize_spaces
+
+key_detector = KeyDetector()
+
+def route_to_parser(narr: str):
+    
+    # I call key detector to fix keys before delimiter based parsing
+    rewritten_narr, hitl = key_detector.rewrite(normalize_spaces(narr))
+    
+    # if a new key is found.
+    if hitl: routine1(hitl)
+
+    if is_wire(narr):
+        res = wire_parser(rewritten_narr)
+        res["RAW"] = narr
+        return res, "wire"
+
+    if is_ach(narr):
+        res = ach_parser(rewritten_narr)
+        res["RAW"] = narr
+        return res, "ach"
+
+    if is_swift(narr):
+        res = swift_parser(rewritten_narr)
+        res["RAW"] = narr
+        return res, "swift"
+    
+    #  LATAM 
+    if is_LATAM(narr) is not None:
+        return LATAM_parse(narr), "LATAM"
+
+    #  Paypal
+    if classify_paypal(narr) is not None:
+        return parse_paypal(narr), "PAYPAL"
+
+    #  Disbursement 
+    if is_disbursement_narrative(narr):
+        return parse_disbursement_narrative(narr), "disbursement"
+
+    #  Funds transfer 
+    if is_funds_transfer_frmdep(narr):
+        return parse_funds_transfer_frmdep(narr), "fundstr"
+
+    #  Vendor payments 
+    if is_vendor_payment_remittance(narr):
+        return parse_vendor_payment_remittance(narr), "vpay_remit"
+
+    if is_vendor_payment_rmr(narr):
+        return parse_vendor_payment_rmr(narr), "vpymt"
+
+    if is_vendor_pay_narrative(narr):
+        return parse_vendor_pay_narrative(narr), "vpay"
+
+    #  AvidPay 
+    if is_avidpay_check(narr):
+        return parse_avidpay_check(narr), "avp_check"
+
+    if is_avidpay_generic(narr):
+        return parse_avidpay_generic(narr), "avp_gen"
+
+    #  Card 
+    if is_card_payment(narr):
+        return parse_card_payment(narr), "card"
+
+    #  Invoice / Web 
+    if is_invoice_reference(narr):
+        return parse_invoice_reference(narr), "invo"
+
+    if is_web_transfer(narr):
+        return parse_web_transfer(narr), "webt"
+
+    #  Processor / EFT 
+    if is_processor_eft(narr):
+        return parse_processor_eft(narr), "peft"
+
+    #  Remittance / Merchant 
+    if is_remittance_advice(narr):
+        return parse_remittance_advice(narr), "remi"
+
+    if is_merchant_reference(narr):
+        return parse_merchant_reference(narr), "merch"
+
+    #  Direct Debit 
+    if is_direct_debit(narr):
+        return parse_direct_debit(narr), "ddbt"
+
+
+    res = all_parser(rewritten_narr)
+    res["RAW"] = narr
+    return res, "generic"

counterparty/routines.py

@@ -0,0 +1,72 @@
+import json
+from pathlib import Path
+
+def routine1(data):
+    # print("NEW KEY-VALUE PAIRS DETECTED.")
+    # print(f"ADD THEM TO THE LIST")
+    # for k in data[1]:
+    #     print(f"{k} : {data[1][k]}")
+    # print()
+    pass
+
+
+def routine2(key, value, inline=False):
+    key = key.strip().lower()
+    value = value.strip()
+    if not key or not value:
+        return
+
+    value_up = value.upper()
+
+    base = Path(__file__).resolve().parent     
+    gamma = base.parent                        
+
+    # canonical_keys.json
+    canon_path = gamma / "key_engine" / "canonical_keys.json"
+    with open(canon_path, "r", encoding="utf-8") as f:
+        canon = json.load(f)
+
+    canon.setdefault(key, [])
+    if value.lower() not in canon[key]:
+        canon[key].append(value.lower())
+        with open(canon_path, "w", encoding="utf-8") as f:
+            json.dump(canon, f, indent=2)
+
+    all_path = gamma / "key_engine" / "keys.py"
+    add_to_keys(all_path, value_up, inline)
+
+
+
+def add_to_keys(path, value, inline):
+    text = path.read_text(encoding="utf-8")
+    name = "INLINE_KEYS" if inline else "KEYS"
+
+    start = text.find(f"{name} = [")
+    if start == -1:
+        raise RuntimeError(f"{name} not found in {path}")
+
+    l = text.find("[", start)
+    r = text.find("]", l)
+    if l == -1 or r == -1:
+        raise RuntimeError(f"Broken {name} list in {path}")
+
+    body = text[l + 1:r]
+    items = []
+
+    for x in body.split(","):
+        x = x.strip().strip('"').strip("'")
+        if x:
+            items.append(x)
+
+    if value not in items:
+        items.append(value)
+
+    items = sorted(set(items), key=lambda x: (-len(x), x))
+
+    new_list = f"{name} = [\n"
+    for x in items:
+        new_list += f'    "{x}",\n'
+    new_list += "]"
+
+    text = text[:start] + new_list + text[r + 1:]
+    path.write_text(text, encoding="utf-8")

counterparty/util.py

@@ -0,0 +1,40 @@
+import re
+from typing import Optional, Dict, Any
+import unicodedata
+
+# this is used in extract payer/payee logic
+def norm2(v):
+    if v is None: return None
+    if isinstance(v, dict): v = v.get("value") or v.get("name")
+    s = str(v).strip()
+    s = unicodedata.normalize("NFKD", s)
+    s = s.encode("ascii", "ignore").decode("ascii")
+    s = re.sub(r"\s+", " ", s)
+    return s if s else None
+
+# This one is for aliasing.
+def normalize(text: str) -> str:
+    if not text: return ""
+    text = unicodedata.normalize("NFKD", text)
+    text = text.encode("ASCII", "ignore").decode("ASCII")
+    text = text.upper()
+    text = re.sub(r"[.,/\\]+", " ", text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip()
+
+# This one is for wire/ach/swift detection
+def norm(text: Optional[str]) -> str:
+    if not text: return ""
+    text = re.sub(r"^[,|]+", "", text)
+    text = re.sub(r"[\\|,]+$", "", text)
+    text = re.sub(r"\s+", " ", text)
+    return text.strip().upper()
+
+# This one is when i want to run key_detector
+def normalize_spaces(text: str) -> str:
+    text = text.replace('.','')
+    text = text.replace(',',' ')
+    # add space BEFORE and AFTER delimiter if missing
+    text = re.sub(r"(?<!\s)([:,=;#])", r" \1", text)
+    text = re.sub(r"([:,=;#])(?!\s)", r"\1 ", text)
+    return " ".join(text.split())

counterparty-0.1.6.dist-info/METADATA

@@ -0,0 +1,9 @@
+Metadata-Version: 2.4
+Name: counterparty
+Version: 0.1.6
+Summary: A library for counterparty extraction and narrative parsing.
+Requires-Python: >=3.9
+Requires-Dist: rapidfuzz>=2.0.0
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

counterparty-0.1.6.dist-info/RECORD

@@ -0,0 +1,64 @@
+counterparty/__init__.py,sha256=LfM7ucTBfJhqumdJOT5411VdVG_RpHYvRoA0rvMNkwI,809
+counterparty/route.py,sha256=Al8fLE0l3ITd-s5TMNR3SPp4bNKKfnH0vRmcnAtYzv0,4300
+counterparty/routines.py,sha256=ELA34Pb36RIgzf7A5MRjcnLKCIZTSWQU09RHQPWs8qE,1915
+counterparty/util.py,sha256=3_Zkcoef9U3qxsP38DANDLTj0khQFICRnHWUpOQIkKI,1319
+counterparty/extraction/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/extraction/clean.py,sha256=etNHWosQMM3REi1T6Cap0EZtGvAjxR0F74HWxLj3GoQ,3586
+counterparty/extraction/extract_payer_payee.py,sha256=G92jLvNvLycU2Z9Ub24Rz5CzVXKATuGZaphYbOJlpjM,5296
+counterparty/extraction/infer_counterparty.py,sha256=TmVuiJ0yUHuQUIdQEck9ikrSbp47gJpfu-vq414gGv4,411
+counterparty/key_engine/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/key_engine/canonical_keys.json,sha256=mNQYbLmAwEFq3C5PwkHS3uMKYiBPLVcPpMm4D9HIAlg,5277
+counterparty/key_engine/key_detector.py,sha256=uVbHRTa5gr-_UZ0eFWOGgjXrRjWtNz_XLVF_g4AV9CA,9592
+counterparty/key_engine/keys.py,sha256=ID42R1lh2h_1NajZI0qouokudcPbhz1QeHLXc4JvGyw,6143
+counterparty/parsers/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/LAT_AM/LAT_AM_Entry.py,sha256=ObjjlKDdwzGaiboSFdqTlxDaiPvxNsxPMJe-G6hIofE,2728
+counterparty/parsers/LAT_AM/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/LAT_AM/pattern1.py,sha256=yPCotFTNThl6MhJjauCzwnaS_gUOP7-JJp5UHwa9KHo,3968
+counterparty/parsers/LAT_AM/pattern10.py,sha256=eivRBqSdMrmkgmPX0qvqzG5l4bP6TQps_3bhCQm3gA0,1658
+counterparty/parsers/LAT_AM/pattern11.py,sha256=2UsgNGLxZbEG9VzcfYpXdshwwuqbgP6q24Sq05ysnwI,1516
+counterparty/parsers/LAT_AM/pattern12.py,sha256=fQY1sgBi0RfpwcU2dLMED9I8HLdRPmHm3Yih9VmnPlg,2432
+counterparty/parsers/LAT_AM/pattern2.py,sha256=pmBh06VQ0rh-FI1KFpDEW3_jTqHqtifxjQ4vDl9RSvA,2651
+counterparty/parsers/LAT_AM/pattern3.py,sha256=hHBiUxQ98uOMuC9UHnNobsPg8QN_ylwqSf4GaY521EY,1702
+counterparty/parsers/LAT_AM/pattern4.py,sha256=A_idcKDZSX93mydQJNSzn-ONODZu1pxUINQTUen_Pwg,3401
+counterparty/parsers/LAT_AM/pattern5.py,sha256=C8jc32oga6VDfO_xy9B6A44ZNa4FBXFaaId51DJ4pXo,1106
+counterparty/parsers/LAT_AM/pattern6.py,sha256=xl1vo4mhbjAYSINVGLQf_ZkPRh4-q_Uzhtx1o0eiHro,3535
+counterparty/parsers/LAT_AM/pattern7.py,sha256=MZrQb4ZbmwxDc2Xlt1SV-de9aXqbN_duvBqxWgXn9ww,2783
+counterparty/parsers/LAT_AM/pattern8.py,sha256=Ci9-O_AmzMxToAM8SE2_4FePwOXcvT-K3f3Mqd78sRg,3273
+counterparty/parsers/LAT_AM/pattern9.py,sha256=NOTLM_TdmANXGW77-668iLfesijoHarR62-z2BE92uA,2113
+counterparty/parsers/ach/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/ach/ach_parser.py,sha256=pA6JJw12ry8Hi8Hs7CM2Fsxdv53HLgXe4WFWvtBfbbs,4409
+counterparty/parsers/avidpay/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/avidpay/avidp_check_parser.py,sha256=7usYY7jU4CiaKrS8FGaWhZN2Ls-cmkU3uT7PD9J581g,1825
+counterparty/parsers/avidpay/avidp_gen_parser.py,sha256=jkXviSVukB0SPX-OxQcsAWhfxpgRH7HrQ_zkVJXqLQ4,1435
+counterparty/parsers/directdebit/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/directdebit/directdeb.py,sha256=DxSnukw9421LN_-4oZmxsUmfqxxeh0E8ckqPs0F3ORw,1654
+counterparty/parsers/disbursement/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/disbursement/disb_parser.py,sha256=xwY4ORQfVZpiyGTjd5r7LYJf8oekqfdFQvU4X22Fdc4,1438
+counterparty/parsers/fundsTransfer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/fundsTransfer/fundsTrans_parser.py,sha256=gFv8bdd9CUdvW0bXJdJamnOfSuvmk8PEUfX_se3CqJ4,1838
+counterparty/parsers/generic/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/generic/all_parser.py,sha256=s_mBBJ7x1wOLD9E_IoQ5F9msjbTVSnXr771XZbbrLPc,2272
+counterparty/parsers/merchref/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/merchref/merch_ref_parser.py,sha256=INn6QwjNp4CbSOqejuJhLawYj1Zkn207vwKSeY6dsFA,1022
+counterparty/parsers/misc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/misc/cardp.py,sha256=_cmKZRWqg2Sjay0rkoe1iTZkHuUulSKc5KHPn2nYf9U,1384
+counterparty/parsers/misc/invo.py,sha256=R3UJSPuDusrT_auFvWdgLBISyLj78DqJjwfWQIrt-0M,2066
+counterparty/parsers/misc/webt.py,sha256=YWX7tpWLlQ-wkArS4ihhiRUeEQRh1H843XrtCG5eFig,1259
+counterparty/parsers/paypal/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/paypal/paypal.py,sha256=G_ex6MrIE1QiyUDlXiWXfHU3_uVhEihJ3vdJVNrDoB4,2454
+counterparty/parsers/processor_eft/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/processor_eft/peft.py,sha256=LiQ3rJWQ_9BJWCUJELXXdnQDScifu3060pZuEk10lsk,2686
+counterparty/parsers/remittance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/remittance/remi.py,sha256=tgoJhLLcLWxRmzrkEsyYoMjBCvhFilpg1vs07EdLJ_U,1898
+counterparty/parsers/swift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/swift/swift_parser.py,sha256=szNX55hNIWn82dNwLEnUmvwYq7uw7na7xupYfYyGzSs,2596
+counterparty/parsers/vendorpay/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/vendorpay/vp_parser.py,sha256=uVS5c7K0yMfuDqDYtAt2DZG8WJVHeZ1FoFtXq-Xcs5o,1157
+counterparty/parsers/vendorpymt/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/vendorpymt/vpymt_parser.py,sha256=2ZTzhQXUwBo5iud1IiHYLewPm6PTpu5EBRetV9ctXH8,2953
+counterparty/parsers/wire/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+counterparty/parsers/wire/wire_parser.py,sha256=iy1hwB0yztpYZ0uHKI9daISZgq3kqRQR8C9ZB-18R3w,3412
+counterparty-0.1.6.dist-info/METADATA,sha256=-lcL8pr2To_hxp71eEesdC3TcH0xZoAnnW2R3-_JN3I,246
+counterparty-0.1.6.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+counterparty-0.1.6.dist-info/top_level.txt,sha256=4GalgZH-igUEpExaDNOZUNUANXkbQRu3MnRc8Mcczoc,13
+counterparty-0.1.6.dist-info/RECORD,,

counterparty-0.1.6.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

counterparty-0.1.6.dist-info/top_level.txt

@@ -0,0 +1 @@
+counterparty