miso20022 0.1.0__py3-none-any.whl

miso20022/__init__.py

@@ -0,0 +1,34 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+ISO 20022 data models package.
+"""
+
+from dataclasses import asdict
+from miso20022.bah.apphdr import AppHdr
+from miso20022.pacs import Document, FIToFICstmrCdtTrf
+from miso20022.helpers import dict_to_xml
+
+def model_to_xml(model, prefix=None, namespace=None):
+    """Convert model to XML using the dictionary-based approach."""
+    if hasattr(model, 'to_dict'):
+        xml_dict = model.to_dict()
+    else:
+        xml_dict = asdict(model)
+        if prefix and namespace:
+            xml_dict = {
+                "Document": {
+                    f"@xmlns:{prefix}": namespace,
+                    **xml_dict
+                }
+            }
+    return dict_to_xml(xml_dict, prefix=prefix, namespace=namespace)
+
+
+__all__ = [
+    "AppHdr",
+    "Document",
+    "FIToFICstmrCdtTrf",
+    "dict_to_xml",
+    "model_to_xml",
+]

miso20022/cli.py

@@ -0,0 +1,107 @@
+# SPDX-License-Identifier: Apache-2.0
+
+import argparse
+import json
+import os
+import sys
+from datetime import datetime
+from typing import Dict, Any
+
+from miso20022.fedwire import generate_fedwire_message, generate_fedwire_payload
+
+def load_input_payload(input_file_path: str) -> Dict[str, Any]:
+    """Load a input payload from a JSON file."""
+    try:
+        with open(input_file_path, 'r') as file:
+            return json.load(file)
+    except Exception as e:
+        print(f"Error loading input file: {e}", file=sys.stderr)
+        sys.exit(1)
+
+def write_message_to_file(message: str, output_file: str) -> bool:
+    """Write the generated message to a file."""
+    try:
+        with open(output_file, 'w') as file:
+            file.write(message)
+        print(f"Message successfully written to {output_file}")
+        return True
+    except Exception as e:
+        print(f"Error writing message to file: {e}", file=sys.stderr)
+        return False
+
+def generate_output_filename(message_code: str, extension: str) -> str:
+    """Generate a default output filename."""
+    message_type = message_code.split(':')[-1]
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    return f"{message_type}_{timestamp}.{extension}"
+
+def handle_generate(args):
+    """Handler for the 'generate' command."""
+    xsd_path = os.path.abspath(args.xsd_file)
+    if not os.path.exists(xsd_path):
+        print(f"Error: XSD file not found at {xsd_path}", file=sys.stderr)
+        sys.exit(1)
+
+    input_path = os.path.abspath(args.input_file)
+    if not os.path.exists(input_path):
+        print(f"Error: Input file not found at {input_path}", file=sys.stderr)
+        sys.exit(1)
+
+    payload = load_input_payload(input_path)
+    _, _, complete_message = generate_fedwire_message(args.message_code, args.environment, args.fed_aba, payload, xsd_path)
+
+    if complete_message:
+        output_file = args.output_file or generate_output_filename(args.message_code, 'xml')
+        write_message_to_file(complete_message, output_file)
+    else:
+        print("Failed to generate complete message", file=sys.stderr)
+        sys.exit(1)
+
+def handle_parse(args):
+    """Handler for the 'parse' command."""
+    if not os.path.exists(args.input_file):
+        print(f"Error: Input file not found at {args.input_file}", file=sys.stderr)
+        sys.exit(1)
+
+    payload = generate_fedwire_payload(args.input_file, args.message_code)
+
+    if payload:
+        output_file = args.output_file or generate_output_filename(args.message_code, 'json')
+        try:
+            with open(output_file, 'w') as f:
+                json.dump(payload, f, indent=4)
+            print(f"Payload successfully written to {output_file}")
+        except Exception as e:
+            print(f"Error writing payload to file: {e}", file=sys.stderr)
+            sys.exit(1)
+    else:
+        print("Failed to parse XML file.", file=sys.stderr)
+        sys.exit(1)
+
+def main():
+
+    parser = argparse.ArgumentParser(description='A CLI tool for generating and parsing ISO 20022 messages.')
+    subparsers = parser.add_subparsers(dest='command', required=True, help='Available commands')
+
+    # Generate command
+    gen_parser = subparsers.add_parser('generate', help='Generate a complete ISO 20022 message.')
+    gen_parser.add_argument('--message_code', help='ISO 20022 message code (e.g., urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08)')
+    gen_parser.add_argument('--environment', required=True, choices=['TEST', 'PROD'], help='The environment for the message (TEST or PROD).')
+    gen_parser.add_argument('--fed-aba', required=True, help='The Fed ABA number for message generation.')
+    gen_parser.add_argument('--input-file', required=True, help='Path to input JSON payload file.')
+    gen_parser.add_argument('--output-file', help='Path to output XML file.')
+    gen_parser.add_argument('--xsd-file', required=True, help='Path to the XSD file.')
+    gen_parser.set_defaults(func=handle_generate)
+
+    # Parse command
+    parse_parser = subparsers.add_parser('parse', help='Parse an ISO 20022 XML file into a JSON payload.')
+    parse_parser.add_argument('--input-file', required=True, help='Path to the XML file to parse.')
+    parse_parser.add_argument('--message-code', required=True, help='The message code to determine the parsing model.')
+    parse_parser.add_argument('--output-file', help='Path to output JSON file.')
+    parse_parser.set_defaults(func=handle_parse)
+
+    args = parser.parse_args()
+    args.func(args)
+
+if __name__ == '__main__':
+    main()

miso20022/fedwire.py

@@ -0,0 +1,389 @@
+# SPDX-License-Identifier: Apache-2.0
+
+import sys
+import re
+import json
+import xml.etree.ElementTree as ET
+from typing import Dict, Any, Tuple, Optional, List, Union
+from datetime import datetime
+
+# Fix imports to use the correct package structure
+from miso20022.bah.apphdr import AppHdr
+from miso20022.pacs.pacs008 import Document as Pacs008Document 
+from miso20022.pacs.pacs028 import Document as Pacs028Document
+from miso20022.pacs.pacs002 import FIToFIPmtStsRpt
+from miso20022.pacs.pacs008 import FIToFICstmrCdtTrf
+from miso20022.helpers import dict_to_xml
+from miso20022.helpers import parse_xml_to_json
+
+def parse_message_envelope(xsd_path, message_code):
+    """
+    Parse the XSD file and return data for a specific message code.
+    
+    Args:
+        xsd_path: Path to the XSD file
+        message_code: The specific message code to return data for (required)
+        
+    Returns:
+        A tuple containing (element_name, target_ns, root_element_name, message_container_name) for the specified message code
+        
+    Raises:
+        ValueError: If message_code is not provided or not found in the XSD file
+    """
+    # Check if message_code is provided
+    if not message_code:
+        raise ValueError("message_code parameter is required")
+    
+    # Define the namespaces
+    namespaces = { 
+        'xs': 'http://www.w3.org/2001/XMLSchema'
+    }
+    
+    # Parse the XSD file
+    try:
+        # Read the file content directly to extract namespace declarations
+        with open(xsd_path, 'r') as file:
+            content = file.read()
+            
+        # Extract namespace declarations using regex
+        ns_mapping = {}
+        ns_pattern = r'xmlns:([a-zA-Z0-9]+)="([^"]+)"'
+        for match in re.finditer(ns_pattern, content):
+            prefix, uri = match.groups()
+            ns_mapping[prefix] = uri
+            
+        # Now parse the file with ElementTree
+        tree = ET.parse(xsd_path)
+        root = tree.getroot()
+    except Exception as e:
+        print(f"Error parsing XSD file: {e}")
+        sys.exit(1)
+    
+    # Extract the target namespace
+    target_ns = root.get('targetNamespace')
+    if not target_ns:
+        print("Error: XSD file does not have a target namespace.")
+        sys.exit(1)
+        
+    # Add the target namespace to our namespaces dictionary
+    namespaces['tns'] = target_ns
+    
+    # Find the root element and message container element
+    root_elements = []
+    for element in root.findall('.//xs:element', namespaces):
+        name = element.get('name')
+        if name:
+            root_elements.append(name)
+    
+    # Determine the root element (usually the first one defined)
+    root_element_name = root_elements[0] if root_elements else None
+    
+    # Determine the message container element (usually the second one defined)
+    message_container_name = root_elements[2] if len(root_elements) > 2 else (root_elements[1] if len(root_elements) > 1 else None)
+    
+    # Find all elements that could be message types
+    for element in root.findall('.//xs:element', namespaces):
+        name = element.get('name')
+        # Skip the root elements and technical headers
+        if (name and 
+            name != root_element_name and 
+            name != message_container_name and
+            not name.endswith('TechnicalHeader')):
+            
+            # Check if this element has child elements that include Document
+            has_document = False
+            for seq in element.findall('.//xs:sequence', namespaces):
+                for child in seq.findall('.//xs:element', namespaces):
+                    ref = child.get('ref')
+                    if ref and 'Document' in ref:
+                        has_document = True
+                        break
+            
+            if has_document:
+                # This is a message type element
+                
+                # Find the child elements to determine which message code it uses
+                for seq in element.findall('.//xs:sequence', namespaces):
+                    for child in seq.findall('.//xs:element', namespaces):
+                        ref = child.get('ref')
+                        if ref:
+                            try:
+                                prefix, local_name = ref.split(':')
+                                if prefix in ns_mapping:
+                                    namespace = ns_mapping[prefix]
+                                    if local_name == 'Document':
+                                        # Extract the message code from the namespace
+                                        current_message_code = namespace
+                                        
+                                        # If we found the requested message code, return the data
+                                        if current_message_code == message_code:
+                                            return name, target_ns, root_element_name, message_container_name
+                            except ValueError:
+                                # Skip refs that don't have a prefix
+                                continue
+    
+    # If we've gone through all elements and haven't found the message code, raise an error
+    raise ValueError(f"Message code '{message_code}' not found in the XSD file.")
+
+def generate_message_structure(app_hdr_xml, document_xml, name, target_ns, root_element_name, message_container_name):
+    """
+    Generate the message structure for a given message code.
+    
+    Args:
+        app_hdr_xml: The AppHdr XML
+        document_xml: The Document XML
+        name: The element name
+        target_ns: The target namespace
+        root_element_name: The root element name
+        message_container_name: The message container name
+        
+    Returns:
+        The XML structure as a string
+    """
+    # Create the XML structure
+    app_hdr_lines = app_hdr_xml.strip().split('\n')
+    document_lines = document_xml.strip().split('\n')
+    
+    # Indent the lines properly
+    app_hdr_indented = '\n        '.join(app_hdr_lines)
+    document_indented = '\n        '.join(document_lines)
+    
+    complete_structure = f"""<{root_element_name} xmlns="{target_ns}">
+  <{message_container_name}>
+    <{name}>
+        {app_hdr_indented}
+        {document_indented}
+    </{name}>
+  </{message_container_name}>
+</{root_element_name}>"""
+    
+    return complete_structure
+
+def generate_fedwire_message(message_code: str, environment: str, fed_aba: str, payload: Dict[str, Any], xsd_path: str) -> Tuple[Optional[str], Optional[str], Optional[str]]:
+    """
+    Generate a complete ISO20022 message using the models from miso20022.
+    
+    Args:
+        message_code: The ISO20022 message code (e.g., urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08).
+        environment: The environment for the message, either "TEST" or "PROD".
+        fed_aba: The Fed ABA number for message generation.
+        payload: The payload data as a dictionary.
+        xsd_path: Path to the XSD file for structure identification.
+        
+    Returns:
+        Tuple of (AppHdr XML, Document XML, Complete Structure XML) or (None, None, None) if not supported.
+    """
+    # Extract the message type from the message code
+    message_type = message_code.split(':')[-1]
+    
+    try:
+        # Generate AppHdr
+        app_hdr = AppHdr.from_payload(environment, fed_aba, message_code, payload)
+        app_hdr_dict = app_hdr.to_dict()
+        app_hdr_xml = dict_to_xml(app_hdr_dict, "head", "urn:iso:std:iso:20022:tech:xsd:head.001.001.03")
+        
+        # Generate Document based on message type
+        document_xml = None
+        
+        # Only support pacs.008 and pacs.028 message types
+        if "pacs.008" in message_type:
+            try:
+                # Use the specific model for pacs.008
+                document = Pacs008Document.from_payload(payload)
+                document_dict = document.to_dict()
+                document_xml = dict_to_xml(document_dict, "pacs", message_code)
+            except Exception as e:
+                print(f"Error generating pacs.008 structure: {e}")
+                return None, None, None
+                
+        elif "pacs.028" in message_type:
+            try:
+                document = Pacs028Document.from_payload(payload)
+                document_dict = document.to_dict()
+                document_xml = dict_to_xml(document_dict, "pacs", message_code)
+                print(f"Generated structure for pacs.028 message type using model")
+            except Exception as e:
+                print(f"Error generating pacs.028 structure: {e}")
+                print("Make sure you're providing the correct payload structure for pacs.028")
+                return None, None, None
+        else:
+            # All other message types are unsupported
+            print(f"Message type {message_type} is not currently supported for generation.")
+            return None, None, None
+        
+        # Generate the complete structure
+        complete_structure = None
+        try:
+            # Get the specific message data - use full message_code, not just message_type
+            element_name, target_ns, root_element_name, message_container_name = parse_message_envelope(xsd_path, message_code)
+            
+            # Create the complete XML structure with the actual generated content
+            app_hdr_lines = app_hdr_xml.strip().split('\n')
+            document_lines = document_xml.strip().split('\n')
+            
+            # Indent the lines properly
+            app_hdr_indented = '\n        '.join(app_hdr_lines)
+            document_indented = '\n        '.join(document_lines)
+            
+            complete_structure = f"""<{root_element_name} xmlns="{target_ns}">
+  <{message_container_name}>
+    <{element_name}>
+        {app_hdr_indented}
+        {document_indented}
+    </{element_name}>
+  </{message_container_name}>
+</{root_element_name}>"""
+        except ValueError as e:
+            print(f"Error generating complete structure: {e}")
+            return None, None, None
+        
+        return app_hdr_xml, document_xml, complete_structure
+        
+    except Exception as e:
+        print(f"Error generating message: {e}")
+        return None, None, None
+
+def get_account_number(Acct):
+    """Safely retrieves the account number from an Acct object."""
+    if not Acct or not hasattr(Acct, 'Id') or not Acct.Id:
+        return ""
+    # Prioritize Other ID if available
+    if hasattr(Acct.Id.Othr, 'Id') and Acct.Id.Othr.Id:
+        return Acct.Id.Othr.Id
+
+    # Fallback to IBAN
+    if hasattr(Acct.Id, 'IBAN') and Acct.Id.IBAN:
+        return Acct.Id.IBAN
+
+    return ""
+
+def pacs_008_to_fedwire_json    (app_hdr, cdt_trf_tx_inf, grp_hdr_data):
+    """Maps AppHdr and CdtTrfTxInf data classes to the Fedwire JSON format. Supports PACS008 Only"""
+
+    # Helper to safely extract address lines
+    def get_adr_line(pstl_adr, index):
+        if not pstl_adr:
+            return ""
+
+        constructed_line = ""
+        
+        if index == 0:  # Line 1: Street Name and Building Number
+            line_parts = filter(None, [pstl_adr.StrtNm, pstl_adr.BldgNb])
+            constructed_line = " ".join(line_parts).strip()
+        elif index == 1:  # Line 2: Floor and Room
+            flr_part = f"Flr {pstl_adr.Flr}" if pstl_adr.Flr else None
+            room_part = pstl_adr.Room
+            line_parts = filter(None, [flr_part, room_part])
+            constructed_line = ", ".join(line_parts).strip()
+        elif index == 2:  # Line 3: Town, State/Province PostalCode, Country
+            town_part = pstl_adr.TwnNm
+            # Combine State/Province and Postal Code, e.g., "CA 90210" or "CA" or "90210"
+            state_zip_part = " ".join(filter(None, [pstl_adr.CtrySubDvsn, pstl_adr.PstCd])).strip()
+            country_part = pstl_adr.Ctry
+            
+            # Combine all parts of Line 3 with commas, filtering out empty ones
+            all_line3_parts = filter(None, [town_part, state_zip_part, country_part])
+            constructed_line = ", ".join(all_line3_parts).strip()
+        
+        # Return the constructed line if not empty, otherwise fallback to AdrLine
+        if constructed_line:
+            return constructed_line
+        elif pstl_adr.AdrLine and len(pstl_adr.AdrLine) > index and pstl_adr.AdrLine[index]:
+            return pstl_adr.AdrLine[index] # Return AdrLine if it's not empty
+        else:
+            return ""
+
+    fedwire_message = {
+        "fedWireMessage": {
+            "inputMessageAccountabilityData": {
+                "inputCycleDate": grp_hdr_data.MsgId[:8],
+                "inputSource": grp_hdr_data.MsgId[8:13],
+                "inputSequenceNumber": grp_hdr_data.MsgId[13:]
+            },
+            "amount": {
+                "amount": str(int(float(cdt_trf_tx_inf.IntrBkSttlmAmt['#text'])))
+            },
+            "senderDepositoryInstitution": {
+                "senderABANumber": cdt_trf_tx_inf.InstgAgt.FinInstnId.ClrSysMmbId.MmbId,
+                "senderShortName": cdt_trf_tx_inf.DbtrAgt.FinInstnId.Nm or ""
+            },
+            "receiverDepositoryInstitution": {
+                "receiverABANumber": cdt_trf_tx_inf.InstdAgt.FinInstnId.ClrSysMmbId.MmbId,
+                "receiverShortName": cdt_trf_tx_inf.CdtrAgt.FinInstnId.Nm or ""
+            },
+            "originator": {
+                "personal": {
+                    "name": cdt_trf_tx_inf.Dbtr.Nm,
+                    "address": {
+                        "addressLineOne": get_adr_line(cdt_trf_tx_inf.Dbtr.PstlAdr, 0),
+                        "addressLineTwo": get_adr_line(cdt_trf_tx_inf.Dbtr.PstlAdr, 1),
+                        "addressLineThree": get_adr_line(cdt_trf_tx_inf.Dbtr.PstlAdr, 2)
+                    },
+                    "identifier": get_account_number(cdt_trf_tx_inf.DbtrAcct)
+                }
+            },
+            "beneficiary": {
+                "personal": {
+                    "name": cdt_trf_tx_inf.Cdtr.Nm,
+                    "address": {
+                        "addressLineOne": get_adr_line(cdt_trf_tx_inf.Cdtr.PstlAdr, 0),
+                        "addressLineTwo": get_adr_line(cdt_trf_tx_inf.Cdtr.PstlAdr, 1),
+                        "addressLineThree": get_adr_line(cdt_trf_tx_inf.Cdtr.PstlAdr, 2)
+                    },
+                    "identifier": get_account_number(cdt_trf_tx_inf.CdtrAcct)
+                }
+            }
+        }
+    }
+    return fedwire_message
+
+
+def pacs_002_to_fedwire_json(app_hdr, pmt_sts_req):
+    """Maps AppHdr and FIToFIPmtStsRpt data classes to the Fedwire JSON format."""
+
+    #TODO: Add status and reason
+    fedwire_message = {
+        "fedWireMessage": {
+            "inputMessageAccountabilityData": {
+                "inputCycleDate": pmt_sts_req.TxInfAndSts.OrgnlGrpInf['OrgnlMsgId'][:8],
+                "inputSource": pmt_sts_req.TxInfAndSts.OrgnlGrpInf['OrgnlMsgId'][8:13],
+                "inputSequenceNumber": pmt_sts_req.TxInfAndSts.OrgnlGrpInf['OrgnlMsgId'][13:]
+            },
+            "outputMessageAccountabilityData": {
+                "outputCycleDate": pmt_sts_req.GrpHdr.MsgId[:8],
+                "outputSource": pmt_sts_req.GrpHdr.MsgId[8:13],
+                "outputSequenceNumber": pmt_sts_req.GrpHdr.MsgId[13:]
+            }
+        }
+    }
+    return fedwire_message
+    
+
+def generate_fedwire_payload(xml_file, message_code):
+
+    # 1. Parse the XML file to JSON
+    json_output = parse_xml_to_json(xml_file)
+    data = json.loads(json_output)
+
+    # 2. Instantiate the AppHdr & CdtTrfTxInf data class
+    
+    if message_code == "urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08":
+
+        app_hdr_instance = AppHdr.from_iso20022(data,message_code)
+        grp_hdr_data, cdt_trf_tx_inf = FIToFICstmrCdtTrf.from_iso20022(data)
+
+        # 3. Map to Fedwire JSON format
+        fedwire_json = pacs_008_to_fedwire_json(app_hdr_instance, cdt_trf_tx_inf, grp_hdr_data)
+
+    elif message_code == "urn:iso:std:iso:20022:tech:xsd:pacs.002.001.10":
+
+        app_hdr_instance = AppHdr.from_iso20022(data,message_code)
+        pmt_sts_req= FIToFIPmtStsRpt.from_iso20022(data)
+        
+        # 3. Map to Fedwire JSON format
+        fedwire_json = pacs_002_to_fedwire_json(app_hdr_instance, pmt_sts_req)
+
+    else:
+        raise ValueError(f"Unsupported message code: {message_code}")
+    
+    return fedwire_json

miso20022/helpers.py

@@ -0,0 +1,111 @@
+# SPDX-License-Identifier: Apache-2.0
+
+"""
+Utility to convert dictionaries to XML format.
+"""
+from typing import Any, Dict, List, Union, Optional
+import xmltodict
+from lxml import etree
+import json
+
+def _remove_none_values(obj):
+    """Remove None values from a dictionary recursively."""
+    if isinstance(obj, dict):
+        return {k: _remove_none_values(v) for k, v in obj.items() if v is not None}
+    elif isinstance(obj, list):
+        return [_remove_none_values(item) for item in obj]
+    return obj
+
+
+def dict_to_xml(data: Union[Dict[str, Any], List[Any]], prefix, namespace, root: Optional[str] = None) -> str:
+    """
+    Convert a dictionary to an XML string with optional namespace prefix.
+
+    Args:
+        data: Dictionary or list to convert.
+        prefix: Namespace prefix to apply to element tags.
+        namespace: Namespace URI to declare on the root element.
+        root: Optional root element name to wrap data.
+
+    Returns:
+        Namespaced XML string.
+    """
+    # Remove None values first
+    data = _remove_none_values(data)
+
+    def _apply_prefix(obj):
+        if isinstance(obj, dict):
+            new_obj = {}
+            for key, value in obj.items():
+                # Don't prefix attributes or the text node
+                if key.startswith('@') or key == '#text':
+                    new_obj[key] = _apply_prefix(value)
+                else:
+                    prefixed_key = f"{prefix}:{key}"
+                    new_obj[prefixed_key] = _apply_prefix(value)
+            return new_obj
+        elif isinstance(obj, list):
+            return [_apply_prefix(item) for item in obj]
+        else:
+            return obj
+
+    # Apply prefix to all tags
+    if prefix and namespace:
+        data = _apply_prefix(data)
+
+    # If root is provided, wrap the data in it
+    if root:
+        root_key = f"{prefix}:{root}"
+        data = {root_key: data}
+        # Declare namespace on the root element
+        data[root_key]["@xmlns:" + prefix] = namespace
+
+    # Generate XML without the XML declaration
+    return xmltodict.unparse(data, pretty=True, full_document=False)
+
+def parse_xml_to_json(xml_file_path: str) -> str:
+    """Parses an XML file and converts it to a JSON string."""
+    try:
+        tree = etree.parse(xml_file_path)
+        root = tree.getroot()
+
+        def element_to_dict(element):
+            """Recursively converts an lxml element to a dictionary."""
+            # Remove namespace from tag name
+            tag = etree.QName(element).localname
+
+            node_dict = {}
+
+            # Add attributes to the dictionary
+            if element.attrib:
+                node_dict['@attributes'] = {k: v for k, v in element.attrib.items()}
+
+            # Add child elements to the dictionary
+            children = element.getchildren()
+            if children:
+                for child in children:
+                    child_tag, child_data = element_to_dict(child).popitem()
+                    if child_tag in node_dict:
+                        if not isinstance(node_dict[child_tag], list):
+                            node_dict[child_tag] = [node_dict[child_tag]]
+                        node_dict[child_tag].append(child_data)
+                    else:
+                        node_dict[child_tag] = child_data
+
+            # Add text content to the dictionary
+            if element.text and element.text.strip():
+                text = element.text.strip()
+                if node_dict:  # If there are attributes or children, add text as a key
+                    node_dict['#text'] = text
+                else:  # Otherwise, the element's value is just the text
+                    node_dict = text
+
+            return {tag: node_dict}
+
+        xml_dict = element_to_dict(root)
+        return json.dumps(xml_dict, indent=4)
+
+    except etree.XMLSyntaxError as e:
+        raise ValueError(f"Error parsing XML file: {e}")
+    except Exception as e:
+        raise IOError(f"Error reading file or processing XML: {e}")

miso20022-0.1.0.dist-info/METADATA

@@ -0,0 +1,341 @@
+Metadata-Version: 2.4
+Name: miso20022
+Version: 0.1.0
+Summary: ISO 20022 Message Generator for US Payment Rails
+Author-email: Mbanq <developers@mbanq.com>, Sai Vatsavai <sai.vatsavai@mbanq.com>, Vamsi Krishna <vamsi.krishna@mbanq.com>
+License-Expression: Apache-2.0
+Project-URL: Homepage, https://github.com/Mbanq/iso20022
+Project-URL: Bug Tracker, https://github.com/Mbanq/iso20022/issues
+Keywords: iso20022,financial,messaging,banking,fedwire,us payment rails,fednow
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Office/Business :: Financial
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: xmlschema>=1.9.0
+Requires-Dist: python-dotenv>=0.19.0
+Requires-Dist: xmltodict>=0.13.0
+Requires-Dist: lxml>=4.9.0
+Requires-Dist: setuptools~=58.0.4
+Dynamic: license-file
+
+# MISO20022 Python Library
+
+This package provides a set of tools for generating and working with ISO 20022 financial messages, with a focus on the US Payment Rails.
+
+
+## Installation
+
+You can install the package from PyPI:
+
+```bash
+pip install miso20022
+```
+
+## Usage Examples
+
+This section provides detailed examples for the core functionalities of the library.
+
+**Index:**
+- [Generating a `pacs.008.001.08` (Customer Credit Transfer) Message](#generating-a-pacs00800108-customer-credit-transfer-message)
+- [Generating a `pacs.028.001.03` (Payment Status Request) Message](#generating-a-pacs02800103-payment-status-request-message)
+- [Parsing a `pacs.008.001.08` XML to JSON](#parsing-a-pacs00800108-xml-to-json)
+- [Parsing a `pacs.002.001.10` (Payment Status Report) XML to JSON](#parsing-a-pacs00200110-payment-status-report-xml-to-json)
+
+---
+
+### Input JSON Structure
+
+The `generate_fedwire_message` function expects a specific JSON structure for the `payload` argument. Below are the expected formats for the supported message types.
+
+#### `pacs.008.001.08` (Customer Credit Transfer)
+
+The payload for a `pacs.008` message should follow this structure:
+
+```json
+{
+  "fedWireMessage": {
+    "inputMessageAccountabilityData": {
+      "inputCycleDate": "20250109",
+      "inputSource": "MBANQ",
+      "inputSequenceNumber": "001000001"
+    },
+    "amount": {
+      "amount": "1000"
+    },
+    "senderDepositoryInstitution": {
+      "senderABANumber": "<routing_number>",
+      "senderShortName": "Pypi Bank"
+    },
+    "receiverDepositoryInstitution": {
+      "receiverABANumber": "<routing_number>",
+      "receiverShortName": "HelloBank"
+    },
+    "originator": {
+      "personal": {
+        "name": "JANE SMITH",
+        "address": {
+          "addressLineOne": "456 eat street",
+          "addressLineTwo": "SOMEWHERE, CA 67890",
+          "addressLineThree": ""
+        },
+        "identifier": "<account_number>"
+      }
+    },
+    "beneficiary": {
+      "personal": {
+        "name": "JOHN DOE",
+        "address": {
+          "addressLineOne": "123 Main street",
+          "addressLineTwo": "ANYTOWN, TX 12345",
+          "addressLineThree": ""
+        },
+        "identifier": "<account_number>"
+      }
+    }
+  }
+}
+```
+
+#### `pacs.028.001.03` (Payment Status Request)
+
+The payload for a `pacs.028` message should follow this structure:
+
+```json
+{
+  "fedWireMessage": {
+    "inputMessageAccountabilityData": {
+      "inputCycleDate": "20250109",
+      "inputSource": "MBANQ",
+      "inputSequenceNumber": "001000002"
+    },
+    "senderDepositoryInstitution": {
+      "senderABANumber": "<routing_number>",
+      "senderShortName": "<short_name>"
+    },
+    "receiverDepositoryInstitution": {
+      "receiverABANumber": "<routing_number>",
+      "receiverShortName": "<short_name>"
+    }
+  },
+  "message_id": "PACS028REQ20250109001",
+  "original_msg_id": "20250109MBANQ001000001",
+  "original_msg_nm_id": "pacs.008.001.08",
+  "original_creation_datetime": "2025-01-09T12:34:56Z",
+  "original_end_to_end_id": "MEtoEIDCJShqZKb"
+}
+```
+
+### Generating a `pacs.008.001.08` (Customer Credit Transfer) Message
+
+This example shows how to generate a Fedwire `pacs.008` message from a JSON payload.
+
+```python
+import json
+from miso20022.fedwire import generate_fedwire_message
+
+# 1. Load your payment data from a JSON object
+with open('sample_files/sample_payload.json', 'r') as f:
+    payload = json.load(f)
+
+# 2. Define the necessary message parameters
+message_code = 'urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08'
+environment = "TEST"  # Or "PROD"
+fed_aba = '000000008' # The ABA number for the Fed
+xsd_path = 'proprietary_fed_file.xsd' # The XSD file for fedwire format
+
+# 3. Generate the complete XML message
+_, _, complete_message = generate_fedwire_message(
+    message_code=message_code,
+    environment=environment,
+    fed_aba=fed_aba,
+    payload=payload,
+    xsd_path=xsd_path
+)
+
+# 4. Save the message to a file
+if complete_message:
+    with open('generated_pacs.008.xml', 'w') as f:
+        f.write(complete_message)
+
+print("pacs.008.001.08 message generated successfully!")
+```
+
+### Generating a `pacs.028.001.03` (Payment Status Request) Message
+
+This example shows how to generate a `pacs.028` payment status request.
+
+```python
+import json
+from miso20022.fedwire import generate_fedwire_message
+
+# 1. Load the payload for the status request
+with open('sample_files/sample_pacs028_payload.json', 'r') as f:
+    payload = json.load(f)
+
+# 2. Define message parameters
+message_code = 'urn:iso:std:iso:20022:tech:xsd:pacs.028.001.03'
+environment = "TEST"  # Or "PROD"
+fed_aba = '000000008'
+xsd_path = 'proprietary_fed_file.xsd'
+
+# 3. Generate the XML message
+_, _, complete_message = generate_fedwire_message(
+    message_code=message_code,
+    environment=environment,
+    fed_aba=fed_aba,
+    payload=payload,
+    xsd_path=xsd_path
+)
+
+# 4. Save the message to a file
+if complete_message:
+    with open('generated_pacs.028.xml', 'w') as f:
+        f.write(complete_message)
+
+print("pacs.028.001.03 message generated successfully!")
+```
+
+### Parsing a `pacs.008.001.08` XML to JSON
+
+This example shows how to parse a `pacs.008` XML file and convert it into a simplified JSON object.
+
+```python
+from miso20022.fedwire import generate_fedwire_payload
+import json
+
+# 1. Define the path to your XML file and the message code
+xml_file = 'incoming_pacs.008.xml'
+message_code = 'urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08'
+
+# 2. Parse the XML file
+fedwire_json = generate_fedwire_payload(xml_file, message_code)
+
+# 3. Save the JSON payload to a file
+if fedwire_json:
+    with open('parsed_pacs.008.json', 'w') as f:
+        json.dump(fedwire_json, f, indent=4)
+
+print("pacs.008.001.08 XML parsed to JSON successfully!")
+```
+
+### Parsing a `pacs.002.001.10` (Payment Status Report) XML to JSON
+
+This example shows how to parse a `pacs.002` payment status report (ack/nack) into a JSON object.
+
+```python
+from miso20022.fedwire import generate_fedwire_payload
+import json
+
+# 1. Define the path to your XML file and the message code
+xml_file = 'sample_files/pacs.002_PaymentAck.xml'
+message_code = 'urn:iso:std:iso:20022:tech:xsd:pacs.002.001.10'
+
+# 2. Parse the XML to get the JSON payload
+fedwire_json = generate_fedwire_payload(xml_file, message_code)
+
+# 3. Save the payload to a JSON file
+if fedwire_json:
+    with open('parsed_pacs.002_payload.json', 'w') as f:
+        json.dump(fedwire_json, f, indent=4)
+
+print("pacs.002.001.10 XML parsed to JSON successfully!")
+```
+
+## Command-Line Interface (CLI)
+
+The package includes a command-line tool, `miso20022`, for generating and parsing messages directly from your terminal.
+
+### Generating a Message
+
+**Usage:**
+
+```bash
+miso20022 generate --message_code [MESSAGE_CODE] --environment [ENV] --fed-aba [ABA_NUMBER] --input-file [PAYLOAD_FILE] --output-file [OUTPUT_XML]
+```
+
+**Arguments:**
+
+-   `--message_code`: The ISO 20022 message code (e.g., `urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08`).
+-   `--environment`: The environment for the message (`TEST` or `PROD`).
+-   `--fed-aba`: The Fedwire ABA number.
+-   `--input-file`: Path to the input JSON payload file.
+-   `--output-file`: (Optional) Path to save the generated XML message.
+-   `--xsd-file`: (Optional) Path to the XSD file for validation.
+
+**Example:**
+
+```bash
+miso20022 generate \
+    --message_code urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08 \
+    --environment TEST \
+    --fed-aba 000000008 \
+    --input-file sample_files/sample_payment.json \
+    --output-file pacs.008_output.xml
+```
+
+### Parsing a Message
+
+**Usage:**
+
+```bash
+miso20022 parse --input-file [INPUT_XML] --message-code [MESSAGE_CODE] --output-file [OUTPUT_JSON]
+```
+
+**Arguments:**
+
+-   `--input-file`: Path to the input ISO 20022 XML file.
+-   `--message-code`: The ISO 20022 message code of the input file.
+-   `--output-file`: (Optional) Path to save the output JSON payload.
+
+**Example:**
+
+```bash
+miso20022 parse \
+    --input-file sample_files/pacs.008.001.008_2025_1.xml \
+    --message-code urn:iso:std:iso:20022:tech:xsd:pacs.008.001.08 \
+    --output-file parsed_payload.json
+```
+
+---
+
+## Supported Message Types
+
+The library provides different levels of support for various message types.
+
+### Message Generation (`generate_fedwire_message`)
+
+The following message types are fully supported with dedicated data models for generating complete XML messages:
+
+-   **`pacs.008.001.08`**: FI to FI Customer Credit Transfer
+-   **`pacs.028.001.03`**: FI to FI Payment Status Request
+
+While other message types might be generated using the generic handlers, these are the ones with first-class support.
+
+### XML to JSON Parsing (`generate_fedwire_payload`)
+
+The library can parse the following XML message types into a simplified Fedwire JSON format:
+
+-   **`pacs.008.001.08`**: FI to FI Customer Credit Transfer
+-   **`pacs.002.001.10`**: FI to FI Payment Status Report
+
+Support for parsing other message types can be added by creating new mapping functions.
+
+### Future Support
+
+We are actively working to expand the range of supported message types. Future releases will include built-in support for additional `pacs`, `camt`, and other ISO 20022 messages, with planned support for FedNow services. Stay tuned for updates!
+
+## Contributing
+
+Contributions are welcome! Please refer to the [Project repository](https://github.com/Mbanq/iso20022) for contribution guidelines, to open an issue, or to submit a pull request.
+
+<p align="center"><strong style="font-size: 2em">Built with ❤️ in the Beautiful State of Washington!</strong></p>
+
+

miso20022-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+miso20022/__init__.py,sha256=yTENkynwRJv8RUTxoZwIUBjVmi9sy6WNSko3J20C1pg,863
+miso20022/cli.py,sha256=btcqHFS8BbRawzgFfHC7DyHCSVXHZyZ0xazCBSrewSQ,4525
+miso20022/fedwire.py,sha256=xzkYVMwWmUJoGKcH4SgraEZr2Xz1nrJssC5C-jlL5rU,16312
+miso20022/helpers.py,sha256=iUs7osRRK5Y0YX_MXc9FhpdgBVb13yLtsqaHET4DhQw,3986
+miso20022-0.1.0.dist-info/licenses/LICENSE,sha256=anJYlF4dWNaK9dbT5YiQtvP3yC2usnjq9j6dnssLfa8,11362
+miso20022-0.1.0.dist-info/METADATA,sha256=caDDUiiA0-WbXzjaoNNElONPQSO8f4g71p9sOHllq3Y,10780
+miso20022-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+miso20022-0.1.0.dist-info/entry_points.txt,sha256=2vMPbvTduug0nFnDI09fW185WL3IlUA7hJCFUR2257c,49
+miso20022-0.1.0.dist-info/top_level.txt,sha256=amQoMpH9Ct_K-ufsoBI8h3BAVMafLyzZC7ltGXonEak,10
+miso20022-0.1.0.dist-info/RECORD,,

miso20022-0.1.0.dist-info/WHEEL

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

miso20022-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+miso20022 = miso20022.cli:main

miso20022-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [2025] [BAAS Corporation d/b/a Mbanq]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

miso20022-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+miso20022