mikrowerk-edi-invoicing 0.1.0__py3-none-any.whl

mikrowerk_edi_invoicing-0.1.0.dist-info/METADATA

@@ -0,0 +1,35 @@
+Metadata-Version: 2.2
+Name: mikrowerk_edi_invoicing
+Version: 0.1.0
+Summary: Parser for EDI invoices in CII or UBL format
+Author: Mikrowerk a Gammadata Division
+Author-email: info@mikrowerk.com
+License: Affero-3
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU Affero General Public License v3 or later (AGPLv3+)
+Classifier: Operating System :: OS Independent
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: lxml
+Requires-Dist: pypdf
+Requires-Dist: pytest
+Requires-Dist: flake8
+Requires-Dist: isort
+Requires-Dist: black
+Requires-Dist: coverage
+Requires-Dist: codecov
+Requires-Dist: drafthorse~=2.4.0
+Requires-Dist: factur-x==3.6
+Requires-Dist: jsonpickle~=4.0.1
+Requires-Dist: parameterized
+Requires-Dist: schwifty
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
+
+# Mikrowerk EDI Parser for CII and UBL Invoices

mikrowerk_edi_invoicing-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+model/__init__.py,sha256=eM8kFNSQHvV3RbGnrOPECSNcdOZIU_FJYkqOJ9gZ5-0,59
+model/x_rechnung.py,sha256=qklcfdmihPZL9Ny7rqvP_KgvcnEsNGXLJUEO8iafZas,9790
+tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tests/test_iban_handling.py,sha256=suRaB9gxbNc2Dc7spjHmQyPBdXva98HF1js85wQWqPM,662
+tests/test_parse_x_rechnung.py,sha256=ChVUcDp3P1o8IzQmRJJWwkIlrqZel3xYmoE3V1ukytE,3584
+util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+util/file_helper.py,sha256=4gdWbv8L9LSMraLKvGI1Z3NMcuGGy7JB1qFvNaW-yo4,767
+x_mapper/__init__.py,sha256=Ee222PGj2y9wgsjx53yP9InOwkig31SZd8ra29gkPMc,536
+x_mapper/cross_industry_invoice_mapper.py,sha256=HmIDFJhJf4iB5efFZoPhs04c2qvwvTn0pfbsrPA9EJk,827
+x_mapper/drafthorse_elements_helper.py,sha256=gO8VobJnBqKEdRDcVsz4XixCvSCQEYqhcZeb7v51jGE,3756
+x_mapper/xml_abstract_x_rechnung_parser.py,sha256=puxCSC02zIXpfMY9xNLqY-w0aRv0y5ROHmNtmaV16o4,673
+x_mapper/xml_cii_dom_parser.py,sha256=q_0osUHGloVkG0ZL782SBMWAGtMaBdEI8xblyGrDlmw,10980
+x_mapper/xml_ubl_sax_parser.py,sha256=VZcZSQo-iHiVA3IUtZu9xAQwWglgk34lD_Y-Hw3Sq5M,14008
+mikrowerk_edi_invoicing-0.1.0.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+mikrowerk_edi_invoicing-0.1.0.dist-info/METADATA,sha256=9kizoXNxoAkO0FHNyu10gjLF10aJr6VYsPlQpPQgjBM,1004
+mikrowerk_edi_invoicing-0.1.0.dist-info/WHEEL,sha256=nn6H5-ilmfVryoAQl3ZQ2l8SH5imPWFpm1A5FgEuFV4,91
+mikrowerk_edi_invoicing-0.1.0.dist-info/top_level.txt,sha256=pchuH1VFSrOMiUHBeuZxMaHNvC6mgZ59aac8eM_PXgs,26
+mikrowerk_edi_invoicing-0.1.0.dist-info/RECORD,,

mikrowerk_edi_invoicing-0.1.0.dist-info/WHEEL

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

mikrowerk_edi_invoicing-0.1.0.dist-info/top_level.txt

@@ -0,0 +1,4 @@
+model
+tests
+util
+x_mapper

model/__init__.py

@@ -0,0 +1,3 @@
+from .x_rechnung import XRechnung
+
+__all__ = ["XRechnung"]

model/x_rechnung.py

@@ -0,0 +1,260 @@
+from datetime import datetime
+from dataclasses import dataclass, asdict
+from decimal import Decimal
+
+__all__ = ['XRechnung', "XRechnungCurrency", "XRechnungTradeParty", "XRechnungTradeAddress", "XRechnungTradeContact",
+           "XRechnungPaymentMeans", "XRechnungBankAccount", "XRechnungAppliedTradeTax", "XRechnungTradeLine",
+           "XRechnungFinancialCard"]
+
+
+@dataclass
+class XRechnungCurrency:
+    amount: Decimal
+    currency_code: str
+
+    @staticmethod
+    def from_currency_tuple(currency_tuple: tuple) -> 'XRechnungCurrency':
+        return XRechnungCurrency(*currency_tuple)
+
+
+@dataclass
+class XRechnungTradeAddress:
+    post_code: str = None  # 'Post-Code'
+    city_name: str = None  # 'City'
+    country_id: str = None  # 'Country ID
+    country_subdivision_id: str = None  # 'Country Subdivision ID'
+    address_line_1: str = None  # 'Address Line 1'
+    address_line_2: str = None  # 'Address Line 2'
+    address_line_3: str = None  # 'Address Line 3'
+
+
+@dataclass
+class XRechnungTradeContact:
+    name: str = None  # 'Person Name'
+    department_name: str = None  # 'Department Name'
+    telephone: str = None  # 'Telephone Number'
+    fax: str = None  # 'Fax'
+    email: str = None  # 'Email'
+
+
+@dataclass
+class XRechnungTradeParty:
+    global_id: int = 0  # 'Global ID'
+    global_id_schema: str = None  # 'Global Schema'
+    id: str = None  # 'id'
+    name: str = None  # 'Name'
+    description: str = None  # 'Description'
+    postal_address: XRechnungTradeAddress = None
+    email: str = None  # 'Email'
+    trade_contact: XRechnungTradeContact = None
+    vat_registration_number: str = None  # 'VAT Registration Number'
+    fiscal_registration_number: str = None  # 'Fiscal Registration Number'
+    legal_registration_number: str = None
+
+
+# @dataclass
+# class XRechnungSpecifiedTradeSettlementPaymentMeans:
+#     name: str = None  # 'Name'
+#     type_code: str = None  # 'Type Code'
+#     information: str = None  # 'Information'
+#     iban: str = None  # 'IBAN'
+#     bicid: str = None  # 'BICID'
+#     account_name: str = None  # 'Account Name'
+
+
+@dataclass
+class XRechnungAppliedTradeTax:
+    name: str = None  # 'Name'
+    type_code: str = None
+    category_code: str = None
+    applicable_percent: float = 0.0
+    basis_amount: float = 0.0  # 'Basis Amount'
+    calculated_amount: float = 0.0  # 'Calculated Tax Amount'
+
+
+@dataclass
+class XRechnungTradeLine:
+    name: str = None  # 'Name')
+    description: str = None
+    line_id: str = None  # 'Line ID')
+    global_product_id: str = None  # 'Global Product ID')
+    global_product_scheme_id: str = None  # 'Global Product Scheme ID')
+    seller_assigned_id: str = None  # 'Seller Assigned ID')
+    buyer_assigned_id: str = None  # 'Buyer Assigned ID')
+    price_unit: float = 0.0  # 'Net Price')
+    quantity_billed: float = 0.0  # 'Billed Quantity')
+    quantity_unit_code: str = None  # 'Quantity Code')
+    total_amount_net: float = 0.0  # 'Total Amount Net')
+    price_unit_gross: float = 0.0
+    total_allowance_charge: float = 0.0
+    trade_tax: any = None
+    note: str = None
+    lot_number_id: str = None
+    expiry_date: datetime = None
+
+
+@dataclass
+class XRechnungFinancialCard:
+    id: str | None = None
+    cardholder_name: str | None = None
+
+
+@dataclass
+class XRechnungBankAccount:
+    iban: str | None = None
+    bic: str | None = None
+
+
+@dataclass
+class XRechnungPaymentMeans:
+    id: str = None
+    type_code: str = None
+    information: str = None
+    financial_card: XRechnungFinancialCard = None
+    payee_account: XRechnungBankAccount = None
+
+
+@dataclass
+class XRechnung:
+    name: str = None  # 'Name'
+    doc_id: str = None  # 'Document ID'
+    doc_type_code: str = None  # 'Subject Code'
+    issued_date_time: datetime = None  # 'Date'
+    delivered_date_time: datetime = None  # 'Delivered Date'
+    languages: str = None  # 'Languages'
+    notes: str = None  # 'Notes'
+    buyer_reference: str = None  # 'Buyer Reference'
+    order_reference: str = None
+    dispatch_reference: str = None
+    sales_order_reference: str = None
+    seller: XRechnungTradeParty = None
+    payee: XRechnungTradeParty = None
+    buyer: XRechnungTradeParty = None
+    invoicee: XRechnungTradeParty = None
+    currency_code: str = None  # 'Currency Code'
+    payment_means: XRechnungPaymentMeans = None
+    payment_terms: str = None  # 'Payment Terms'
+    line_total_amount: Decimal = None  # 'Line Total Amount'
+    charge_total_amount: Decimal = None  # 'Charge Total Amount'
+    allowance_total_amount: Decimal = None  # 'Allowance Total Amount'
+    tax_basis_total_amount: XRechnungCurrency = None
+    tax_total_amount: [XRechnungCurrency] = None  # 'Tax Grand Total Amount'
+    grand_total_amount: XRechnungCurrency = None  # 'Grand Total Amount'
+    total_prepaid_amount: Decimal = None  # 'Total Prepaid Amount'
+    due_payable_amount: Decimal = None  # 'Due Payable Amount'
+    trade_line_items: [XRechnungTradeLine] = None
+    applicable_trade_taxes: [XRechnungAppliedTradeTax] = None
+
+    def map_to_dict(self) -> dict:
+        """
+        maps a XRechnung to a dict suited for generation odoo entities
+        Note: this is not a 1:1 mapping of the XRechnung model, some adjustments and simplifications made
+        :param self: XRechnung.XRechnung
+        :return: dict
+        """
+
+        _dict = asdict(self)
+        _dict.update({
+            'line_total_amount': float(self.line_total_amount) if self.line_total_amount is not None else 0,
+            'charge_total_amount': float(self.charge_total_amount) if self.charge_total_amount else 0,
+            'allowance_total_amount': float(self.allowance_total_amount) if self.allowance_total_amount else 0,
+            'tax_basis_total_amount': float(
+                self.tax_basis_total_amount.amount) if self.tax_basis_total_amount else 0,
+            'tax_total_amount': self.sum_x_rechnung_currency(self.tax_total_amount) if self.tax_total_amount else 0,
+            'grand_total_amount': float(self.grand_total_amount.amount) if self.grand_total_amount else 0,
+            'total_prepaid_amount': float(self.total_prepaid_amount) if self.total_prepaid_amount else 0.0,
+            'due_payable_amount': float(self.due_payable_amount) if self.due_payable_amount else 0.0,
+            'seller': self.map_trade_party(self.seller) if self.seller else None,
+            'payee': self.map_trade_party(self.payee) if self.payee else None,
+            'buyer': self.map_trade_party(self.buyer) if self.buyer else None,
+            'invoicee': self.map_trade_party(self.invoicee) if self.invoicee else None,
+            'payment_means': self.map_payment_means(self.payment_means) if self.payment_means else None,
+            'trade_line_items': self.map_tradeline_items_to_dict(self.trade_line_items),
+            'applicable_trade_taxes': self.map_trade_taxes_to_dict(self.applicable_trade_taxes),
+        })
+        return _dict
+
+    @classmethod
+    def map_tradeline_to_dict(cls, x_trade_line: XRechnungTradeLine) -> dict:
+        _dict = asdict(x_trade_line)
+        _dict.update(
+            {'trade_tax': asdict(x_trade_line.trade_tax),
+             'price_unit': float(x_trade_line.price_unit),
+             'quantity_billed': float(x_trade_line.quantity_billed),
+             'total_amount_net': float(x_trade_line.total_amount_net),
+             })
+        return _dict
+
+    @classmethod
+    def map_tradeline_items_to_dict(cls, tradeline_items: list) -> list:
+        res = []
+        if tradeline_items:
+            for tradeline_item in tradeline_items:
+                res.append(cls.map_tradeline_to_dict(tradeline_item))
+        return res
+
+    @classmethod
+    def map_trade_taxes_to_dict(cls, trade_taxes: list) -> list:
+        res = []
+        if trade_taxes:
+            for tax in trade_taxes:
+                res.append(asdict(tax))
+        return res
+
+    @classmethod
+    def map_trade_party(cls, trade_party: XRechnungTradeParty) -> dict:
+        _dict = asdict(trade_party)
+        _dict.update({
+            'postal_address': cls.map_trade_address(trade_party.postal_address),
+            'trade_contact': cls.map_trade_contact(trade_party.trade_contact)
+        })
+        return _dict
+
+    @classmethod
+    def map_trade_address(cls, trade_address: XRechnungTradeAddress) -> dict | None:
+        if trade_address is None:
+            return None
+        _dict = asdict(trade_address)
+        return _dict
+
+    @classmethod
+    def map_trade_contact(cls, trade_contact: XRechnungTradeContact) -> dict | None:
+        if trade_contact is None:
+            return None
+        _dict = asdict(trade_contact)
+        return _dict
+
+    @classmethod
+    def map_payment_means(cls, payment_means: XRechnungPaymentMeans) -> dict:
+        _dict = {
+            'type_code': payment_means.type_code,
+            'information': payment_means.information,
+            'financial_card': cls.map_financial_card(
+                payment_means.financial_card) if payment_means.financial_card else None,
+            'bank_account': cls.map_bank_account(payment_means.payee_account) if payment_means.payee_account else None,
+        }
+        return _dict
+
+    @classmethod
+    def map_financial_card(cls, card: XRechnungFinancialCard) -> dict:
+        _dict = {
+            'card_number': card.id,
+            'card_holder_name': card.cardholder_name
+        }
+        return _dict
+
+    @classmethod
+    def map_bank_account(cls, bank: XRechnungBankAccount) -> dict:
+        _dict = {
+            'iban': bank.iban,
+            'bic': bank.bic
+        }
+        return _dict
+
+    @classmethod
+    def sum_x_rechnung_currency(cls, x_currencies: [XRechnungCurrency]) -> float:
+        res = 0.0
+        if x_currencies:
+            for x_currency in x_currencies:
+                res += float(x_currency.amount)
+        return res

tests/test_iban_handling.py

@@ -0,0 +1,24 @@
+import unittest
+from schwifty import IBAN
+
+_iban_1 = 'DE43500105175451887913'
+_bic_expected = 'INGDDEFFXXX'
+
+
+class IbanTestCase(unittest.TestCase):
+    def test_iban_decoding(self):
+        _ib_1: IBAN = IBAN(_iban_1)
+        self.assertIsNotNone(_ib_1)
+        _bank_code = _ib_1.bank_code
+        self.assertIsNotNone(_bank_code)
+        _account_code = _ib_1.account_code
+        self.assertIsNotNone(_account_code)
+        _country_code = _ib_1.country_code
+        self.assertIsNotNone(_country_code)
+        _bic = _ib_1.bic
+        self.assertIsNotNone(_bic)
+        self.assertEqual(_bic, _bic_expected)
+
+
+if __name__ == '__main__':
+    unittest.main()

tests/test_parse_x_rechnung.py

@@ -0,0 +1,82 @@
+import unittest
+import jsonpickle
+from parameterized import parameterized
+
+from facturx import get_facturx_xml_from_pdf
+
+from ..util.file_helper import get_checked_file_path
+from ..model.x_rechnung import XRechnung
+from ..x_mapper.cross_industry_invoice_mapper import parse_and_map_x_rechnung
+
+
+class XRechnungEinfachTestCase(unittest.TestCase):
+
+    def setUp(self) -> None:
+        jsonpickle.set_encoder_options("json", indent=2, ensure_ascii=False)
+        pass
+
+    @parameterized.expand([
+        ('xml', 'zugferd/XRECHNUNG_Einfach/xrechnung.xml'),
+        ('xml', 'real_invoice_samples/AKD-736116091815.xml'),
+        ('xml', 'griffity_exapmles/385_2025.xml'),
+        ('xml', 'e_invoicing_EN16931/CII-BR-CO-10-RoundingIssue.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_business_example_01.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_business_example_02.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_business_example_Z.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_example1.xml'),
+        # # ('xml', 'e_invoicing_EN16931/CII_example2.xml'),  # throws error
+        ('xml', 'e_invoicing_EN16931/CII_example3.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_example4.xml'),
+        # # ('xml', 'e_invoicing_EN16931/CII_example5.xml'),  # throws error
+        ('xml', 'e_invoicing_EN16931/CII_example6.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_example7.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_example8.xml'),
+        ('xml', 'e_invoicing_EN16931/CII_example9.xml'),
+        ('xml', 'ubl/RG00343552.xml'),
+        ('xml', 'ubl/ubl_invoice_example.xml'),
+        ('xml', 'ubl/UBL-Invoice-2.1-Example.xml'),
+        ('pdf', 'zugferd/BASIC-WL_Einfach/BASIC-WL_Einfach.pdf'),
+        # ('pdf', 'zugferd/XRECHNUNG_Einfach/XRECHNUNG_Einfach.pdf'), # needs some checks, why test failed
+        # ("pdf", "zugferd/XRECHNUNG_Elektron/XRECHNUNG_Elektron.pdf"), # needs some checks, why test failed
+        ('pdf', 'odoo_generated/INV_2025_00001.pdf')
+    ])
+    def test_x_rechnung_files(self, file_type, file_path):
+        print(f"start testing with file: {file_path}")
+        if file_type == 'xml':
+            _parsed = self._parse_xml(file_path)
+        elif file_type == 'pdf':
+            _parsed = self._parse_pdf(file_path)
+        else:
+            raise AssertionError(f'File type {file_type} not supported')
+        assert _parsed is not None
+        res_dict = _parsed.map_to_dict()
+        print(jsonpickle.dumps(res_dict))
+
+    def _parse_xml(self, filepath) -> XRechnung:
+        _file_path, _exists, _is_dir = get_checked_file_path(filepath, __file__)
+        self.assertTrue(_exists)
+        print(f"\n_parse_xml: file_path={_file_path}")
+        with open(_file_path, "rb") as _file:
+            samplexml = _file.read()
+            res = parse_and_map_x_rechnung(samplexml)
+            self.assertIsNotNone(res)
+            return res
+
+    def _parse_pdf(self, filepath) -> XRechnung:
+        _file_path, _exists, _is_dir = get_checked_file_path(filepath, __file__)
+        self.assertTrue(_exists)
+        print(f"\n_parse_pdf: file_path={_file_path}")
+        with open(_file_path, "rb") as _file:
+            sample_pdf = _file.read()
+            filename, xml = get_facturx_xml_from_pdf(sample_pdf, False)
+            print(xml)
+            if not xml or len(xml) == 0:
+                raise FileNotFoundError(
+                    f"Could not extraxt XML from PDF file: {filepath}")
+            res = parse_and_map_x_rechnung(xml)
+            self.assertIsNotNone(res)
+            return res
+
+
+if __name__ == '__main__':
+    unittest.main()

util/file_helper.py

@@ -0,0 +1,24 @@
+"""
+Helper functions for working with files and directories.
+"""
+
+from os import path as os_path
+
+
+def get_checked_file_path(file_path: str, rel_file=None) -> (str, bool, bool):
+    """
+    get relative or absolute file path
+    Args:
+        file_path: path to file, relative or absolute
+        rel_file: if not none then this is the base dir-path to the file_path
+
+    Returns: (str, bool, bool) resulting path to file, file exists, is directory
+
+    """
+    if rel_file is None or file_path.startswith("/"):
+        _path = os_path.normpath(file_path)  # absolute
+    else:
+        rel_dir = os_path.dirname(rel_file)
+        fp = os_path.normpath(file_path)
+        _path = os_path.join(rel_dir, fp)
+    return _path, os_path.exists(_path), os_path.isdir(_path)

x_mapper/__init__.py

@@ -0,0 +1,8 @@
+from .cross_industry_invoice_mapper import parse_and_map_x_rechnung
+from .xml_abstract_x_rechnung_parser import XMLAbstractXRechnungParser
+from .xml_cii_dom_parser import XRechnungCIIXMLParser
+from .xml_ubl_sax_parser import XRechnungUblXMLParser
+from .drafthorse_elements_helper import get_string_from_text as get_string_from_text
+__all__ = ["parse_and_map_x_rechnung", "cross_industry_invoice_mapper", "drafthorse_elements_helper",
+           "XMLAbstractXRechnungParser",
+           "XRechnungCIIXMLParser", "XRechnungUblXMLParser"]

x_mapper/cross_industry_invoice_mapper.py

@@ -0,0 +1,20 @@
+"""
+This implements a mapper from a drafthorse parsed x-rechnung-xml to the internal XRechnung object
+"""
+from lxml import etree
+
+from ..model.x_rechnung import XRechnung
+from ..x_mapper.xml_cii_dom_parser import XRechnungCIIXMLParser
+from ..x_mapper.xml_ubl_sax_parser import XRechnungUblXMLParser
+
+
+def parse_and_map_x_rechnung(_xml: any) -> XRechnung:
+    _parser = None
+    tree = etree.fromstring(_xml)
+    if tree.tag == '{urn:un:unece:uncefact:data:standard:CrossIndustryInvoice:100}CrossIndustryInvoice':
+        _parser = XRechnungCIIXMLParser()
+    elif tree.tag == '{urn:oasis:names:specification:ubl:schema:xsd:Invoice-2}Invoice':
+        _parser = XRechnungUblXMLParser()
+    if _parser is None:
+        raise ValueError(f'xml format not supported: "{tree.tag}"')
+    return _parser.parse_and_map_x_rechnung(_xml)

x_mapper/drafthorse_elements_helper.py

@@ -0,0 +1,132 @@
+from drafthorse.models.elements import (StringElement, DirectDateTimeElement, DateTimeElement, DecimalElement,
+                                        IndicatorElement, QuantityElement, CurrencyElement, ClassificationElement,
+                                        Container)
+from drafthorse.models.party import EmailURI, PhoneNumber, FaxNumber
+from drafthorse.models.note import IncludedNote
+from drafthorse.models.payment import PaymentTerms
+from drafthorse.models.container import IDContainer, StringContainer, CurrencyContainer
+
+"""
+Code zur Beschreibung des Datumsformats
+Codeliste:
+102 = CCYYMMDD
+201 = YYMMDDHHMM
+615 = YYWW
+616 = CCYYWW
+720 = THHMMTHHMM
+804 = Anzahl Tage
+Beispiel: <DocumentDate FormatCode="102">20160331</DocumentDate>
+"""
+
+
+def get_value(self) -> any:
+    return self._value
+
+
+def get_value_from_amount(self) -> any:
+    return self._amount
+
+
+def get_currency(self) -> (any, any):
+    return self._amount, self._currency
+
+
+def get_currencies(self) -> [(any, any)]:
+    res = []
+    if self.children:
+        for currency in self.children:
+            res.append(currency)
+    return res
+
+
+def get_string_from_text(self) -> str:
+    return self._text
+
+
+def get_string_from_payment_terms(self, separator) -> str:
+    return str(self.description)
+
+
+def get_string_from_value(self) -> str:
+    return str(self._value)
+
+
+def get_string_from_data(self) -> str:
+    return str(self._data)
+
+
+def get_string_from_address(self) -> str:
+    return str(self.address)
+
+
+def get_string_from_number(self) -> str:
+    return str(self.number)
+
+
+def get_string_from_date(self) -> str:
+    return str(self._value)
+
+
+def get_string_from_quantity(self) -> str:
+    return str(f"{self._amount} {self._unit_code}")
+
+
+def get_string_from_currency(self) -> str:
+    return str(f"{self._amount} {self._currency}")
+
+
+def get_string_from_content(self, separator) -> str:
+    if not self.content:
+        return ""
+    return self.content.get_string_elements(separator)
+
+
+def get_string_elements(self, separator: str = ';') -> str:
+    res = ""
+    _separator = ""
+    if self.children:
+        for child in self.children:
+            if isinstance(child, str):
+                res += _separator + child
+            elif isinstance(child, tuple):
+                p1, p2 = child[:]
+                res += f"{p1} {p2} {_separator}"
+            else:
+                res += _separator + child.get_string(separator)
+            _separator = separator
+    return res
+
+
+def get_ids(self) -> list:
+    res = list()
+    if self.children:
+        for text, _id, in self.children:
+            res.append({
+                'id': _id,
+                'schema': text,
+            })
+    return res
+
+
+StringElement.get_string = get_string_from_text
+StringContainer.get_string = get_string_elements
+DirectDateTimeElement.get_string = get_string_from_date
+DateTimeElement.get_string = get_string_from_date
+DateTimeElement.get_value = get_value
+DecimalElement.get_string = get_string_from_value
+DecimalElement.get_value = get_value
+IndicatorElement.get_string = get_string_from_value
+QuantityElement.get_string = get_string_from_quantity
+QuantityElement.get_value = get_value_from_amount
+CurrencyElement.get_currency = get_currency
+CurrencyContainer.get_string = get_string_elements
+CurrencyContainer.get_currencies = get_currencies
+ClassificationElement.get_string = get_string_from_text
+IDContainer.get_object = get_ids
+EmailURI.get_string = get_string_from_address
+PhoneNumber.get_string = get_string_from_number
+FaxNumber.get_string = get_string_from_number
+Container.get_string_elements = get_string_elements
+IncludedNote.get_string = get_string_from_content
+IncludedNote.get_string_elements = get_string_elements
+PaymentTerms.get_string = get_string_from_payment_terms

x_mapper/xml_abstract_x_rechnung_parser.py

@@ -0,0 +1,21 @@
+from abc import ABC, abstractmethod
+
+from ..model.x_rechnung import XRechnung
+
+
+class XMLAbstractXRechnungParser(ABC):
+    TYPE_CODES = {
+        '326': 'Partial invoice',
+        '380': 'Commercial invoice',  # Rechnung
+        '384': 'Corrected invoice',  # Rechnungskorrektur
+        '389': 'Self-billed invoice',  # Selbst erstelle Rechnung
+        '381': 'Credit note',  # Gutschrift
+        '875': 'Partial Invoice',  # Abschlagsrechnung
+        '876': 'Partial final invoice',  # Teilschlussrechnung
+        '877': 'Final invoice'  # Schlussrechnung
+    }
+
+    @staticmethod
+    @abstractmethod
+    def parse_and_map_x_rechnung(_xml: any) -> XRechnung:
+        pass