pydpm_xl 0.2.5rc3__py3-none-any.whl → 0.2.7__py3-none-any.whl

py_dpm/dpm/queries/explorer_queries.py

@@ -239,6 +239,7 @@ class ExplorerQuery:
         row_code: Optional[str] = None,
         column_code: Optional[str] = None,
         sheet_code: Optional[str] = None,
+        module_code: Optional[str] = None,
         release_id: Optional[int] = None,
         release_code: Optional[str] = None,
         date: Optional[str] = None,
@@ -326,6 +327,8 @@ class ExplorerQuery:
             q = q.filter(hv_col.code == column_code)
         if sheet_code is not None:
             q = q.filter(hv_sheet.code == sheet_code)
+        if module_code is not None:
+            q = q.filter(ModuleVersion.code == module_code)
 
         # Apply standard release/date filtering on ModuleVersion.
         # For this method, if no release argument is provided, we default
@@ -350,3 +353,119 @@ class ExplorerQuery:
 
         results = q.all()
         return [dict(row._mapping) for row in results]
+
+    @staticmethod
+    def get_variable_by_code(
+        session: Session,
+        variable_code: str,
+        release_id: Optional[int] = None,
+        release_code: Optional[str] = None,
+    ) -> Optional[Dict[str, Any]]:
+        """
+        Get variable_id and variable_vid for a given variable code.
+
+        This is useful for resolving precondition variable references like {v_C_01.00}
+        where the variable code is the table code (e.g., "C_01.00").
+
+        Args:
+            session: SQLAlchemy session
+            variable_code: The variable code to look up (e.g., "C_01.00")
+            release_id: Optional release ID to filter by
+            release_code: Optional release code to filter by
+
+        Returns:
+            Dict with variable_id and variable_vid if found, None otherwise.
+            If multiple versions exist, returns the one matching the release filter
+            or the latest active version if no filter is provided.
+        """
+        if release_id is not None and release_code is not None:
+            raise ValueError(
+                "Specify a maximum of one of release_id or release_code."
+            )
+
+        q = (
+            session.query(
+                VariableVersion.variableid.label("variable_id"),
+                VariableVersion.variablevid.label("variable_vid"),
+                VariableVersion.code.label("variable_code"),
+                VariableVersion.name.label("variable_name"),
+            )
+            .select_from(VariableVersion)
+            .filter(VariableVersion.code == variable_code)
+        )
+
+        # Apply release filtering
+        if release_id or release_code:
+            q = filter_by_release(
+                q,
+                start_col=VariableVersion.startreleaseid,
+                end_col=VariableVersion.endreleaseid,
+                release_id=release_id,
+                release_code=release_code,
+            )
+        else:
+            # Default to active-only (endreleaseid is NULL)
+            q = filter_active_only(q, end_col=VariableVersion.endreleaseid)
+
+        result = q.first()
+        if result:
+            return dict(result._mapping)
+        return None
+
+    @staticmethod
+    def get_variables_by_codes(
+        session: Session,
+        variable_codes: List[str],
+        release_id: Optional[int] = None,
+        release_code: Optional[str] = None,
+    ) -> Dict[str, Dict[str, Any]]:
+        """
+        Batch lookup of variable_id and variable_vid for multiple variable codes.
+
+        This is more efficient than calling get_variable_by_code multiple times
+        when resolving multiple precondition variables.
+
+        Args:
+            session: SQLAlchemy session
+            variable_codes: List of variable codes to look up
+            release_id: Optional release ID to filter by
+            release_code: Optional release code to filter by
+
+        Returns:
+            Dict mapping variable_code to {variable_id, variable_vid, ...}
+            Only includes codes that were found in the database.
+        """
+        if release_id is not None and release_code is not None:
+            raise ValueError(
+                "Specify a maximum of one of release_id or release_code."
+            )
+
+        if not variable_codes:
+            return {}
+
+        q = (
+            session.query(
+                VariableVersion.variableid.label("variable_id"),
+                VariableVersion.variablevid.label("variable_vid"),
+                VariableVersion.code.label("variable_code"),
+                VariableVersion.name.label("variable_name"),
+            )
+            .select_from(VariableVersion)
+            .filter(VariableVersion.code.in_(variable_codes))
+        )
+
+        # Apply release filtering
+        if release_id or release_code:
+            q = filter_by_release(
+                q,
+                start_col=VariableVersion.startreleaseid,
+                end_col=VariableVersion.endreleaseid,
+                release_id=release_id,
+                release_code=release_code,
+            )
+        else:
+            # Default to active-only (endreleaseid is NULL)
+            q = filter_active_only(q, end_col=VariableVersion.endreleaseid)
+
+        results = q.all()
+        return {row.variable_code: dict(row._mapping) for row in results}

py_dpm/dpm/utils.py

@@ -84,7 +84,7 @@ sessionMakerObject = None
 _current_engine_url = None
 
 
-def create_engine_from_url(connection_url):
+def create_engine_from_url(connection_url, pool_config=None):
     """
     Create SQLAlchemy engine from a connection URL with appropriate pooling parameters.
 
@@ -96,6 +96,12 @@ def create_engine_from_url(connection_url):
 
     Args:
         connection_url (str): SQLAlchemy connection URL (e.g., 'sqlite:///path.db', 'postgresql://user:pass@host/db')
+        pool_config (dict, optional): Custom pool configuration. Supported keys:
+            - pool_size (int): Maximum number of connections to maintain in the pool (default: 20)
+            - max_overflow (int): Maximum overflow connections beyond pool_size (default: 10)
+            - pool_timeout (int): Seconds to wait before giving up on getting a connection (default: 30)
+            - pool_recycle (int): Seconds before recycling connections (default: 180)
+            - pool_pre_ping (bool): Health check connections before using from pool (default: True)
 
     Returns:
         sqlalchemy.engine.Engine: Configured database engine
@@ -103,6 +109,8 @@ def create_engine_from_url(connection_url):
     Examples:
         >>> engine = create_engine_from_url('sqlite:///database.db')
         >>> engine = create_engine_from_url('postgresql://user:pass@localhost/mydb')
+        >>> engine = create_engine_from_url('postgresql://user:pass@localhost/mydb',
+        ...                                   pool_config={'pool_size': 5, 'max_overflow': 10})
     """
     global engine, sessionMakerObject, _current_engine_url
 
@@ -123,12 +131,22 @@ def create_engine_from_url(connection_url):
         engine = create_engine(connection_url, pool_pre_ping=True)
     else:
         # Server-based databases (PostgreSQL, MySQL, etc.) with connection pooling
+        # Default pool configuration
+        default_pool_config = {
+            'pool_size': 20,
+            'max_overflow': 10,
+            'pool_timeout': 30,
+            'pool_recycle': 180,
+            'pool_pre_ping': True,
+        }
+
+        # Merge custom pool_config with defaults
+        if pool_config:
+            default_pool_config.update(pool_config)
+
         engine = create_engine(
             connection_url,
-            pool_size=20,
-            max_overflow=10,
-            pool_recycle=180,
-            pool_pre_ping=True,
+            **default_pool_config
         )
 
     # Initialize global sessionMakerObject
@@ -170,7 +188,7 @@ def create_engine_object(url):
     return engine
 
 
-def get_engine(owner=None, database_path=None, connection_url=None):
+def get_engine(owner=None, database_path=None, connection_url=None, pool_config=None):
     """
     Get database engine based on configuration or explicit parameters.
 
@@ -184,13 +202,14 @@ def get_engine(owner=None, database_path=None, connection_url=None):
         owner: Owner for SQL Server databases (EBA/EIOPA) - legacy support
         database_path: Explicit SQLite database path
         connection_url: Explicit SQLAlchemy connection URL (e.g., for PostgreSQL)
+        pool_config: Connection pool configuration dict (for PostgreSQL/MySQL)
 
     Returns:
         SQLAlchemy Engine
     """
     # Priority 1: If explicit connection URL is provided, use it directly
     if connection_url:
-        return create_engine_from_url(connection_url)
+        return create_engine_from_url(connection_url, pool_config=pool_config)
 
     # Priority 2: If explicit database_path is provided, use SQLite with that path
     if database_path:

py_dpm/dpm_xl/utils/scopes_calculator.py

@@ -71,9 +71,19 @@ class OperationScopeService:
         if len(modules_info_dataframe) == 1:
             module_vid = modules_vids[0]
             from_date = modules_info_dataframe["FromReferenceDate"].values[0]
+            to_date = modules_info_dataframe["ToReferenceDate"].values[0]
+            module_code = modules_info_dataframe["ModuleCode"].values[0]
+            version_number = modules_info_dataframe["VersionNumber"].values[0]
             operation_scope = self.create_operation_scope(from_date)
             self.create_operation_scope_composition(
-                operation_scope=operation_scope, module_vid=module_vid
+                operation_scope=operation_scope,
+                module_vid=module_vid,
+                module_info={
+                    "code": module_code,
+                    "version_number": version_number,
+                    "from_reference_date": from_date,
+                    "to_reference_date": to_date,
+                },
             )
         else:
             intra_modules = []
@@ -83,11 +93,10 @@ class OperationScopeService:
             if table_codes:
                 unique_operands_number = len(table_codes) + len(precondition_items)
 
-                # Categorize modules by lifecycle: starting vs ending in this release
-                starting_modules = (
-                    {}
-                )  # Modules that START in this release (replacements)
-                ending_modules = {}  # Modules that END in this release (being replaced)
+                # First pass: categorize modules by table code and lifecycle
+                # We track lifecycle to handle version transitions within the SAME module
+                starting_by_code = {}  # table_code -> [module_vids that START in this release]
+                ending_by_code = {}  # table_code -> [module_vids that END or are active]
 
                 for module_vid, group_df in modules_info_dataframe.groupby(MODULE_VID):
                     table_codes_in_module = (
@@ -105,31 +114,55 @@ class OperationScopeService:
                     end_release = group_df["EndReleaseID"].values[0]
 
                     # Determine if this is a "new" module starting in this release
-                    # or an "old" module ending in this release
                     is_starting = start_release == release_id
-                    is_ending = end_release == release_id or end_release == float(
-                        release_id
-                    )
 
                     if len(table_codes_in_module) == unique_operands_number:
                         # Intra-module: include ALL modules active in the release
-                        # (don't filter by lifecycle - that's only for cross-module)
                         intra_modules.append(module_vid)
                     else:
-                        # For cross-module, group by table code AND lifecycle stage
-                        target_dict = (
-                            starting_modules if is_starting else ending_modules
-                        )
+                        # Track modules by table code and lifecycle
                         for table_code in table_codes_in_module:
-                            if table_code not in target_dict:
-                                target_dict[table_code] = []
-                            target_dict[table_code].append(module_vid)
-
-                # Process cross-module scopes separately for each generation
-                if starting_modules:
-                    cross_modules["_starting"] = starting_modules
-                if ending_modules:
-                    cross_modules["_ending"] = ending_modules
+                            if is_starting:
+                                if table_code not in starting_by_code:
+                                    starting_by_code[table_code] = []
+                                starting_by_code[table_code].append(module_vid)
+                            else:
+                                if table_code not in ending_by_code:
+                                    ending_by_code[table_code] = []
+                                ending_by_code[table_code].append(module_vid)
+
+                # Second pass: determine if lifecycle separation is needed
+                # Only separate if a table code has modules in BOTH starting and ending
+                # (indicating a version transition for that table)
+                needs_lifecycle_separation = any(
+                    code in starting_by_code and code in ending_by_code
+                    for code in set(starting_by_code.keys()) | set(ending_by_code.keys())
+                )
+
+                if needs_lifecycle_separation:
+                    # Separate into starting and ending scopes
+                    starting_modules = {}
+                    ending_modules = {}
+                    for code, vids in starting_by_code.items():
+                        starting_modules[code] = vids
+                    for code, vids in ending_by_code.items():
+                        ending_modules[code] = vids
+                    if starting_modules:
+                        cross_modules["_starting"] = starting_modules
+                    if ending_modules:
+                        cross_modules["_ending"] = ending_modules
+                else:
+                    # No version transitions - combine all modules by table code
+                    all_by_code = {}
+                    for code, vids in starting_by_code.items():
+                        if code not in all_by_code:
+                            all_by_code[code] = []
+                        all_by_code[code].extend(vids)
+                    for code, vids in ending_by_code.items():
+                        if code not in all_by_code:
+                            all_by_code[code] = []
+                        all_by_code[code].extend(vids)
+                    cross_modules = all_by_code
             else:
                 # Original logic for table VIDs
                 unique_operands_number = len(tables_vids) + len(precondition_items)
@@ -268,12 +301,21 @@ class OperationScopeService:
         :param modules_vids: list with module version ids
         """
         for module_vid in modules_vids:
-            from_date = modules_info[modules_info["ModuleVID"] == module_vid][
-                "FromReferenceDate"
-            ].values[0]
+            module_row = modules_info[modules_info["ModuleVID"] == module_vid].iloc[0]
+            from_date = module_row["FromReferenceDate"]
+            to_date = module_row["ToReferenceDate"]
+            module_code = module_row["ModuleCode"]
+            version_number = module_row["VersionNumber"]
             operation_scope = self.create_operation_scope(from_date)
             self.create_operation_scope_composition(
-                operation_scope=operation_scope, module_vid=module_vid
+                operation_scope=operation_scope,
+                module_vid=module_vid,
+                module_info={
+                    "code": module_code,
+                    "version_number": version_number,
+                    "from_reference_date": from_date,
+                    "to_reference_date": to_date,
+                },
             )
 
     def process_cross_module(self, cross_modules, modules_dataframe):
@@ -313,8 +355,18 @@ class OperationScopeService:
             operation_scope = self.create_operation_scope(from_submission_date)
             combination = set(combination)
             for module in combination:
+                module_row = modules_dataframe[
+                    modules_dataframe[MODULE_VID] == module
+                ].iloc[0]
                 self.create_operation_scope_composition(
-                    operation_scope=operation_scope, module_vid=module
+                    operation_scope=operation_scope,
+                    module_vid=module,
+                    module_info={
+                        "code": module_row["ModuleCode"],
+                        "version_number": module_row["VersionNumber"],
+                        "from_reference_date": module_row[FROM_REFERENCE_DATE],
+                        "to_reference_date": module_row[TO_REFERENCE_DATE],
+                    },
                 )
 
     def create_operation_scope(self, submission_date):
@@ -340,17 +392,21 @@ class OperationScopeService:
         self.session.add(operation_scope)
         return operation_scope
 
-    def create_operation_scope_composition(self, operation_scope, module_vid):
+    def create_operation_scope_composition(self, operation_scope, module_vid, module_info=None):
         """
         Method to populate OperationScopeComposition table
         :param operation_scope: Operation scope data
         :param module_vid: Module version id
+        :param module_info: Optional dict with module info (code, from_reference_date, to_reference_date)
         """
         operation_scope_composition = OperationScopeComposition(
             operation_scope=operation_scope,
             modulevid=module_vid,
             rowguid=str(uuid.uuid4()),
         )
+        # Store module info as transient attribute for to_dict() access
+        if module_info:
+            operation_scope_composition._module_info = module_info
         self.session.add(operation_scope_composition)
 
     def get_scopes_with_status(self):

py_dpm/dpm_xl/utils/serialization.py

@@ -361,12 +361,14 @@ class ASTToJSONVisitor(NodeVisitor):
             'op': node.op,
             'operand': self.visit(node.operand),
         }
-        # Add grouping_clause if present and has actual components
+        # Always include grouping_clause (null when not present or empty)
+        grouping_clause = None
         if hasattr(node, 'grouping_clause') and node.grouping_clause is not None:
             gc = self.visit(node.grouping_clause)
-            # Only include grouping_clause if it has components
+            # Only set to actual value if it has components
             if gc and gc.get('components'):
-                result['grouping_clause'] = gc
+                grouping_clause = gc
+        result['grouping_clause'] = grouping_clause
         return result
 
     def visit_GroupingClause(self, node):

py_dpm/instance/instance.py

@@ -169,6 +169,7 @@ class Instance:
                     row_code=None,
                     column_code=None,
                     sheet_code=None,
+                    module_code=instance_json["module_code"],
                     date=ref_period,
                 )
 

{pydpm_xl-0.2.5rc3.dist-info → pydpm_xl-0.2.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.2.5rc3
+Version: 0.2.7
 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.5rc3.dist-info → pydpm_xl-0.2.7.dist-info}/RECORD

@@ -1,27 +1,27 @@
-py_dpm/__init__.py,sha256=zPA7CdwYtnZIaZc8jniwDoBwlzur7Wj1qOl35ZvmcHo,1861
-py_dpm/api/__init__.py,sha256=n79vAD7qatlYaXaI2N5IAD9m_8Fgb00EOdapVXZYTpI,1081
+py_dpm/__init__.py,sha256=a2pLEJ-WUNGj-wIL9gxgvcBpavgpyCKq-DbzJMC2dbA,1858
+py_dpm/api/__init__.py,sha256=6ElO0NKEjuqiHNxK7pxkzLNlaUOrYKnY3N0fUDDobik,1021
 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/data_dictionary.py,sha256=q6w_5bFdc6WPd5Z601PpDaCcnIw39CnI4wdby3GJmFU,29893
+py_dpm/api/dpm/explorer.py,sha256=xgrSdh2D83RivypF26WWo20rbQifYBEH7PXvINoi07Y,10861
 py_dpm/api/dpm/hierarchical_queries.py,sha256=X4AbpsWy3iItOTVIdVbtaTmRgOHPf0Y64Ig-_377uns,4054
 py_dpm/api/dpm/instance.py,sha256=v3DWzdaM5gPCecLjwjZ49FGfqZzUR3dPC0U8zGwdttk,3795
 py_dpm/api/dpm/migration.py,sha256=9FT7zzz4QdUIRR6MD01gMODBtfq9HH_RF4hRgZqMcZc,2404
-py_dpm/api/dpm_xl/__init__.py,sha256=aRjaMAf_i2a33UAGTg-TF1BfO6miOOrbCydTUqAVvRU,910
-py_dpm/api/dpm_xl/ast_generator.py,sha256=GHu_F3YKaMpqvu16ABIvj8BwlmWXehvk0eUJVQkCphE,55204
-py_dpm/api/dpm_xl/complete_ast.py,sha256=VkmcBatrydu97Inwp3pHjz93F38q2JRo-4Lohdu30RY,7684
-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/__init__.py,sha256=cwqeYgmowGH6MK8kQMQkjQaTL9qKEnC8-M5rueqhrPI,850
+py_dpm/api/dpm_xl/ast_generator.py,sha256=7EEUEmXMwck7obL3rnBjHeDnsM0F-LHnpUZNd3rVjHI,94929
+py_dpm/api/dpm_xl/complete_ast.py,sha256=_FSxA0FmNXuW0OLS3c8yzp14yjkmdR0rTebBAs1pg-E,8141
+py_dpm/api/dpm_xl/operation_scopes.py,sha256=v2t3f2-AiF39hspNtpf_PA94T69JqbymFK9a5hpckRs,48831
+py_dpm/api/dpm_xl/semantic.py,sha256=Ddmh2Wj_iXIpQZ4jCjqOI-6ddFCquaO9RTu6W9i1Rts,13968
 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=v8ZgIjg4Zqf6UWNv2bydYlZV6KfDLnPACyqplNIJyNE,22447
+py_dpm/cli/main.py,sha256=LJ7JBk7lyWXe7ZYxnbxmohM1Dbha4sIdQzSTYKd9ZNo,22457
 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=d70oZ_3wXsKBRGM2TJRlsuDrHWSVkzetLAZeMIoImwc,124821
-py_dpm/dpm/utils.py,sha256=JNdAeOXjzQtye94jLPRHHGUMcvkGtTsjA5HFl92rWig,12783
+py_dpm/dpm/models.py,sha256=Rt1b8zOSayXd9KhwyfkGJVhCai3YxUakmLYgwaiICWA,135660
+py_dpm/dpm/utils.py,sha256=lyAZjMVrvVXXNw4e-3J0W6Q6o4YeZTgBtgn6BkPFTfI,13953
 py_dpm/dpm/queries/base.py,sha256=EddMeJMwtp63DyyIFO7_XxGvdlCtJQWWpeOVImlKp4I,3648
 py_dpm/dpm/queries/basic_objects.py,sha256=JOXC235lMDfVENrFAhZAl7_nqePJ4RrwJhFF0WDyk0M,955
-py_dpm/dpm/queries/explorer_queries.py,sha256=Co8CzdzlDrOL5-ZxY7_HoHPaP_j-xjLDSsB8EKT5aC8,13034
+py_dpm/dpm/queries/explorer_queries.py,sha256=HcLfwpdGWX-q-i1L-7W0nwTxL_0OiDliqPUeoZ9zHZ4,17453
 py_dpm/dpm/queries/filters.py,sha256=fxC2KLYpIvtmuyuJFb0te2ULiyDnQBZfVM79VQnr6qA,4901
 py_dpm/dpm/queries/glossary.py,sha256=2SqKZghQTw-E8NWwHebDHuDC8BC389fGe-0UBIVfJ8Q,1571
 py_dpm/dpm/queries/hierarchical_queries.py,sha256=FYO2p_OxZioynXW4nGCQ3UG3p3uzE28KdsmMaQSk1wk,31538
@@ -68,17 +68,17 @@ py_dpm/dpm_xl/utils/__init__.py,sha256=4-jXa7AdHjx2DpikAzjZVKqBktdrHgSAx6pibb4sM
 py_dpm/dpm_xl/utils/data_handlers.py,sha256=a0E-IaP_-CDKLcj-Gt2ggAziKIOUiwnT2D9IkWCS68o,4402
 py_dpm/dpm_xl/utils/operands_mapping.py,sha256=LG0hPlUuTM2X2uWOtiD6HkmNeDEJkWJ8gV-Fxej_8QM,2241
 py_dpm/dpm_xl/utils/operator_mapping.py,sha256=BFgbVbSCSuutFNHJ4gtgm5VuG38pcl8Kmfi-sefg6JU,1913
-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/scopes_calculator.py,sha256=do_emsUqD1TbrjguKlOOqFleaVhxzqm-NnlgdrdIb6I,20906
+py_dpm/dpm_xl/utils/serialization.py,sha256=ouQpkmZWc6_T0hVzjwmxpHRu9yheNyyMBBaOZERe0qM,32558
 py_dpm/dpm_xl/utils/tokens.py,sha256=VRIrPDi5ttwgH-on5Qt4-l4ho4bLA755-nfTalponcA,3496
 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
 py_dpm/instance/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-py_dpm/instance/instance.py,sha256=OPSEPgSYAxhgqhKuxbMpMPTfBnaFNzURTrUUT4kvGKc,10820
-pydpm_xl-0.2.5rc3.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pydpm_xl-0.2.5rc3.dist-info/METADATA,sha256=W-1lvyIWG91rZpsouuv4hzolwcUT6pksvJlj_9pl-dE,9305
-pydpm_xl-0.2.5rc3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-pydpm_xl-0.2.5rc3.dist-info/entry_points.txt,sha256=6DDmBfw-AjtgvMHgq_I730i_LAAs_7-N3C95HD_bRr4,47
-pydpm_xl-0.2.5rc3.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
-pydpm_xl-0.2.5rc3.dist-info/RECORD,,
+py_dpm/instance/instance.py,sha256=gRSg2dh1nEa0Srx9yKcN3bxiYidvZyRU_jsTNaKkP5I,10882
+pydpm_xl-0.2.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pydpm_xl-0.2.7.dist-info/METADATA,sha256=Tg3xyWRxhUd3w1pKuv5iNBYTRq_VkZzIH533JzyaBYQ,9302
+pydpm_xl-0.2.7.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+pydpm_xl-0.2.7.dist-info/entry_points.txt,sha256=6DDmBfw-AjtgvMHgq_I730i_LAAs_7-N3C95HD_bRr4,47
+pydpm_xl-0.2.7.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
+pydpm_xl-0.2.7.dist-info/RECORD,,

{pydpm_xl-0.2.5rc3.dist-info → pydpm_xl-0.2.7.dist-info}/WHEEL

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