tricc-oo 1.5.13__py3-none-any.whl → 1.6.8__py3-none-any.whl

tests/build.py

@@ -1,10 +1,18 @@
+from tricc_oo.strategies.output.spice import SpiceStrategy  # noqa: F401
+from tricc_oo.strategies.output.xlsform_cht_hf import XLSFormCHTHFStrategy  # noqa: F401
+from tricc_oo.strategies.output.xlsform_cht import XLSFormCHTStrategy  # noqa: F401
+from tricc_oo.strategies.output.xlsform_cdss import XLSFormCDSSStrategy  # noqa: F401
+from tricc_oo.strategies.output.xls_form import XLSFormStrategy  # noqa: F401
+from tricc_oo.strategies.output.openmrs_form import OpenMRSStrategy  # noqa: F401
+from tricc_oo.strategies.output.fhir_form import FHIRStrategy  # noqa: F401
+from tricc_oo.strategies.output.html_form import HTMLStrategy  # noqa: F401
+from tricc_oo.strategies.output.dhis2_form import DHIS2Strategy  # noqa: F401
+from tricc_oo.strategies.input.drawio import DrawioStrategy  # noqa: F401
 import getopt
-import gettext
 import logging
 import os
 import sys
 import gc
-import shutil
 from pathlib import Path
 
 # set up logging to file
@@ -23,15 +31,9 @@ langs = SingletonLangClass()
 # langs.add_trad('fr', fr)
 # langs.add_trad('en', en)
 
-from tricc_oo.strategies.input.drawio import DrawioStrategy
 
 # from tricc_oo.serializers.medalcreator import execute
 
-from tricc_oo.strategies.output.xls_form import XLSFormStrategy
-from tricc_oo.strategies.output.xlsform_cdss import XLSFormCDSSStrategy
-from tricc_oo.strategies.output.xlsform_cht import XLSFormCHTStrategy
-from tricc_oo.strategies.output.xlsform_cht_hf import XLSFormCHTHFStrategy
-from tricc_oo.strategies.output.spice import SpiceStrategy
 
 def setup_logger(
     logger_name,
@@ -39,15 +41,15 @@ def setup_logger(
     level=logging.INFO,
     formatting="[%(asctime)s] {%(pathname)s:%(lineno)d} %(levelname)s - %(message)s",
 ):
-    l = logging.getLogger(logger_name)
+    logger = logging.getLogger(logger_name)
     formatter = logging.Formatter(formatting)
     file_handler = logging.FileHandler(log_file, mode="w+")
     file_handler.setFormatter(formatter)
     stream_handler = logging.StreamHandler()
     stream_handler.setFormatter(formatter)
 
-    l.setLevel(level)
-    l.addHandler(file_handler)
+    logger.setLevel(level)
+    logger.addHandler(file_handler)
 
 
 class ColorFormatter(logging.Formatter):
@@ -94,9 +96,7 @@ LEVELS = {
 
 
 def print_help():
-    print(
-        "-i / --input draw.io filepath (MANDATORY) or directory containing drawio files"
-    )
+    print("-i / --input draw.io filepath (MANDATORY) or directory containing drawio files")
     print("-o / --output xls file ")
     print("-d form_id ")
     print("-s L4 system/strategy (odk, cht, cc)")
@@ -116,9 +116,7 @@ if __name__ == "__main__":
     input_strategy = "DrawioStrategy"
     output_strategy = "XLSFormStrategy"
     try:
-        opts, args = getopt.getopt(
-            sys.argv[1:], "hti:o:s:I:O:l:d:D:", ["input=", "output=", "help", "trads"]
-        )
+        opts, args = getopt.getopt(sys.argv[1:], "hti:o:s:I:O:l:d:D:", ["input=", "output=", "help", "trads"])
     except getopt.GetoptError:
         print_help()
         sys.exit(1)
@@ -145,7 +143,7 @@ if __name__ == "__main__":
     if in_filepath is None:
         print_help()
         sys.exit(2)
-    
+
     if not download_dir:
         download_dir = out_path
     debug_path = os.fspath(out_path + "/debug.log")
@@ -165,7 +163,7 @@ if __name__ == "__main__":
         setup_logger("default", debug_file_path, logging.INFO)
     file_content = []
     files = []
-    in_filepath_list = in_filepath.split(',')
+    in_filepath_list = in_filepath.split(",")
     for in_filepath in in_filepath_list:
         pre, ext = os.path.splitext(in_filepath)
 
@@ -173,18 +171,13 @@ if __name__ == "__main__":
             # if output file path not specified, just chagne the extension
             out_path = os.path.dirname(pre)
 
-
         if os.path.isdir(in_filepath):
-            files = [
-                os.path.join(in_filepath, f)
-                for f in os.listdir(in_filepath) 
-                if f.endswith(".drawio")
-            ]
+            files = [os.path.join(in_filepath, f) for f in os.listdir(in_filepath) if f.endswith(".drawio")]
         elif os.path.isfile(in_filepath) and in_filepath.endswith(".drawio"):
             files = [in_filepath]
-            
+
         for f in files:
-            with open(f, 'r') as s:
+            with open(f, "r") as s:
                 content = s.read()
                 # present issue with some drawio file that miss the XML header
 
@@ -193,7 +186,6 @@ if __name__ == "__main__":
         logger.critical(f"{in_filepath} is neither a drawio file nor a directory containing drawio files")
         exit(1)
 
-
     strategy = globals()[input_strategy](files)
     logger.info(f"build the graph from strategy {input_strategy}")
     media_path = os.path.join(out_path, "media-tmp")

tests/test_build.py

@@ -0,0 +1,260 @@
+import unittest
+import subprocess
+import sys
+import os
+import tempfile
+import shutil
+from pathlib import Path
+import pandas as pd
+from pyxform import create_survey_from_xls
+
+
+class TestBuildScript(unittest.TestCase):
+    """Test cases for the build.py script with different argument combinations."""
+
+    def setUp(self):
+        """Set up test fixtures."""
+        self.test_data_dir = Path(__file__).parent / "data"
+        self.test_output_dir = Path(__file__).parent / "output"
+        self.demo_file = self.test_data_dir / "demo.drawio"
+
+        # Ensure test data exists
+        self.assertTrue(self.demo_file.exists(), f"Test data file {self.demo_file} does not exist")
+
+    def run_build_script(self, args):
+        """Helper method to run build.py with given arguments."""
+        cmd = [sys.executable, str(Path(__file__).parent / "build.py")] + args
+        result = subprocess.run(cmd, capture_output=True, text=True, cwd=Path(__file__).parent.parent)
+        return result
+
+    def test_basic_build_with_demo_file(self):
+        """Test basic build with demo.drawio file."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_directory_input(self):
+        """Test build with directory containing drawio files."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.test_data_dir),
+                "-o", temp_dir,
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_xlsform_strategy(self):
+        """Test build with XLSFormStrategy (default)."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "XLSFormStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_html_strategy(self):
+        """Test build with HTMLStrategy."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "HTMLStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_fhir_strategy(self):
+        """Test build with FHIRStrategy."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "FHIRStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_dhis2_strategy(self):
+        """Test build with DHIS2Strategy."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "DHIS2Strategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_openmrs_strategy(self):
+        """Test build with OpenMRSStrategy."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "OpenMRSStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_cht_strategy(self):
+        """Test build with XLSFormCHTStrategy."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "XLSFormCHTStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_cht_hf_strategy(self):
+        """Test build with XLSFormCHTHFStrategy."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "XLSFormCHTHFStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_cdss_strategy(self):
+        """Test build with XLSFormCDSSStrategy."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "XLSFormCDSSStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    # def test_build_with_spice_strategy(self):
+    #     """Test build with SpiceStrategy."""
+    #     with tempfile.TemporaryDirectory() as temp_dir:
+    #         args = [
+    #             "-i", str(self.demo_file),
+    #             "-o", temp_dir,
+    #             "-O", "SpiceStrategy",
+    #             "-l", "i"
+    #         ]
+    #         result = self.run_build_script(args)
+    #         self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_debug_level(self):
+        """Test build with debug logging level."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-l", "d"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_trad_option(self):
+        """Test build with translation option."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-t",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_with_form_id(self):
+        """Test build with custom form ID."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-d", "test_form_123",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+    def test_build_missing_input(self):
+        """Test build with missing input file."""
+        args = ["-o", "/tmp/test_output"]
+        result = self.run_build_script(args)
+        self.assertNotEqual(result.returncode, 0, "Build should fail with missing input")
+
+    def test_build_invalid_input_file(self):
+        """Test build with invalid input file."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            args = [
+                "-i", "/nonexistent/file.drawio",
+                "-o", temp_dir,
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertNotEqual(result.returncode, 0, "Build should fail with invalid input file")
+
+    def validate_xls_form(self, xls_path):
+        """Helper method to validate XLS form using ODK libraries."""
+        try:
+            # Convert XLS to XML using pyxform
+            survey = create_survey_from_xls(xls_path)
+            xml_output = survey.to_xml()
+
+            # Basic validation - check if XML was generated successfully
+            # In a real scenario, you might want to use odk_validate command line tool
+            if xml_output and len(xml_output.strip()) > 0:
+                return True, "Validation successful"
+            else:
+                return False, "Empty XML output"
+        except Exception as e:
+            return False, str(e)
+
+    def test_xlsform_strategy_validation(self):
+        """Test XLSFormStrategy output validation with ODK libraries."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            xls_output = Path(temp_dir) / "demo_tricc.xlsx"
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "XLSFormStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+            # Check if XLS file was created
+            self.assertTrue(xls_output.exists(), f"XLS file {xls_output} was not created")
+
+    def test_xlsform_cdss_strategy_validation(self):
+        """Test XLSFormCDSSStrategy output validation with ODK libraries."""
+        with tempfile.TemporaryDirectory() as temp_dir:
+            xls_output = Path(temp_dir) / "demo_tricc.xlsx"
+            args = [
+                "-i", str(self.demo_file),
+                "-o", temp_dir,
+                "-O", "XLSFormCDSSStrategy",
+                "-l", "i"
+            ]
+            result = self.run_build_script(args)
+            self.assertEqual(result.returncode, 0, f"Build failed: {result.stderr}")
+
+
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_cql.py

@@ -1,51 +1,40 @@
 import unittest
 
-from tricc_oo.converters.cql_to_operation import cqlToXlsFormVisitor, transform_cql_to_operation
-from tricc_oo.models.base import  TriccOperator, TriccOperation, TriccStatic, TriccReference
+from tricc_oo.converters.cql_to_operation import transform_cql_to_operation
+from tricc_oo.models.base import TriccOperator, TriccOperation, TriccStatic, TriccReference
+
 
 class TestCql(unittest.TestCase):
     def test_and(self):
-        if_cql = "\"p_weight\" is not null and \"p_age\" > 2"
+        if_cql = '"p_weight" is not null and "p_age" > 2'
         dg_operation = transform_cql_to_operation(if_cql)
         dg_expected = TriccOperation(
             operator=TriccOperator.AND,
             reference=[
-                TriccOperation(
-                    operator=TriccOperator.NOT,
-                    reference=[
-                        TriccOperation(
-                            operator=TriccOperator.ISNULL,
-                            reference=[TriccReference("p_weight")]
-                        )
-                    ]
-                ),
-                TriccOperation(
-                    operator=TriccOperator.MORE,
-                    reference=[
-                        TriccReference("p_age"),
-                        TriccStatic(
-                            value=2
-                        )
-                    ]
-                )
-            ]
+                TriccOperation(operator=TriccOperator.ISNOTNULL, reference=[TriccReference("p_weight")]),
+                TriccOperation(operator=TriccOperator.MORE, reference=[TriccReference("p_age"), TriccStatic(value=2)]),
+            ],
         )
         self.assertEqual(str(dg_operation), str(dg_expected))
-    
-   
+
     def test_durg_doage(self):
-        if_cql = "DrugDosage('paracetamol', \"p_weight\", \"p_age\")"
+        if_cql = 'DrugDosage(\'paracetamol\', "p_weight", "p_age")'
         dg_operation = transform_cql_to_operation(if_cql)
         dg_expected = TriccOperation(
             operator=TriccOperator.DRUG_DOSAGE,
-            reference=[
-                TriccStatic(value='paracetamol'),
-                TriccReference("p_weight"),
-                TriccReference("p_age")
-            ]
+            reference=[TriccStatic(value="paracetamol"), TriccReference("p_weight"), TriccReference("p_age")],
         )
         self.assertEqual(str(dg_operation), str(dg_expected))
-    
+
+    def test_implied_concat(self):
+        if_cql = "'A' & \"B\" & 'C'"
+        cc_operation = transform_cql_to_operation(if_cql)
+        cc_expected = TriccOperation(
+            operator=TriccOperator.CONCATENATE,
+            reference=[TriccStatic(value="A"), TriccReference("B"), TriccStatic(value="C")],
+        )
+        self.assertEqual(str(cc_operation), str(cc_expected))
+
     def test_if(self):
         if_cql = "if AgeInDays() < 60 then 'newborn' else 'child'"
         if_operation = transform_cql_to_operation(if_cql)
@@ -54,61 +43,36 @@ class TestCql(unittest.TestCase):
             reference=[
                 TriccOperation(
                     operator=TriccOperator.LESS,
-                    reference=[
-                        TriccOperation(
-                            operator=TriccOperator.AGE_DAY,
-                            reference=[]
-                        ),
-                        TriccStatic(
-                            value=60
-                        )
-                    ]
+                    reference=[TriccOperation(operator=TriccOperator.AGE_DAY, reference=[]), TriccStatic(value=60)],
                 ),
-                TriccStatic(value='newborn'),
-                TriccStatic(value='child'),
-            ]
+                TriccStatic(value="newborn"),
+                TriccStatic(value="child"),
+            ],
         )
         self.assertEqual(str(if_operation), str(if_expected))
 
     def test_case(self):
         case_cql = """
-        case AgeInMonths() 
-        when 0 then 'newborn' 
-        when 1 then 'newborn' 
+        case AgeInMonths()
+        when 0 then 'newborn'
+        when 1 then 'newborn'
         else 'child' end
         """
         case_operation = transform_cql_to_operation(case_cql)
         case_expected = TriccOperation(
             operator=TriccOperator.CASE,
             reference=[
-                TriccOperation(
-                    operator=TriccOperator.AGE_MONTH,
-                    reference=[]
-                ),
-                [
-                    TriccStatic(
-                        value=0
-                    ),
-                    TriccStatic(
-                        value="newborn"
-                    )
-                ],
-                [
-                    TriccStatic(
-                        value=1
-                    ),
-                    TriccStatic(
-                        value="newborn"
-                    )
-                ],
-                TriccStatic(value='child'),
-            ]
+                TriccOperation(operator=TriccOperator.AGE_MONTH, reference=[]),
+                [TriccStatic(value=0), TriccStatic(value="newborn")],
+                [TriccStatic(value=1), TriccStatic(value="newborn")],
+                TriccStatic(value="child"),
+            ],
         )
         self.assertEqual(str(case_operation), str(case_expected))
 
     def test_ifs(self):
         case_cql = """
-        case 
+        case
         when AgeInMonths() <= 2 then true
         when AgeInYears() > 5 then true
         else false end
@@ -121,57 +85,32 @@ class TestCql(unittest.TestCase):
                     TriccOperation(
                         operator=TriccOperator.LESS_OR_EQUAL,
                         reference=[
-                            TriccOperation(
-                                operator=TriccOperator.AGE_MONTH,
-                                reference=[]
-                            ),
-                            TriccStatic(
-                                value=2
-                            )
-                        ]
+                            TriccOperation(operator=TriccOperator.AGE_MONTH, reference=[]),
+                            TriccStatic(value=2),
+                        ],
                     ),
-                    TriccStatic(
-                        value=True
-                    )
+                    TriccStatic(value=True),
                 ],
                 [
                     TriccOperation(
                         operator=TriccOperator.MORE,
-                        reference=[
-                            TriccOperation(
-                                operator=TriccOperator.AGE_YEAR,
-                                reference=[]
-                            ),
-                            TriccStatic(
-                                value=5
-                            )
-                        ]
+                        reference=[TriccOperation(operator=TriccOperator.AGE_YEAR, reference=[]), TriccStatic(value=5)],
                     ),
-                    TriccStatic(
-                        value=True
-                    )
+                    TriccStatic(value=True),
                 ],
                 TriccStatic(value=False),
-            ]
+            ],
         )
         self.assertEqual(str(case_operation), str(case_expected))
 
-
     def test_minus(self):
-        minus_cql =""" "WFL" >= -3"""
+        minus_cql = """ "WFL" >= -3"""
         # minus_cql = """
         # ("age_in_months" < 6 and "WFL" >= -3 and "WFL" < -2) is true
         # """
         minus_operation = transform_cql_to_operation(minus_cql)
         minus_expected = TriccOperation(
-            TriccOperator.MORE_OR_EQUAL,
-            [
-                TriccReference("WFL"),
-                TriccOperation(
-                    TriccOperator.MINUS,
-                    [TriccStatic(3)]
-                )
-            ]
+            TriccOperator.MORE_OR_EQUAL, [TriccReference("WFL"), TriccOperation(TriccOperator.MINUS, [TriccStatic(3)])]
         )
         self.assertEqual(str(minus_operation), str(minus_expected))
 
@@ -185,13 +124,13 @@ class TestCql(unittest.TestCase):
                     operator=TriccOperator.SELECTED,
                     reference=[
                         TriccReference("identifier"),
-                        TriccStatic(value='code'),
-                    ]
+                        TriccStatic(value="code"),
+                    ],
                 )
-            ]
+            ],
         )
         self.assertEqual(str(dg_operation), str(dg_expected))
-    
 
-if __name__ == '__main__':
-    unittest.main()
+
+if __name__ == "__main__":
+    unittest.main()

tests/to_ocl.py

@@ -1,51 +1,49 @@
-import os
 import json
 from pathlib import Path
 from tricc_oo.converters.codesystem_to_ocl import transform_fhir_to_ocl
 
+
 def find_and_process_codesystems(directory_path):
     # Convert string path to Path object if not already
     dir_path = Path(directory_path)
-    
+
     # Find all JSON files in the directory
     for json_file in dir_path.glob("*.json"):
         try:
             # Read the JSON file
-            with open(json_file, 'r', encoding='utf-8') as f:
+            with open(json_file, "r", encoding="utf-8") as f:
                 data = json.load(f)
-                
+
                 # Check if resource_type is CodeSystem
                 if data.get("resourceType") == "CodeSystem":
                     # Get the filename without extension for output naming
                     file_key = json_file.stem
-                    
+
                     # Write the original CodeSystem JSON
                     output_cs_path = dir_path / f"{file_key}_codesystem.json"
-                    with open(output_cs_path, "w", encoding='utf-8') as file:
+                    with open(output_cs_path, "w", encoding="utf-8") as file:
                         file.write(json.dumps(data, indent=4))
-                    
+
                     # Transform to OCL payload
                     ocl_payload = transform_fhir_to_ocl(
-                        data,
-                        source_name="ALM",
-                        source_owner="pdelcroix",
-                        source_owner_type="User"
+                        data, source_name="ALM", source_owner="pdelcroix", source_owner_type="User"
                     )
-                    
+
                     # Save the transformed OCL payload
                     output_ocl_path = dir_path / f"{file_key}_ocl_bulk_upload.json"
-                    with open(output_ocl_path, "w", encoding='utf-8') as f:
+                    with open(output_ocl_path, "w", encoding="utf-8") as f:
                         for item in ocl_payload:
                             json_line = json.dumps(item.dict(exclude_none=True))
-                            f.write(json_line + '\n')
-                    
+                            f.write(json_line + "\n")
+
                     print(f"OCL bulk upload payload generated successfully for {file_key}!")
-                    
+
         except json.JSONDecodeError:
             print(f"Error: Invalid JSON in file {json_file}")
         except Exception as e:
             print(f"Error processing {json_file}: {str(e)}")
 
+
 # Example usage
 media_path = "path/to/your/directory"  # Replace with your directory path
-find_and_process_codesystems(media_path)
+find_and_process_codesystems(media_path)