pyx12 4.0.0rc1__py3-none-any.whl

pyx12/__init__.py

@@ -0,0 +1,10 @@
+"""
+Validate and transform HIPAA X12 documents
+"""
+
+__author__ = "John Holland <john.holland@swmbh.org>"
+__status__ = "production"
+from .version import __version__ as __version__
+
+__date__ = "2021-05-28"
+__revision__ = ""

pyx12/codes.py

@@ -0,0 +1,120 @@
+######################################################################
+# Copyright
+#   John Holland <john@zoner.org>
+# All rights reserved.
+#
+# This software is licensed as described in the file LICENSE.txt, which
+# you should have received as part of this distribution.
+#
+######################################################################
+
+"""
+External Codes interface
+"""
+
+from __future__ import annotations
+
+import logging
+import os.path
+from importlib.resources import files as _res_files
+from typing import IO, Any, TypedDict
+
+import defusedxml.ElementTree as et
+
+from pyx12.errors import EngineError
+
+
+class CodesError(Exception):
+    """Class for code modules errors."""
+
+
+class _CodeSet(TypedDict):
+    name: str | None
+    dataele: str | None
+    codes: frozenset[str | None]
+
+
+class ExternalCodes:
+    """
+    Validates an ID against an external list of codes
+    """
+
+    codes: dict[str | None, _CodeSet]
+    exclude_list: list[str]
+
+    def __init__(self, base_path: str | None = None, exclude: str | None = None) -> None:
+        """
+        Initialize the external list of codes
+
+        :param base_path: Override directory containing codes.xml.
+            If None, uses package resource folder.
+        :param exclude: comma-separated string of external code names to ignore.
+
+        ``self.codes`` maps codeset_id to ``{'name', 'dataele', 'codes'}``.
+        """
+        logger = logging.getLogger("pyx12")
+        self.codes = {}
+        codes_file = "codes.xml"
+        # ElementTree.parse accepts either text- or binary-mode streams; the
+        # file source differs between override path and bundled package resource.
+        code_fd: IO[Any]
+        if base_path is not None:
+            logger.debug(f"Looking for codes file '{codes_file}' in map_path '{base_path}'")
+            code_fd = open(os.path.join(base_path, codes_file), encoding="utf-8")
+        else:
+            logger.debug(f"Looking for codes file '{codes_file}' in package resources")
+            code_fd = _res_files("pyx12").joinpath("map", codes_file).open("rb")
+
+        self.exclude_list = exclude.split(",") if exclude is not None else []
+        with code_fd:
+            parser = et.XMLParser(encoding="utf-8")
+            for cElem in et.parse(code_fd, parser=parser).iter("codeset"):
+                codeset_id = cElem.findtext("id")
+                self.codes[codeset_id] = {
+                    "name": cElem.findtext("name"),
+                    "dataele": cElem.findtext("data_ele"),
+                    "codes": frozenset(c.text for c in cElem.iterfind("version/code")),
+                }
+
+    def isValid(self, key: str | None, code: str | None, check_dte: str | None = None) -> bool:
+        """
+        Return True if code is in the codeset identified by key.
+        """
+        if not key:
+            raise EngineError(f"bad key {key!r}")
+        if key in self.exclude_list:
+            return True
+        if key not in self.codes:
+            raise EngineError(f'External Code "{key}" is not defined')
+        return code in self.codes[key]["codes"]
+
+    def debug_print(self, count: int = 10) -> None:
+        """Debug print first <count> codes for each codeset (alphabetical)."""
+        for key in self.codes:
+            print(sorted(self.codes[key]["codes"], key=lambda c: c or "")[:count])
+
+
+def list_external_codesets(base_path: str | None = None) -> list[tuple[str, str]]:
+    """Return ``(id, name)`` for every codeset in ``codes.xml``.
+
+    Used by CLI scripts to populate ``--help`` with the list of names
+    accepted by the ``--exclude-external-codes`` flag. Loads the metadata
+    only — does not parse code values — so the cost is small.
+
+    :param base_path: Override directory containing codes.xml.
+        If None, uses package resource folder.
+    """
+    code_fd: IO[Any]
+    if base_path is not None:
+        code_fd = open(os.path.join(base_path, "codes.xml"), encoding="utf-8")
+    else:
+        code_fd = _res_files("pyx12").joinpath("map", "codes.xml").open("rb")
+    pairs: list[tuple[str, str]] = []
+    with code_fd:
+        parser = et.XMLParser(encoding="utf-8")
+        for cs in et.parse(code_fd, parser=parser).iter("codeset"):
+            cid = (cs.findtext("id") or "").strip()
+            name = (cs.findtext("name") or "").strip()
+            if cid:
+                pairs.append((cid, name))
+    return pairs

pyx12/dataele.py

@@ -0,0 +1,103 @@
+######################################################################
+# Copyright (c) 2001-2019
+#   John Holland <john@zoner.org>
+# All rights reserved.
+#
+# This software is licensed as described in the file LICENSE.txt, which
+# you should have received as part of this distribution.
+#
+######################################################################
+
+"""
+Interface to normalized Data Elements
+"""
+
+from __future__ import annotations
+
+import logging
+import os.path
+from importlib.resources import files as _res_files
+from typing import IO, Any, TypedDict
+
+import defusedxml.ElementTree as et
+
+# Intrapackage imports
+from pyx12.errors import EngineError
+
+
+class DataElementsError(Exception):
+    """Class for data elements module errors."""
+
+
+class _DataEle(TypedDict):
+    data_type: str | None
+    min_len: int
+    max_len: int
+    name: str | None
+
+
+class DataElements:
+    """
+    Interface to normalized Data Elements
+    """
+
+    dataele: dict[str | None, _DataEle]
+
+    def __init__(self, base_path: str | None = None) -> None:
+        """
+        Initialize the list of data elements
+
+        :param base_path: Override directory containing dataele.xml.  If None,
+            uses package resource folder
+        :type base_path: string
+
+        Note: ``self.dataele`` maps to the data element
+        ``{ele_num: {data_type, min_len, max_len, name}}``
+        """
+        logger = logging.getLogger("pyx12")
+        self.dataele = {}
+        dataele_file = "dataele.xml"
+        # ElementTree.parse accepts either text- or binary-mode streams; the
+        # file source differs between override path and bundled package resource.
+        fd: IO[Any]
+        if base_path is not None:
+            logger.debug(
+                f"Looking for data element definition file '{dataele_file}' in map_path '{base_path}'"
+            )
+            fd = open(os.path.join(base_path, dataele_file), encoding="utf-8")
+        else:
+            logger.debug(
+                f"Looking for data element definition file '{dataele_file}' in package resources"
+            )
+            fd = _res_files("pyx12").joinpath("map", dataele_file).open("rb")
+        with fd:
+            parser = et.XMLParser(encoding="utf-8")
+            for eElem in et.parse(fd, parser=parser).iter("data_ele"):
+                ele_num = eElem.get("ele_num")
+                self.dataele[ele_num] = {
+                    "data_type": eElem.get("data_type"),
+                    "min_len": int(eElem.get("min_len")),
+                    "max_len": int(eElem.get("max_len")),
+                    "name": eElem.get("name"),
+                }
+
+    def get_by_elem_num(self, ele_num: str | None) -> _DataEle:
+        """
+        Get the element characteristics for the indexed element code
+        :param ele_num: the data element code
+        :type ele_num: string
+        :return: {data_type, min_len, max_len, name}
+        :rtype: dict
+        """
+        if not ele_num:
+            raise EngineError(f"Bad data element {ele_num!r}")
+        if ele_num not in self.dataele:
+            raise EngineError(f'Data Element "{ele_num}" is not defined')
+        return self.dataele[ele_num]
+
+    def debug_print(self) -> None:
+        """
+        Debug print data elements
+        """
+        for ele_num in self.dataele:
+            print(self.dataele[ele_num])

pyx12/decorators.py

@@ -0,0 +1,79 @@
+from __future__ import annotations
+
+import collections.abc
+import functools
+from collections.abc import Callable
+from typing import Any
+
+# See https://wiki.python.org/moin/PythonDecoratorLibrary
+
+
+def dump_args(func: Callable[..., Any]) -> Callable[..., Any]:
+    "This decorator dumps out the arguments passed to a function before calling it"
+    argnames = func.__code__.co_varnames[: func.__code__.co_argcount]
+    fname = func.__name__
+
+    def echo_func(*args: Any, **kwargs: Any) -> Any:
+        print(
+            (
+                fname,
+                ":",
+                ", ".join(
+                    "%s=%r" % entry for entry in list(zip(argnames, args)) + list(kwargs.items())
+                ),
+            )
+        )
+        return func(*args, **kwargs)
+
+    return echo_func
+
+
+def memoize(obj: Callable[..., Any]) -> Callable[..., Any]:
+    cache: dict[Any, Any] = {}
+    obj.cache = cache  # type: ignore[attr-defined]
+
+    @functools.wraps(obj)
+    def memoizer(*args: Any, **kwargs: Any) -> Any:
+        if kwargs:  # frozenset is used to ensure hashability
+            key: Any = (args, frozenset(kwargs.items()))
+        else:
+            key = args
+        if key not in cache:
+            cache[key] = obj(*args, **kwargs)
+        return cache[key]
+
+    return memoizer
+
+
+class memoized:
+    """Decorator. Caches a function's return value each time it is called.
+    If called later with the same arguments, the cached value is returned
+    (not reevaluated).
+    """
+
+    func: Callable[..., Any]
+    cache: dict[Any, Any]
+
+    def __init__(self, func: Callable[..., Any]) -> None:
+        self.func = func
+        self.cache = {}
+
+    def __call__(self, *args: Any) -> Any:
+        if not isinstance(args, collections.abc.Hashable):
+            # uncacheable. a list, for instance.
+            # better to not cache than blow up.
+            return self.func(*args)
+        if args in self.cache:
+            return self.cache[args]
+        else:
+            value = self.func(*args)
+            self.cache[args] = value
+            return value
+
+    def __repr__(self) -> str:
+        """Return the function's docstring."""
+        return self.func.__doc__ or ""
+
+    def __get__(self, obj: Any, objtype: Any) -> Callable[..., Any]:
+        """Support instance methods."""
+        return functools.partial(self.__call__, obj)

pyx12/errh_xml.py

@@ -0,0 +1,324 @@
+######################################################################
+# Copyright (c)
+#   John Holland <john@zoner.org>
+# All rights reserved.
+#
+# This software is licensed as described in the file LICENSE.txt, which
+# you should have received as part of this distribution.
+#
+######################################################################
+
+"""
+Capture X12 Errors
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import tempfile
+from types import TracebackType
+from typing import IO, Any, Literal
+
+# Intrapackage imports
+from .errors import EngineError
+from .xmlwriter import XMLWriter
+
+# (kind, code, message, value, src_line)
+_ErrTuple = tuple[str, str, str, Any, int | None]
+
+
+class err_handler:
+    """
+    The interface to the error handling structures.
+    """
+
+    logger: logging.Logger
+    filename: str
+    fd: IO[Any]
+    cur_line: int | None
+    errors: list[_ErrTuple]
+    writer: XMLWriter
+
+    def __init__(self, xml_out: str | None = None, basedir: str | None = None) -> None:
+        """
+        :param xml_out: Output filename, if None, will dump to tempfile
+        :param basedir: working directory, where file will be created
+        """
+        self.logger = logging.getLogger("pyx12.errh_xml")
+        if xml_out:
+            self.filename = xml_out
+            self.fd = open(xml_out, "w", encoding="utf-8")
+        else:
+            try:
+                (fdesc, self.filename) = tempfile.mkstemp(".xml", "pyx12_")
+                self.fd = os.fdopen(fdesc, "w+b")
+            except OSError:
+                (fdesc, self.filename) = tempfile.mkstemp(
+                    suffix=".xml", prefix="pyx12_", dir=basedir
+                )
+                self.fd = os.fdopen(fdesc, "w+b")
+        self.cur_line = None
+        self.errors = []
+        if not self.fd:
+            raise EngineError("Could not open temp error xml file")
+        self.writer = XMLWriter(self.fd)  # type: ignore[arg-type]
+        self.writer.push("x12err")
+
+    def close(self) -> None:
+        """
+        Flush remaining XML closing tags and close the underlying file.
+        Idempotent.
+        """
+        while len(self.writer) > 0:
+            self.writer.pop()
+        if self.fd is not None and not self.fd.closed:
+            self.fd.close()
+
+    def __enter__(self) -> err_handler:
+        return self
+
+    def __exit__(
+        self,
+        exc_type: type[BaseException] | None,
+        exc: BaseException | None,
+        tb: TracebackType | None,
+    ) -> Literal[False]:
+        self.close()
+        return False
+
+    def getFilename(self) -> str:
+        return self.filename
+
+    def handleErrors(self, err_list: list[_ErrTuple]) -> None:
+        """
+        :param err_list: list of errors to apply
+        """
+        self.errors.extend(err_list)
+        # for (err_type, err_cde, err_str, err_val, src_line) in err_list:
+        #    if err_type == 'isa':
+        #        self.isa_error(err_cde, err_str)
+        #    elif err_type == 'gs':
+        #        self.gs_error(err_cde, err_str)
+        #    elif err_type == 'st':
+        #        self.st_error(err_cde, err_str)
+        #    elif err_type == 'seg':
+        #        self.seg_error(err_cde, err_str, err_val, src_line)
+
+    def getCurLine(self) -> int | None:
+        """
+        :return: Current file line number
+        :rtype: int
+        """
+        return self.cur_line
+
+    def Write(self, cur_line: int) -> None:
+        """
+        Generate XML for the segment data and matching map node
+
+        """
+        if len(self.errors) > 0:
+            self.writer.push("seg", attrs={"line": "%i" % (cur_line)})
+            for err_type, err_cde, err_str, err_val, src_line in self.errors:
+                self.writer.push("err", attrs={"code": err_cde})
+                # self.writer.elem(u"type", err_type)
+                # self.writer.elem(u"code", err_cde)
+                self.writer.elem("desc", err_str)
+                if err_val:
+                    self.writer.elem("errval", err_val)
+                # self.writer.push(u"seg", {u'line': '%i'%(cur_line)})
+                # self.writer.elem(u'ele', seg_data.get_value('%02i' %
+                # (i+1)),
+                #    attrs={u'id': child_node.id})
+                self.writer.pop()  # end err
+            self.writer.pop()  # end segment
+            self.errors = []
+
+
+class ErrorErrhNull(Exception):
+    """Class for errh_null errors."""
+
+
+class errh_list:
+    """
+    A null error object - used for testing.
+    Stores the current error in simple variables.
+    """
+
+    logger: logging.Logger
+    errors: list[_ErrTuple]
+    cur_line: int
+
+    def __init__(self) -> None:
+        self.logger = logging.getLogger("pyx12.errh_xml")
+        # self.id = 'ROOT'
+        self.errors = []
+        # self.cur_node = self
+        self.cur_line = 0
+        # self.err_cde = None
+        # self.err_str = None
+
+    def get_errors(self) -> list[_ErrTuple]:
+        return self.errors
+
+    def reset(self) -> None:
+        self.errors = []
+
+    def get_cur_line(self) -> int:
+        """
+        :return: Current file line number
+        :rtype: int
+        """
+        return self.cur_line
+
+    def set_cur_line(self, cur_line: int) -> None:
+        """ """
+        self.cur_line = cur_line
+
+    #    def get_id(self):
+    #        """
+    #        :return: Error node type
+    #        :rtype: string
+    #        """
+    #        return self.id
+
+    def add_isa_loop(self, seg: Any, src: Any) -> None:
+        """ """
+        # raise ErrorErrhNull, 'add_isa loop'
+        pass
+
+    def add_gs_loop(self, seg: Any, src: Any) -> None:
+        """ """
+        pass
+
+    def add_st_loop(self, seg: Any, src: Any) -> None:
+        """ """
+        pass
+
+    def add_seg(
+        self, map_node: Any, seg: Any, seg_count: int, cur_line: int, ls_id: str | None
+    ) -> None:
+        """ """
+        pass
+
+    def add_ele(self, map_node: Any) -> None:
+        """ """
+        pass
+
+    def isa_error(self, err_cde: str, err_str: str) -> None:
+        """
+        :param err_cde: ISA level error code
+        :type err_cde: string
+        :param err_str: Description of the error
+        :type err_str: string
+        """
+        self.errors.append(("isa", err_cde, err_str, None, None))
+        sout = ""
+        sout += "Line:%i " % (self.cur_line)
+        sout += "ISA:%s - %s" % (err_cde, err_str)
+        self.logger.error(sout)
+
+    def gs_error(self, err_cde: str, err_str: str) -> None:
+        """
+        :param err_cde: GS level error code
+        :type err_cde: string
+        :param err_str: Description of the error
+        :type err_str: string
+        """
+        self.errors.append(("gs", err_cde, err_str, None, None))
+        sout = ""
+        sout += "Line:%i " % (self.cur_line)
+        sout += "GS:%s - %s" % (err_cde, err_str)
+        self.logger.error(sout)
+
+    def st_error(self, err_cde: str, err_str: str) -> None:
+        """
+        :param err_cde: Segment level error code
+        :type err_cde: string
+        :param err_str: Description of the error
+        :type err_str: string
+        """
+        self.errors.append(("st", err_cde, err_str, None, None))
+        sout = ""
+        sout += "Line:%i " % (self.cur_line)
+        sout += "ST:%s - %s" % (err_cde, err_str)
+        self.logger.error(sout)
+
+    def seg_error(
+        self,
+        err_cde: str,
+        err_str: str,
+        err_value: str | None = None,
+        src_line: int | None = None,
+    ) -> None:
+        """
+        :param err_cde: Segment level error code
+        :type err_cde: string
+        :param err_str: Description of the error
+        :type err_str: string
+        """
+        self.errors.append(("seg", err_cde, err_str, err_value, src_line))
+        sout = ""
+        sout += "Line:%i " % (self.cur_line)
+        sout += "SEG:%s - %s" % (err_cde, err_str)
+        if err_value:
+            sout += " (%s)" % err_value
+        self.logger.error(sout)
+
+    def ele_error(self, err_cde: str, err_str: str, bad_value: str | None) -> None:
+        """
+        :param err_cde: Element level error code
+        :type err_cde: string
+        :param err_str: Description of the error
+        :type err_str: string
+        """
+        self.errors.append(("ele", err_cde, err_str, bad_value, None))
+        sout = ""
+        sout += "Line:%i " % (self.cur_line)
+        sout += "ELE:%s - %s" % (err_cde, err_str)
+        if bad_value:
+            sout += " (%s)" % (bad_value)
+        self.logger.error(sout)
+
+    def close_isa_loop(self, node: Any, seg: Any, src: Any) -> None:
+        """ """
+        pass
+
+    def close_gs_loop(self, node: Any, seg: Any, src: Any) -> None:
+        """ """
+        pass
+
+    def close_st_loop(self, node: Any, seg: Any, src: Any) -> None:
+        """ """
+        pass
+
+    def find_node(self, atype: str) -> None:
+        """
+        Find the last node of a type
+        """
+        pass
+
+    def get_parent(self) -> None:
+        return None
+
+    #    def get_first_child(self):
+    #        """
+    #        """
+    #        if len(self.children) > 0:
+    #            return self.children[0]
+    #        else:
+    #            return None
+
+    def get_next_sibling(self) -> None:
+        """ """
+        return None
+
+    def get_error_count(self) -> int:
+        """ """
+        return len(self.errors)
+
+    def is_closed(self) -> bool:
+        """
+        :rtype: boolean
+        """
+        return True