pydpm_xl 0.2.2__py3-none-any.whl → 0.2.3__py3-none-any.whl

py_dpm/api/{dpm → dpm_xl}/operation_scopes.py

@@ -1244,7 +1244,7 @@ def calculate_scopes_from_expression(
         OperationScopeResult: Result containing existing and new scopes
 
     Example:
-        >>> from py_dpm.api.dpm.operation_scopes import calculate_scopes_from_expression
+        >>> from py_dpm.api.dpm_xl.operation_scopes import calculate_scopes_from_expression
         >>> result = calculate_scopes_from_expression(
         ...     "{tC_01.00, r0100, c0010}",
         ...     release_id=4,
@@ -1275,7 +1275,7 @@ def get_existing_scopes(
         List[OperationScope]: List of existing scopes
 
     Example:
-        >>> from py_dpm.api.dpm.operation_scopes import get_existing_scopes
+        >>> from py_dpm.api.dpm_xl.operation_scopes import get_existing_scopes
         >>> scopes = get_existing_scopes(operation_version_id=1, database_path="./database.db")
     """
     api = OperationScopesAPI(database_path=database_path, connection_url=connection_url)

py_dpm/cli/main.py

@@ -8,7 +8,7 @@ import pandas as pd
 
 from py_dpm.api import SemanticAPI, SyntaxAPI
 from py_dpm.api.dpm_xl.semantic import SemanticValidationResult
-from py_dpm.api.dpm.operation_scopes import OperationScopesAPI
+from py_dpm.api.dpm_xl.operation_scopes import OperationScopesAPI
 from py_dpm.dpm.migration import run_migration
 from py_dpm.dpm_xl.utils.tokens import (
     CODE,

py_dpm/dpm/models.py

@@ -1293,7 +1293,11 @@ class Organisation(Base):
     name = Column("Name", String(200), unique=True)
     acronym = Column("Acronym", String(20))
     idprefix = Column("IDPrefix", Integer, unique=True)
-    rowguid = Column("RowGUID", String(36), ForeignKey("Concept.ConceptGUID"))
+    rowguid = Column(
+        "RowGUID",
+        String(36),
+        ForeignKey("Concept.ConceptGUID", use_alter=True, name="fk_org_concept"),
+    )
 
     # Relationships
     concept = relationship("Concept", foreign_keys=[rowguid])

py_dpm/instance/instance.py

@@ -0,0 +1,265 @@
+from pathlib import Path
+import tempfile
+import zipfile
+import json
+from datetime import datetime
+
+from py_dpm.api import ExplorerQueryAPI
+
+
+class Fact:
+    def __init__(
+        self,
+        table_code: str,
+        column_code: str = None,
+        row_code: str = None,
+        sheet_code: str = None,
+        open_values: dict = None,
+        value: int = None,
+        date: str = None,
+    ):
+        self.table_code = table_code
+        self.column_code = column_code
+        self.row_code = row_code
+        self.sheet_code = sheet_code
+        self.open_values = open_values
+        self.value = value
+        self.variable_id = None
+
+        self.resolve_datapoint_id(date)
+
+    def __str__(self):
+        return f"Operand(table={self.table_code}, column={self.column_code}, row={self.row_code}, sheet={self.sheet_code}, open_values={self.open_values}, value={self.value})"
+
+    def resolve_datapoint_id(self, date: str) -> str:
+        variables = ExplorerQueryAPI().get_variable_from_cell_address(
+            table_code=self.table_code,
+            column_code=self.column_code,
+            sheet_code=self.sheet_code,
+            row_code=self.row_code,
+            date=date,
+        )
+
+        if len(variables) == 0:
+            raise ValueError(f"No mapping found for {self.operand_code}")
+        if len(variables) > 1:
+            raise ValueError(f"Multiple mappings found for {self.operand_code}")
+
+        self.variable_id = variables[0]["variable_id"]
+
+    @property
+    def operand_code(self):
+        code = f"{self.table_code}"
+
+        if self.row_code:
+            code += f", r{self.row_code}"
+        if self.column_code:
+            code += f", c{self.column_code}"
+        if self.sheet_code:
+            code += f", s{self.sheet_code}"
+
+        return code
+
+    @property
+    def variable_csv_row(self):
+        return f"dp{self.variable_id}"
+
+    @classmethod
+    def from_dict(cls, operand_data: dict):
+        operand = cls(
+            table_code=operand_data["table_code"],
+            column_code=(
+                operand_data["column_code"] if "column_code" in operand_data else None
+            ),
+            row_code=operand_data["row_code"] if "row_code" in operand_data else None,
+            sheet_code=(
+                operand_data["sheet_code"] if "sheet_code" in operand_data else None
+            ),
+            open_values=(
+                operand_data["open_values"] if "open_values" in operand_data else None
+            ),
+            value=operand_data["value"] if "value" in operand_data else None,
+            date=operand_data["date"] if "date" in operand_data else None,
+        )
+
+        return operand
+
+
+class Instance:
+    PARAMETERS_DEFAULT = {
+        "entityID": "rs:DUMMYLEI123456789012.CON",
+        "baseCurrency": "iso4217:EUR",
+        "decimalsInteger": 0,
+        "decimalsMonetary": 2,
+        "decimalsPercentage": 8,
+        "decimalsDecimal": 2,
+    }
+
+    META_JSON = {
+        "documentInfo": {
+            "documentType": "http://xbrl.org/PWD/2020-12-09/report-package"
+        }
+    }
+
+    REPORTS_JSON = {
+        "documentInfo": {
+            "documentType": "https://xbrl.org/CR/2021-02-03/xbrl-csv",
+            "extends": [],
+        }
+    }
+
+    def __init__(self, module_url: str, operands: dict[Fact], parameters: dict = None):
+
+        self.module_url = module_url
+        self.operands = operands
+        self.parameters = parameters
+
+    @staticmethod
+    def _validate_dict_structure(instance_json: dict):
+        required_keys = {"module_code", "parameters", "operands"}
+        if required_keys != set(instance_json.keys()):
+            missing = required_keys - set(instance_json.keys())
+            raise ValueError(f"Missing required keys: {missing}")
+
+        if not isinstance(instance_json["module_code"], str):
+            raise TypeError("module_code must be a string")
+
+        if not isinstance(instance_json["parameters"], dict):
+            raise TypeError("parameters must be a dictionary")
+
+        if "refPeriod" not in instance_json["parameters"]:
+            raise ValueError("parameters must contain 'refPeriod'")
+
+        if not isinstance(instance_json["operands"], list):
+            raise TypeError("operands must be a list")
+
+    @classmethod
+    def from_json_file(cls, json_file: Path):
+        with open(json_file, "r") as f:
+            json_data = json.load(f)
+        instance = cls.from_dict(json_data)
+        return instance
+
+    @classmethod
+    def from_dict(cls, instance_json: dict):
+        cls._validate_dict_structure(instance_json)
+
+        url = ExplorerQueryAPI().get_module_url(
+            module_code=instance_json["module_code"],
+            date=instance_json["parameters"]["refPeriod"],
+        )
+
+        parameters = cls.PARAMETERS_DEFAULT.copy()
+        parameters.update(instance_json["parameters"])
+
+        operands = {}
+        for operand in instance_json["operands"]:
+            operand["date"] = parameters["refPeriod"]
+            operand = Fact.from_dict(operand)
+            if operand.table_code not in operands:
+                operands[operand.table_code] = []
+            operands[operand.table_code].append(operand)
+
+        instance = cls(
+            module_url=url,
+            operands=operands,
+            parameters=parameters,
+        )
+
+        return instance
+
+    @property
+    def folder_name(self):
+        module_code = self.module_url.split("/")[-1].split(".")[0]
+        entity_id = self.parameters["entityID"].split(":")[1]
+        ref_period = self.parameters["refPeriod"]
+        return f"{entity_id}_{ref_period}_{module_code}"
+
+    def build_package(self, output_folder: Path | str, file_prefix: str = None):
+        """Build the XBRL‑CSV package and write to *output_zip*."""
+
+        if isinstance(output_folder, str):
+            output_folder = Path(output_folder)
+
+        with tempfile.TemporaryDirectory() as tmpdir:
+            if file_prefix:
+                file_name_root = f"{file_prefix}_{self.folder_name}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+            else:
+                file_name_root = (
+                    f"{self.folder_name}-{datetime.now().strftime('%Y%m%d%H%M%S')}"
+                )
+
+            tmp = Path(tmpdir)
+            root = tmp / file_name_root
+            root.mkdir()
+
+            # META‑INF/reportPackage.json
+            meta_dir = root / "META-INF"
+            meta_dir.mkdir(parents=True, exist_ok=True)
+            (meta_dir / "reportPackage.json").write_text(
+                json.dumps(self.META_JSON, indent=2)
+            )
+
+            # reports/
+            reports_dir = root / "reports"
+            reports_dir.mkdir()
+
+            # parameters.csv
+            param_lines = ["name,value"] + [
+                f"{k},{v}" for k, v in self.parameters.items()
+            ]
+            (reports_dir / "parameters.csv").write_text("\n".join(param_lines))
+
+            # FilingIndicators.csv
+            filing_indicators_lines = ["templateID,reported"]
+            for table in self.operands.keys():
+                if "." in table:
+                    table = table.split(".")
+                    table = table[0] + "." + table[1]
+                if f"{table},true" not in filing_indicators_lines:
+                    filing_indicators_lines.append(f"{table},true")
+
+            (reports_dir / "FilingIndicators.csv").write_text(
+                "\n".join(filing_indicators_lines)
+            )
+
+            # report.json
+            reports_json_dict = self.REPORTS_JSON
+            reports_json_dict["documentInfo"]["extends"] = [self.module_url]
+            (reports_dir / "report.json").write_text(
+                json.dumps(reports_json_dict, indent=2)
+            )
+
+            # tables.csv
+            for table, operands in self.operands.items():
+                header = ["datapoint", "factValue"]
+                first_operand = operands[0]
+                if first_operand.open_values:
+                    for key_dimension in first_operand.open_values.keys():
+                        header.append(key_dimension)
+                header = ",".join(header)
+                lines = [header]
+                for operand in operands:
+                    line = [operand.variable_csv_row, str(operand.value)]
+                    if operand.open_values:
+                        for key_dimension in operand.open_values.keys():
+                            line.append(str(operand.open_values[key_dimension]))
+                    line = ",".join(line)
+                    lines.append(line)
+                (reports_dir / f"{table}.csv").write_text("\n".join(lines))
+
+            # Zip everything
+
+            with zipfile.ZipFile(
+                output_folder / (file_name_root + ".zip"),
+                "w",
+                compression=zipfile.ZIP_DEFLATED,
+            ) as zf:
+                for file_path in tmp.rglob("*"):
+                    zf.write(file_path, file_path.relative_to(tmp))
+
+            output_path = output_folder / (file_name_root + ".zip")
+
+            print(f"Instance package written to: {output_path}")
+
+            return output_path

{pydpm_xl-0.2.2.dist-info → pydpm_xl-0.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.2.2
+Version: 0.2.3
 Summary: Python library for DPM-XL data processing and analysis
 Author-email: "MeaningfulData S.L." <info@meaningfuldata.eu>
 License: GPL-3.0-or-later

{pydpm_xl-0.2.2.dist-info → pydpm_xl-0.2.3.dist-info}/RECORD

@@ -1,24 +1,23 @@
-py_dpm/__init__.py,sha256=f5HSKe3TKudiLPviLZ9Tc47ePZMOG3hNRwQS7-UqbB8,1858
-py_dpm/api/__init__.py,sha256=g0w2FOtETU1ZMuhGnbdgBmmTZwmWoBtBEDmkLR1t8sc,1824
-py_dpm/api/explorer.py,sha256=1dBc2ZidcAR5DfPEBRiyVk54Xv9u_G9mU66u7PA9Z-E,86
-py_dpm/api/semantic.py,sha256=QT0znXXa4ihqk4GmlmJQrdceCRy1o_3J17koW6rT5PE,1304
-py_dpm/api/dpm/__init__.py,sha256=FfyTxv29mxIrdw_y7QOdwwf8p4F9YsdiJ_H7HfL2gJo,528
+py_dpm/__init__.py,sha256=AsLh4kv-iu9KOJD1YfgPwAP2PD-WGt2ZHfgNtpU25tw,1858
+py_dpm/api/__init__.py,sha256=n79vAD7qatlYaXaI2N5IAD9m_8Fgb00EOdapVXZYTpI,1081
+py_dpm/api/dpm/__init__.py,sha256=HQflgiRbs1eDi3KTadNhxS1NoaG6PGQDVMvFnuIEfXo,506
 py_dpm/api/dpm/data_dictionary.py,sha256=g0h6Yfschz7rboYly9LTbP-2SS5UxltU3AXu0v0tqrU,29457
 py_dpm/api/dpm/explorer.py,sha256=gW2RC59XwGl9YbEA-M4syHAs6MvqPWVw4wR_XdVFJ4Y,7888
 py_dpm/api/dpm/hierarchical_queries.py,sha256=X4AbpsWy3iItOTVIdVbtaTmRgOHPf0Y64Ig-_377uns,4054
+py_dpm/api/dpm/instance.py,sha256=OSq-sEZ9bn3zNZFQV6vI3Ed0c20s5VzhDwYEhemZ4Dc,3804
 py_dpm/api/dpm/migration.py,sha256=9FT7zzz4QdUIRR6MD01gMODBtfq9HH_RF4hRgZqMcZc,2404
-py_dpm/api/dpm/operation_scopes.py,sha256=Vw9cdPiFM7uCsQyMY1AgT5XhHbxFcVeMwIcIXANuty4,48486
-py_dpm/api/dpm_xl/__init__.py,sha256=rjiIf9XDi2IGf0G_LiOWp29e5ANyoREfzl5Z5phJU_8,603
-py_dpm/api/dpm_xl/ast_generator.py,sha256=-wOgUEM1DMpyVwflkplLr7BOZFfjaDeXi-R_PLhsAxo,16160
-py_dpm/api/dpm_xl/complete_ast.py,sha256=XmXvE1zWLxL732FvyUpK4WffKwZSrw5yrzJI-QGOpFI,24341
+py_dpm/api/dpm_xl/__init__.py,sha256=aRjaMAf_i2a33UAGTg-TF1BfO6miOOrbCydTUqAVvRU,910
+py_dpm/api/dpm_xl/ast_generator.py,sha256=maVFlxBnBBZ6UYgVxbvewPFTbrTUqXfdKpmjB0ue0qc,42979
+py_dpm/api/dpm_xl/complete_ast.py,sha256=sOaN9uSQo-Nns8twElVQHBg7MnaDSo_8EuZPSIqGdU0,7125
+py_dpm/api/dpm_xl/operation_scopes.py,sha256=7AyOFAn9h012JPF9H5EtZ3sPzv6DOxkoinpj5ArzVOc,48492
 py_dpm/api/dpm_xl/semantic.py,sha256=Buo_t-sEv65r6RmYDy1xkCWGlU2pB2WQsDM-X-FX4cc,13629
 py_dpm/api/dpm_xl/syntax.py,sha256=Ke_kKd9ModoJ6siL3GPT9j9QClmopryCRcdDAT3M5-E,5954
 py_dpm/cli/__init__.py,sha256=UrfGHoQ0sZLjWfA0hoOoI4iTrn-bjr2f9Q8wDWd5nMo,133
-py_dpm/cli/main.py,sha256=Cu04d3hpv0UdcROdkvpNipNfiAkde59YCbPu0gKKCYA,22444
+py_dpm/cli/main.py,sha256=v8ZgIjg4Zqf6UWNv2bydYlZV6KfDLnPACyqplNIJyNE,22447
 py_dpm/cli/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 py_dpm/dpm/__init__.py,sha256=moagUo5Gxf24-Tl9FL_3n2wmVoD_oXtpC-YIGktH_rc,212
 py_dpm/dpm/migration.py,sha256=ivO_ObvKzVomTns6qfo-o5FuciWxkXbMd_gJ4_tu7Xc,14110
-py_dpm/dpm/models.py,sha256=mk0zLUpPHZn5DN2iIFsZ4dJUjgT5b4rroD_Q8W-o_ns,124751
+py_dpm/dpm/models.py,sha256=d70oZ_3wXsKBRGM2TJRlsuDrHWSVkzetLAZeMIoImwc,124821
 py_dpm/dpm/utils.py,sha256=JNdAeOXjzQtye94jLPRHHGUMcvkGtTsjA5HFl92rWig,12783
 py_dpm/dpm/queries/base.py,sha256=EddMeJMwtp63DyyIFO7_XxGvdlCtJQWWpeOVImlKp4I,3648
 py_dpm/dpm/queries/basic_objects.py,sha256=JOXC235lMDfVENrFAhZAl7_nqePJ4RrwJhFF0WDyk0M,955
@@ -72,17 +71,14 @@ py_dpm/dpm_xl/utils/operator_mapping.py,sha256=BFgbVbSCSuutFNHJ4gtgm5VuG38pcl8Km
 py_dpm/dpm_xl/utils/scopes_calculator.py,sha256=nCx2mz_qtw61BESp38ORQYlF2uRT8SyUKawSX9OQljM,17832
 py_dpm/dpm_xl/utils/serialization.py,sha256=LPcmudFfzHeEjIIr57kr5BvGPZbxshOAAeUYOrLl7XM,32482
 py_dpm/dpm_xl/utils/tokens.py,sha256=VRIrPDi5ttwgH-on5Qt4-l4ho4bLA755-nfTalponcA,3496
-py_dpm/dpm_xl/validation/__init__.py,sha256=pzSTkLzUgK16XsV_maXn__erzs0blDBDRApuRWJwwMs,250
-py_dpm/dpm_xl/validation/generation_utils.py,sha256=2UvYorpLor-8PiEUTWFFVr-xEzKjxQzZrLXz3lvedPk,22655
-py_dpm/dpm_xl/validation/property_constraints.py,sha256=d95p2LxIGGmtGJBz0X14Z4LsS404fvO61VHeAJkN8V8,8272
-py_dpm/dpm_xl/validation/utils.py,sha256=2dV23OJfhDbLYTKkwTUVsXaQeO8zJUs9LbjDXcO5OO4,4196
-py_dpm/dpm_xl/validation/variants.py,sha256=LM_2U_sCf8rnlUyt6k4WQwSKj5eTJLt4Ba8q9VVi4kg,13824
 py_dpm/exceptions/__init__.py,sha256=yDERfUxYW7NUUEiTQChGpuJx6abr7IDe2XUpwVFPtvM,416
 py_dpm/exceptions/exceptions.py,sha256=6S3p-_i5O1oStvSMixt_JQG0xwTeSfBcdzrwL8yBy6Q,2413
 py_dpm/exceptions/messages.py,sha256=UwY6QIK8c-POcDCc9HYbZFGArCIYAanUGNh2LNKPx3U,7534
-pydpm_xl-0.2.2.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pydpm_xl-0.2.2.dist-info/METADATA,sha256=AG1po-jCkskQP5DFl49SMCF0y4QJHivL287Y3KLE3T0,7974
-pydpm_xl-0.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pydpm_xl-0.2.2.dist-info/entry_points.txt,sha256=6DDmBfw-AjtgvMHgq_I730i_LAAs_7-N3C95HD_bRr4,47
-pydpm_xl-0.2.2.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
-pydpm_xl-0.2.2.dist-info/RECORD,,
+py_dpm/instance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+py_dpm/instance/instance.py,sha256=ROUXOcd2lBV5fKdGHBAli6lnmL-YP-n02bUhtwARZhE,9119
+pydpm_xl-0.2.3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pydpm_xl-0.2.3.dist-info/METADATA,sha256=cYguvXm7dSViN9mNqxZf9kKo9vlg-eP2lpctZu6oJDI,7974
+pydpm_xl-0.2.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pydpm_xl-0.2.3.dist-info/entry_points.txt,sha256=6DDmBfw-AjtgvMHgq_I730i_LAAs_7-N3C95HD_bRr4,47
+pydpm_xl-0.2.3.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
+pydpm_xl-0.2.3.dist-info/RECORD,,

py_dpm/api/explorer.py

@@ -1,4 +0,0 @@
-from py_dpm.api.dpm.explorer import ExplorerQueryAPI
-
-__all__ = ["ExplorerQueryAPI"]
-

py_dpm/api/semantic.py

@@ -1,56 +0,0 @@
-from typing import Optional
-
-from py_dpm.api.dpm_xl.semantic import (
-    SemanticAPI as _SemanticAPI,
-    SemanticValidationResult,
-    validate_expression as _validate_expression,
-    is_valid_semantics as _is_valid_semantics,
-)
-
-
-SemanticAPI = _SemanticAPI
-
-
-def validate_expression(
-    expression: str,
-    database_path: Optional[str] = None,
-    connection_url: Optional[str] = None,
-    release_id: Optional[int] = None,
-) -> SemanticValidationResult:
-    """
-    Backwards-compatible wrapper for semantic validation.
-
-    This delegates to the DPM-XL SemanticAPI implementation.
-    """
-    return _validate_expression(
-        expression,
-        database_path=database_path,
-        connection_url=connection_url,
-        release_id=release_id,
-    )
-
-
-def is_valid_semantics(
-    expression: str,
-    database_path: Optional[str] = None,
-    connection_url: Optional[str] = None,
-    release_id: Optional[int] = None,
-) -> bool:
-    """
-    Backwards-compatible wrapper to check semantic validity.
-    """
-    return _is_valid_semantics(
-        expression,
-        database_path=database_path,
-        connection_url=connection_url,
-        release_id=release_id,
-    )
-
-
-__all__ = [
-    "SemanticAPI",
-    "SemanticValidationResult",
-    "validate_expression",
-    "is_valid_semantics",
-]
-

py_dpm/dpm_xl/validation/__init__.py

@@ -1,12 +0,0 @@
-"""
-DPM-XL Validation
-
-Syntax and semantic validation for DPM-XL expressions.
-"""
-
-from py_dpm.dpm_xl.validation.variants import *
-from py_dpm.dpm_xl.validation.property_constraints import *
-
-__all__ = [
-    # Re-export will be handled by import *
-]