Support RP1.0 without extension Taxonomy #73

Author: antonheitz

src/xbrl_forge/__init__.py

@@ -5,12 +5,9 @@
 from .logger_setup import logger_conf
 logger_conf()
 
-from .xbrl_generation.ContentDataclasses import ContentDocument
-from .xbrl_generation.XbrlProducer import XbrlProducer
 from .xbrl_generation.PackageDataclasses import File
 from .xbrl_generation.InputData import InputData
-from .xbrl_generation.HtmlProducer import HtmlProducer
-from .xbrl_generation.TaxonomyProducer import TaxonomyProducer
+from .xbrl_generation.PackageProducer import PackageProducer
 from .utils.schema_validation import validate_schema
 from .file_conversion import doc_to_data
 
@@ -39,49 +36,5 @@ def create_xbrl(input_data_list: List[InputData], xthml_template: str = None) ->
     logger.info(f"Creating XBRL")
     # load data
     loaded_data: InputData = InputData.combine(input_data_list)
-    local_namespace = None
-    local_namespace_prefix = None
-    local_taxonomy_schema = None
-    if loaded_data.taxonomy:
-        local_namespace=loaded_data.taxonomy.namespace
-        local_namespace_prefix=loaded_data.taxonomy.prefix 
-        local_taxonomy_schema=loaded_data.taxonomy.schema_url
-    reports_folder: File = None
-    untagged_reports_folder: File = None
-    inline_instances: int = 0
-    non_inline_instances: int = 0
-    for report in loaded_data.reports:
-        if not reports_folder:        
-            reports_folder = File("reports", contained_files=[])
-        if report.xhtml:
-            html_producer: HtmlProducer = HtmlProducer(
-                report, 
-                xthml_template=xthml_template, 
-                local_namespace=local_namespace, 
-                local_namespace_prefix=local_namespace_prefix, 
-                local_taxonomy_schema=local_taxonomy_schema
-            )
-            if html_producer.ixbrl:
-                reports_folder.contained_files.append(html_producer.create_html())
-                inline_instances += 1
-            else:
-                if not untagged_reports_folder:
-                    untagged_reports_folder: File = File("untagged_reports", contained_files=[])
-                    reports_folder.contained_files.append(untagged_reports_folder)
-                untagged_reports_folder.contained_files.append(html_producer.create_html())
-        else:
-            xbrl_producer: XbrlProducer = XbrlProducer(
-                report, 
-                local_namespace=local_namespace, 
-                local_namespace_prefix=local_namespace_prefix, 
-                local_taxonomy_schema=local_taxonomy_schema
-            )
-            reports_folder.contained_files.append(xbrl_producer.create_xbrl())
-            non_inline_instances += 1
-    if not loaded_data.taxonomy:
-        return reports_folder
-    taxonomy_producer: TaxonomyProducer = TaxonomyProducer(loaded_data.taxonomy)
-    package_extension: str = "zip"
-    if inline_instances == 1 and non_inline_instances == 0: package_extension = "xbri"
-    if inline_instances == 0 and non_inline_instances == 1: package_extension = "xbr"
-    return taxonomy_producer.create_files(reports_folder, package_extension)
+    producer: PackageProducer = PackageProducer(loaded_data, xthml_template=xthml_template)
+    return producer.get_package()

src/xbrl_forge/xbrl_generation/PackageDataclasses.py

@@ -9,13 +9,19 @@
 
 logger = logging.getLogger(__name__)
 
+@dataclass
+class PACKAGE_EXTENSIONS:
+    ZIP: str = "zip"
+    XBRI: str = "xbri"
+    XBR: str = "xbr"
+
 class File:
     name: str
     content: str 
     contained_files: List['File'] 
     zip_extension: str
 
-    def __init__(cls, name: str, content: str = None, contained_files: List['File'] = None, zip_extension: str = "zip"):
+    def __init__(cls, name: str, content: str = None, contained_files: List['File'] = None, zip_extension: str = PACKAGE_EXTENSIONS.ZIP):
         cls.name = name
         cls.content = content
         cls.contained_files = [] if contained_files == None else contained_files
@@ -119,4 +125,4 @@ def to_dict(cls) -> dict:
         return {
             "schema_location": cls.schema_location,
             "element_id": cls.element_id
-        }
+        }

src/xbrl_forge/xbrl_generation/PackageProducer.py

@@ -0,0 +1,105 @@
+import json
+
+from typing import List, Dict
+
+from .PackageDataclasses import File, PACKAGE_EXTENSIONS
+from .InputData import InputData
+from .HtmlProducer import HtmlProducer
+from .XbrlProducer import XbrlProducer
+from .TaxonomyProducer import TaxonomyProducer
+
+PACKAGE_EXTENSION_URIS: Dict[str, str] = {
+    PACKAGE_EXTENSIONS.ZIP: "https://xbrl.org/report-package/2023",
+    PACKAGE_EXTENSIONS.XBRI: "https://xbrl.org/report-package/2023/xbri",
+    PACKAGE_EXTENSIONS.XBR: "https://xbrl.org/report-package/2023/xbr"
+}
+
+class PackageProducer:
+    local_namespace: str
+    local_namespace_prefix: str
+    local_taxonomy_schema: str
+    root_folder: File
+
+    def __init__(cls, input_data: InputData, xthml_template: str = None):
+        # get namespace data
+        cls.local_namespace = None
+        cls.local_namespace_prefix = None
+        cls.local_taxonomy_schema = None
+        if input_data.taxonomy:
+            cls.local_namespace=input_data.taxonomy.namespace
+            cls.local_namespace_prefix=input_data.taxonomy.prefix 
+            cls.local_taxonomy_schema=input_data.taxonomy.schema_url
+        # create reports
+        inline_xbrl_reports: List[File] = []
+        xbrl_reports: List[File] = []
+        xhtml_reports: List[File] = []
+        for report in input_data.reports:
+            if report.xhtml:
+                html_producer: HtmlProducer = HtmlProducer(
+                    report, 
+                    xthml_template=xthml_template, 
+                    local_namespace=cls.local_namespace, 
+                    local_namespace_prefix=cls.local_namespace_prefix, 
+                    local_taxonomy_schema=cls.local_taxonomy_schema
+                )
+                if html_producer.ixbrl:
+                    inline_xbrl_reports.append(html_producer.create_html())
+                else:
+                    xhtml_reports.append(html_producer.create_html())
+            else:
+                xbrl_producer: XbrlProducer = XbrlProducer(
+                    report, 
+                    local_namespace=cls.local_namespace, 
+                    local_namespace_prefix=cls.local_namespace_prefix, 
+                    local_taxonomy_schema=cls.local_taxonomy_schema
+                )
+                xbrl_reports.append(xbrl_producer.create_xbrl())
+        # create taxonomy
+        taxonomy_meta_inf_files: List[File] = []
+        taxonomy_folder: File = None
+        if input_data.taxonomy:
+            taxonomy_producer: TaxonomyProducer = TaxonomyProducer(input_data.taxonomy)
+            taxonomy_meta_inf_files = taxonomy_producer.get_meta_inf_files()
+            taxonomy_folder = taxonomy_producer.get_taxonomy()
+
+        package_extension: str = PACKAGE_EXTENSIONS.ZIP
+        if len(inline_xbrl_reports) == 1 and not xbrl_reports:
+            package_extension = PACKAGE_EXTENSIONS.XBRI
+        elif len(xbrl_reports) == 1 and not inline_xbrl_reports:
+            package_extension = PACKAGE_EXTENSIONS.XBR
+        
+        # create base folder
+        root_folder_name: str = "EMPTY"
+        if input_data.taxonomy:
+            root_folder_name = f'{"_".join(input_data.taxonomy.metadata.name.split())}'
+        elif inline_xbrl_reports:
+            root_folder_name = inline_xbrl_reports[0].name.split(".")[0]
+        elif xbrl_reports:
+            root_folder_name = xbrl_reports[0].name.split(".")[0]
+        elif xhtml_reports:
+            root_folder_name = xhtml_reports[0].name.split(".")[0]
+        cls.root_folder: File = File(name=root_folder_name, zip_extension=package_extension)
+        
+        # add content
+        meta_inf_folder: File = File(name="META-INF", contained_files=taxonomy_meta_inf_files)
+        cls.root_folder.contained_files.append(meta_inf_folder)
+        if taxonomy_folder:
+            cls.root_folder.contained_files.append(taxonomy_folder)
+        if xbrl_reports or inline_xbrl_reports or xhtml_reports:
+            reports_folder: File = File("reports", contained_files=xbrl_reports + inline_xbrl_reports)
+            cls.root_folder.contained_files.append(reports_folder)
+            if xhtml_reports:
+                untagged_reports_folder: File = File("untagged_reports", contained_files=xhtml_reports)
+                reports_folder.contained_files.append(untagged_reports_folder)
+            # add reportPackage.json
+            meta_inf_folder.contained_files.append(File(
+                name="reportPackage.json",
+                content=json.dumps({
+                    "documentInfo": {
+                        "documentType": PACKAGE_EXTENSION_URIS.get(package_extension)
+                    }
+                })
+            ))
+
+    def get_package(cls) -> File:
+        return cls.root_folder

src/xbrl_forge/xbrl_generation/TaxonomyProducer.py

@@ -31,28 +31,34 @@
 
 class TaxonomyProducer:
     taxonomy_document: TaxonomyDocument
+    taxonomy_root_folder: File
+    taxonomy_folder: File
+    meta_inf_files: List[File]
 
     def __init__(cls, document: TaxonomyDocument):
         cls.taxonomy_document = document
-
-    def create_files(cls, reports_folder: File = None, package_extension: str = "zip") -> File:
-        # create base folder structure
-        root_folder = File(name=f'{"_".join(cls.taxonomy_document.metadata.name.split())}', zip_extension=package_extension)
-        if reports_folder:
-            root_folder.contained_files.append(reports_folder)
+        cls.taxonomy_root_folder = None
+        cls.taxonomy_folder = None
         # create taxonomy files
-        taxonomy_folder = root_folder
         for part in cls.taxonomy_document.rewrite_path:
-            parent_folder = taxonomy_folder
-            taxonomy_folder = File(name=part)
-            parent_folder.contained_files.append(taxonomy_folder)
-        cls._create_taxonomy_files(taxonomy_folder)
-        # create meta information
-        meta_inf_folder = File(name="META-INF", contained_files=cls._create_meta_inf_files(package_extension if reports_folder else None))
-        root_folder.contained_files.append(meta_inf_folder)
-        return root_folder
+            if not cls.taxonomy_root_folder:
+                cls.taxonomy_root_folder = File(name=part)
+                cls.taxonomy_folder = cls.taxonomy_root_folder
+            else:
+                parent_folder = cls.taxonomy_folder
+                cls.taxonomy_folder = File(name=part)
+                parent_folder.contained_files.append(cls.taxonomy_folder)
+        cls._create_taxonomy_files()
+        cls.meta_inf_files = []
+        cls._create_meta_inf_files()
+
+    def get_taxonomy(cls) -> File:
+        return cls.taxonomy_root_folder
+    
+    def get_meta_inf_files(cls) -> List[File]:
+        return cls.meta_inf_files
 
-    def _create_meta_inf_files(cls, package_extension: str = None) -> List[File]:
+    def _create_meta_inf_files(cls) -> List[File]:
         # create catalog file
         catalog_namespace: str = "urn:oasis:names:tc:entity:xmlns:xml:catalog"
         catalog_namespace_map = {
@@ -160,7 +166,7 @@ def _create_meta_inf_files(cls, package_extension: str = None) -> List[File]:
             )
             ep_lang_element.text = entrypoint.language
 
-        return_files: List[File] = [
+        cls.meta_inf_files = [
             File(
                 name="catalog.xml", 
                 content=xml_to_string(
@@ -176,52 +182,36 @@ def _create_meta_inf_files(cls, package_extension: str = None) -> List[File]:
             )
         ]
 
-        if package_extension:
-            supported_package_extensions: Dict[str, str] = {
-                "zip": "https://xbrl.org/report-package/2023",
-                "xbri": "https://xbrl.org/report-package/2023/xbri",
-                "xbr": "https://xbrl.org/report-package/2023/xbr"
-            }
-            return_files.append(File(
-                name="reportPackage.json",
-                content=json.dumps({
-                    "documentInfo": {
-                        "documentType": supported_package_extensions.get(package_extension)
-                    }
-                })
-            ))
-        return return_files
-
-    def _create_taxonomy_files(cls, taxonomy_folder: File) -> None:
+    def _create_taxonomy_files(cls) -> None:
         logger.debug(f"Creating taxonomy schema for namespace {cls.taxonomy_document.namespace}")
-        cls._create_schema(taxonomy_folder)
+        cls._create_schema(cls.taxonomy_folder)
         presentation_linkbase_filename: str = f"{cls.taxonomy_document.files_base_name}_pre.xml"
         logger.debug(f"Creating presentation linkbase {presentation_linkbase_filename}")
         cls._create_linkbase(
             presentation_linkbase_filename,
-            taxonomy_folder,
+            cls.taxonomy_folder,
             cls._create_presentation()
         )
         calculation_linkbase_filename: str = f"{cls.taxonomy_document.files_base_name}_cal.xml"
         logger.debug(f"Creating calculation linkbase {calculation_linkbase_filename}")
         cls._create_linkbase(
             calculation_linkbase_filename,
-            taxonomy_folder,
+            cls.taxonomy_folder,
             cls._create_calculation()
         )
         definition_linkbase_filename: str = f"{cls.taxonomy_document.files_base_name}_def.xml"
         logger.debug(f"Creating defintion linkbase {definition_linkbase_filename}")
         cls._create_linkbase(
             definition_linkbase_filename,
-            taxonomy_folder,
+            cls.taxonomy_folder,
             cls._create_definition()
         )
         for labels_lang in cls.taxonomy_document.labels:
             label_linkbase_filename: str = f"{cls.taxonomy_document.files_base_name}_lab-{labels_lang}.xml"
             logger.debug(f"Creating label linkbase language {labels_lang} {label_linkbase_filename}")
             cls._create_linkbase(
                 label_linkbase_filename,
-                taxonomy_folder,
+                cls.taxonomy_folder,
                 cls._create_label_linkbase(labels_lang)   
             )