pydpm_xl 0.2.9__py3-none-any.whl → 0.2.11__py3-none-any.whl

py_dpm/__init__.py

@@ -41,7 +41,7 @@ Available packages:
 - pydpm.api: Main APIs for migration, syntax, and semantic analysis
 """
 
-__version__ = "0.2.9"
+__version__ = "0.2.11"
 __author__ = "MeaningfulData S.L."
 __email__ = "info@meaningfuldata.eu"
 __license__ = "GPL-3.0-or-later"

py_dpm/api/dpm_xl/ast_generator.py

@@ -984,6 +984,7 @@ class ASTGeneratorAPI:
         """
         from py_dpm.dpm.utils import get_engine
         from py_dpm.api.dpm import DataDictionaryAPI
+        from py_dpm.api.dpm_xl.operation_scopes import OperationScopesAPI
 
         # Initialize database connection
         engine = get_engine(database_path=self.database_path, connection_url=self.connection_url)
@@ -1017,6 +1018,12 @@ class ASTGeneratorAPI:
             connection_url=self.connection_url
         )
 
+        # Initialize OperationScopesAPI once for all expressions (performance optimization)
+        scopes_api = OperationScopesAPI(
+            database_path=self.database_path,
+            connection_url=self.connection_url
+        )
+
         # Primary module info will be determined from the first expression or module_code
         primary_module_info = None
         namespace = None
@@ -1035,6 +1042,21 @@ class ASTGeneratorAPI:
                 complete_ast = complete_result["ast"]
                 context = complete_result.get("context") or table_context
 
+                # Get tables with modules for this expression FIRST (reuse scopes_api from outer scope)
+                # This is done before _get_primary_module_info to pass precomputed values
+                tables_with_modules = scopes_api.get_tables_with_metadata_from_expression(
+                    expression=expression,
+                    release_id=release_id
+                )
+
+                # Calculate scope_result once (avoid duplicate calls in other methods)
+                scope_result = scopes_api.calculate_scopes_from_expression(
+                    expression=expression,
+                    release_id=release_id,
+                    read_only=True
+                )
+                all_tables_with_modules.extend(tables_with_modules)
+
                 # Get primary module info from first expression (or use module_code)
                 if primary_module_info is None:
                     primary_module_info = self._get_primary_module_info(
@@ -1042,6 +1064,9 @@ class ASTGeneratorAPI:
                         primary_module_vid=primary_module_vid,
                         release_id=release_id,
                         module_code=module_code,
+                        # Performance optimization: pass precomputed values
+                        tables_with_modules=tables_with_modules,
+                        scopes_api=scopes_api,
                     )
                     namespace = primary_module_info.get("module_uri", "default_module")
 
@@ -1066,18 +1091,6 @@ class ASTGeneratorAPI:
                 # Clean extra fields from data entries
                 self._clean_ast_data_entries(ast_with_coords)
 
-                # Get tables with modules for this expression
-                from py_dpm.api.dpm_xl.operation_scopes import OperationScopesAPI
-                scopes_api = OperationScopesAPI(
-                    database_path=self.database_path,
-                    connection_url=self.connection_url
-                )
-                tables_with_modules = scopes_api.get_tables_with_metadata_from_expression(
-                    expression=expression,
-                    release_id=release_id
-                )
-                all_tables_with_modules.extend(tables_with_modules)
-
                 # Build mapping of table_code -> module_vid
                 # Prefer the module VID that matches the detected primary module
                 table_to_module = {}
@@ -1179,6 +1192,10 @@ class ASTGeneratorAPI:
                     operation_code=operation_code,
                     release_id=release_id,
                     preferred_module_dependencies=preferred_module_dependencies,
+                    # Performance optimization: pass precomputed values to avoid redundant work
+                    tables_with_modules=tables_with_modules,
+                    scopes_api=scopes_api,
+                    scope_result=scope_result,
                 )
 
                 # Merge dependency modules (avoid table duplicates)
@@ -1313,6 +1330,8 @@ class ASTGeneratorAPI:
         primary_module_vid: Optional[int],
         release_id: Optional[int],
         module_code: Optional[str] = None,
+        tables_with_modules: Optional[List[Dict[str, Any]]] = None,
+        scopes_api: Optional[Any] = None,
     ) -> Dict[str, Any]:
         """
         Detect and return metadata for the primary module from the expression.
@@ -1323,6 +1342,10 @@ class ASTGeneratorAPI:
             release_id: Optional release ID for filtering
             module_code: Optional module code (e.g., "FINREP9") - takes precedence over
                 primary_module_vid if provided
+            tables_with_modules: Optional precomputed tables with module metadata
+                (performance optimization to avoid redundant database queries)
+            scopes_api: Optional precomputed OperationScopesAPI instance
+                (performance optimization to reuse database connections)
 
         Returns:
             Dict with module_uri, module_code, module_version, framework_code,
@@ -1341,20 +1364,28 @@ class ASTGeneratorAPI:
             "module_vid": None,
         }
 
+        # Track if we created the scopes_api locally (need to close it)
+        local_scopes_api = False
+
         try:
-            scopes_api = OperationScopesAPI(
-                database_path=self.database_path,
-                connection_url=self.connection_url
-            )
+            # Reuse provided scopes_api or create a new one
+            if scopes_api is None:
+                scopes_api = OperationScopesAPI(
+                    database_path=self.database_path,
+                    connection_url=self.connection_url
+                )
+                local_scopes_api = True
 
-            # Get tables with module metadata from expression
-            tables_with_modules = scopes_api.get_tables_with_metadata_from_expression(
-                expression=expression,
-                release_id=release_id
-            )
+            # Reuse provided tables_with_modules or fetch if not available
+            if tables_with_modules is None:
+                tables_with_modules = scopes_api.get_tables_with_metadata_from_expression(
+                    expression=expression,
+                    release_id=release_id
+                )
 
             if not tables_with_modules:
-                scopes_api.close()
+                if local_scopes_api:
+                    scopes_api.close()
                 return default_info
 
             # Determine primary module
@@ -1408,7 +1439,8 @@ class ASTGeneratorAPI:
                         to_date = module.get("to_reference_date", to_date)
                         break
 
-            scopes_api.close()
+            if local_scopes_api:
+                scopes_api.close()
 
             return {
                 "module_uri": module_uri or "default_module",
@@ -1864,6 +1896,9 @@ class ASTGeneratorAPI:
         operation_code: str,
         release_id: Optional[int] = None,
         preferred_module_dependencies: Optional[List[str]] = None,
+        tables_with_modules: Optional[List[Dict[str, Any]]] = None,
+        scopes_api: Optional[Any] = None,
+        scope_result: Optional[Any] = None,
     ) -> tuple:
         """
         Detect cross-module dependencies for a single expression.
@@ -1879,6 +1914,12 @@ class ASTGeneratorAPI:
             release_id: Optional release ID for filtering
             preferred_module_dependencies: Optional list of module codes to prefer when
                 a table belongs to multiple modules
+            tables_with_modules: Optional precomputed tables with module metadata
+                (performance optimization to avoid redundant database queries)
+            scopes_api: Optional precomputed OperationScopesAPI instance
+                (performance optimization to reuse database connections)
+            scope_result: Optional precomputed scope result from calculate_scopes_from_expression
+                (performance optimization to avoid redundant computation)
 
         Returns:
             Tuple of (dependency_modules, cross_instance_dependencies)
@@ -1889,24 +1930,28 @@ class ASTGeneratorAPI:
         from py_dpm.dpm.queries.explorer_queries import ExplorerQuery
         import logging
 
-        scopes_api = OperationScopesAPI(
-            database_path=self.database_path,
-            connection_url=self.connection_url
-        )
+        # Reuse provided scopes_api or create a new one
+        if scopes_api is None:
+            scopes_api = OperationScopesAPI(
+                database_path=self.database_path,
+                connection_url=self.connection_url
+            )
 
         try:
-            # Get tables with module info (includes module_version)
-            tables_with_modules = scopes_api.get_tables_with_metadata_from_expression(
-                expression=expression,
-                release_id=release_id
-            )
+            # Reuse provided tables_with_modules or fetch if not available
+            if tables_with_modules is None:
+                tables_with_modules = scopes_api.get_tables_with_metadata_from_expression(
+                    expression=expression,
+                    release_id=release_id
+                )
 
-            # Check if cross-module
-            scope_result = scopes_api.calculate_scopes_from_expression(
-                expression=expression,
-                release_id=release_id,
-                read_only=True
-            )
+            # Reuse provided scope_result or compute if not available
+            if scope_result is None:
+                scope_result = scopes_api.calculate_scopes_from_expression(
+                    expression=expression,
+                    release_id=release_id,
+                    read_only=True
+                )
 
             if scope_result.has_error or not scope_result.is_cross_module:
                 return {}, []
@@ -2161,12 +2206,11 @@ class ASTGeneratorAPI:
                                 entry["x"] = x_index
 
                         # Calculate y coordinate (column position)
+                        # Only add y if there are multiple columns
                         if cols and col_code in cols:
                             y_index = cols.index(col_code) + 1
-                            entry["y"] = y_index
-                        elif not cols:
-                            # Default to 1 if no column info
-                            entry["y"] = 1
+                            if len(cols) > 1:
+                                entry["y"] = y_index
 
                         # Calculate z coordinate (sheet position)
                         if sheets and sheet_code in sheets:
@@ -2193,13 +2237,16 @@ class ASTGeneratorAPI:
         Remove extra fields from data entries in the AST.
 
         Keeps only the fields required by the engine:
-        - datapoint, operand_reference_id, y, column, x (if multiple rows), z (if multiple sheets)
+        - datapoint, operand_reference_id (always)
+        - x and row (only if multiple rows - rows are variable)
+        - y and column (only if multiple columns - columns are variable)
+        - z and sheet (only if multiple sheets - sheets are variable)
 
         Removes internal/debug fields:
-        - data_type, cell_code, table_code, table_vid, row
+        - data_type, cell_code, table_code, table_vid
         """
-        # Fields to keep in data entries
-        ALLOWED_FIELDS = {"datapoint", "operand_reference_id", "x", "y", "z", "column", "sheet"}
+        # Base fields to always keep in data entries
+        BASE_FIELDS = {"datapoint", "operand_reference_id"}
 
         def clean_node(node):
             if isinstance(node, dict):
@@ -2207,9 +2254,22 @@ class ASTGeneratorAPI:
                 if node.get("class_name") == "VarID" and "data" in node:
                     cleaned_data = []
                     for data_entry in node["data"]:
+                        # Build allowed fields based on which coordinates are present
+                        # Only keep row/column/sheet if the corresponding x/y/z coordinate exists
+                        allowed = set(BASE_FIELDS)
+                        if "x" in data_entry:
+                            allowed.add("x")
+                            allowed.add("row")
+                        if "y" in data_entry:
+                            allowed.add("y")
+                            allowed.add("column")
+                        if "z" in data_entry:
+                            allowed.add("z")
+                            allowed.add("sheet")
+
                         # Keep only allowed fields
                         cleaned_entry = {
-                            k: v for k, v in data_entry.items() if k in ALLOWED_FIELDS
+                            k: v for k, v in data_entry.items() if k in allowed
                         }
                         cleaned_data.append(cleaned_entry)
                     node["data"] = cleaned_data

py_dpm/dpm/migration.py

@@ -103,14 +103,16 @@ def _extract_with_pyodbc(access_file):
         import pyodbc
     except ImportError:
         raise Exception("pyodbc not available")
-    
+
+    import decimal
+
     # Try different Access drivers
     drivers_to_try = [
         r'DRIVER={Microsoft Access Driver (*.mdb, *.accdb)};',
         r'DRIVER={Microsoft Access Driver (*.mdb)};',
         r'DRIVER={MDBTools};'
     ]
-    
+
     conn = None
     for driver in drivers_to_try:
         try:
@@ -120,10 +122,10 @@ def _extract_with_pyodbc(access_file):
             break
         except pyodbc.Error:
             continue
-    
+
     if not conn:
         raise Exception("No suitable ODBC driver found for Access database")
-    
+
     try:
         # Get all table names
         cursor = conn.cursor()
@@ -132,63 +134,56 @@ def _extract_with_pyodbc(access_file):
             table_name = table_info.table_name
             if not table_name.startswith('MSys'):  # Skip system tables
                 tables.append(table_name)
-        
+
         data = {}
-        STRING_COLUMNS = ["row", "column", "sheet"]
-        
+
         # Extract each table
         for table_name in tables:
             print(table_name)
             try:
                 cursor.execute(f"SELECT * FROM [{table_name}]")
-                columns = [column[0] for column in cursor.description]
+
+                # Get column metadata from cursor.description
+                # Each entry is: (name, type_code, display_size, internal_size, precision, scale, null_ok)
+                # type_code is a Python type (str, int, float, decimal.Decimal, etc.)
+                column_info = []
+                for col_desc in cursor.description:
+                    col_name = col_desc[0]
+                    col_type = col_desc[1]  # Python type from ODBC metadata
+                    column_info.append((col_name, col_type))
+
+                columns = [info[0] for info in column_info]
                 rows = cursor.fetchall()
-                
+
                 if rows:
                     # Convert to DataFrame
                     df = pd.DataFrame([list(row) for row in rows], columns=columns)
 
-                    # Apply same dtype conversion logic as mdb-tools method
-                    # Start with all strings, but preserve None as actual None (not string 'None')
-                    for col in df.columns:
-                        df[col] = df[col].astype(object)
-                        mask = df[col].notna()
-                        df.loc[mask, col] = df.loc[mask, col].astype(str)
-
-                    numeric_columns = []
-                    for column in df.columns:
-                        if column in STRING_COLUMNS:
-                            continue
-                        try:
-                            # Convert to numeric and check if any values start with '0' (except '0' itself)
-                            # Only check string values for leading zeros
-                            string_mask = df[column].astype(str).str.match(r'^0\d+', na=False)
-                            has_leading_zeros = string_mask.any()
-
-                            # Test numeric conversion
-                            numeric_series = pd.to_numeric(df[column], errors='coerce')
-
-                            if not has_leading_zeros and not numeric_series.isna().all():
-                                numeric_columns.append(column)
-                        except Exception:
-                            continue
-
-                    # Convert only the identified numeric columns
-                    for col in numeric_columns:
-                        try:
-                            df[col] = pd.to_numeric(df[col], errors='coerce')
-                        except (ValueError, TypeError):
-                            # Keep as string if conversion fails
-                            pass
-                    
+                    # Use the actual column types from Access schema metadata
+                    # instead of inferring from data values (fixes Windows vs Linux inconsistency)
+                    numeric_types = (int, float, decimal.Decimal)
+
+                    for col_name, col_type in column_info:
+                        if col_type in numeric_types:
+                            # Column is defined as numeric in Access schema - convert to numeric
+                            try:
+                                df[col_name] = pd.to_numeric(df[col_name], errors='coerce')
+                            except (ValueError, TypeError):
+                                pass
+                        else:
+                            # Column is defined as text/other in Access schema - keep as string
+                            df[col_name] = df[col_name].astype(object)
+                            mask = df[col_name].notna()
+                            df.loc[mask, col_name] = df.loc[mask, col_name].astype(str)
+
                     data[table_name] = df
-                
+
             except Exception as e:
                 print(f"Error processing table {table_name}: {e}", file=sys.stderr)
                 continue
-        
+
         return data
-        
+
     finally:
         conn.close()
 

py_dpm/dpm/models.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import List
+from typing import Dict, Hashable, List, Tuple
 from sqlalchemy import (
     Boolean,
     Column,
@@ -36,6 +36,11 @@ class SerializationMixin:
 Base = declarative_base(cls=SerializationMixin)
 
 
+def _get_engine_cache_key(session) -> Hashable:
+    bind = session.get_bind()
+    return getattr(bind, "url", repr(bind))
+
+
 def _read_sql_with_connection(sql, session):
     """
     Execute pd.read_sql with proper connection handling to avoid pandas warnings.
@@ -2319,6 +2324,11 @@ class ViewDatapoints(Base):
     context_id = Column(Integer)
     variable_vid = Column(String)
 
+    _TABLE_DATA_CACHE: Dict[
+        Tuple[Hashable, str, Tuple[str, ...] | None, Tuple[str, ...] | None, Tuple[str, ...] | None, int | None],
+        pd.DataFrame,
+    ] = {}
+
     @classmethod
     def _create_base_query_with_aliases(cls, session):
         """
@@ -2552,7 +2562,16 @@ class ViewDatapoints(Base):
     def get_table_data(
         cls, session, table, rows=None, columns=None, sheets=None, release_id=None
     ):
-        # Build query using ORM for database-agnostic compatibility
+        engine_key = _get_engine_cache_key(session)
+        rows_key = tuple(rows) if rows is not None else None
+        columns_key = tuple(columns) if columns is not None else None
+        sheets_key = tuple(sheets) if sheets is not None else None
+        cache_key = (engine_key, table, rows_key, columns_key, sheets_key, release_id)
+
+        cached = cls._TABLE_DATA_CACHE.get(cache_key)
+        if cached is not None:
+            return cached
+
         query, aliases = cls._create_base_query_with_aliases(session)
 
         # Add column selections
@@ -2669,6 +2688,7 @@ class ViewDatapoints(Base):
         data = _check_ranges_values_are_present(data, "column_code", columns)
         data = _check_ranges_values_are_present(data, "sheet_code", sheets)
 
+        cls._TABLE_DATA_CACHE[cache_key] = data
         return data
 
     @classmethod

py_dpm/dpm_xl/ast/operands.py

@@ -2,6 +2,7 @@ from abc import ABC
 
 import pandas as pd
 import warnings
+from typing import Dict, Hashable, Tuple
 
 # Suppress pandas UserWarning about SQLAlchemy connection types
 warnings.filterwarnings("ignore", message=".*pandas only supports SQLAlchemy.*")
@@ -43,6 +44,9 @@ from py_dpm.dpm_xl.utils.data_handlers import filter_all_data
 operand_elements = ["table", "rows", "cols", "sheets", "default", "interval"]
 
 
+_HEADERS_CACHE: Dict[Tuple[Hashable, int, Tuple[str, ...]], pd.DataFrame] = {}
+
+
 def _create_operand_label(node):
     label = generate_new_label()
     node.label = label
@@ -185,42 +189,47 @@ class OperandsChecking(ASTTemplate, ABC):
         if len(table_codes) == 0:
             return
 
-        # Build ORM query
-        query = (
-            self.session.query(
-                TableVersion.code.label("Code"),
-                TableVersion.startreleaseid.label("StartReleaseID"),
-                TableVersion.endreleaseid.label("EndReleaseID"),
-                Header.direction.label("Direction"),
-                Table.hasopenrows.label("HasOpenRows"),
-                Table.hasopencolumns.label("HasOpenColumns"),
-                Table.hasopensheets.label("HasOpenSheets"),
-            )
-            .join(Table, Table.tableid == TableVersion.tableid)
-            .join(
-                TableVersionHeader, TableVersion.tablevid == TableVersionHeader.tablevid
+        engine = self.session.get_bind()
+        engine_key: Hashable = getattr(engine, "url", repr(engine))
+        cache_key = (engine_key, self.release_id, tuple(sorted(table_codes)))
+
+        df_headers = _HEADERS_CACHE.get(cache_key)
+        if df_headers is None:
+            query = (
+                self.session.query(
+                    TableVersion.code.label("Code"),
+                    TableVersion.startreleaseid.label("StartReleaseID"),
+                    TableVersion.endreleaseid.label("EndReleaseID"),
+                    Header.direction.label("Direction"),
+                    Table.hasopenrows.label("HasOpenRows"),
+                    Table.hasopencolumns.label("HasOpenColumns"),
+                    Table.hasopensheets.label("HasOpenSheets"),
+                )
+                .join(Table, Table.tableid == TableVersion.tableid)
+                .join(
+                    TableVersionHeader,
+                    TableVersion.tablevid == TableVersionHeader.tablevid,
+                )
+                .join(Header, Header.headerid == TableVersionHeader.headerid)
+                .filter(TableVersion.code.in_(table_codes))
+                .distinct()
             )
-            .join(Header, Header.headerid == TableVersionHeader.headerid)
-            .filter(TableVersion.code.in_(table_codes))
-            .distinct()
-        )
 
-        # Apply release filter
-        query = filter_by_release(
-            query,
-            start_col=TableVersion.startreleaseid,
-            end_col=TableVersion.endreleaseid,
-            release_id=self.release_id,
-        )
+            query = filter_by_release(
+                query,
+                start_col=TableVersion.startreleaseid,
+                end_col=TableVersion.endreleaseid,
+                release_id=self.release_id,
+            )
 
-        # Execute query and convert to DataFrame
-        from py_dpm.dpm.models import (
-            _compile_query_for_pandas,
-            _read_sql_with_connection,
-        )
+            from py_dpm.dpm.models import (
+                _compile_query_for_pandas,
+                _read_sql_with_connection,
+            )
 
-        compiled_query = _compile_query_for_pandas(query.statement, self.session)
-        df_headers = _read_sql_with_connection(compiled_query, self.session)
+            compiled_query = _compile_query_for_pandas(query.statement, self.session)
+            df_headers = _read_sql_with_connection(compiled_query, self.session)
+            _HEADERS_CACHE[cache_key] = df_headers
 
         for table in table_codes:
             table_headers = df_headers[df_headers["Code"] == table]

{pydpm_xl-0.2.9.dist-info → pydpm_xl-0.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.2.9
+Version: 0.2.11
 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.9.dist-info → pydpm_xl-0.2.11.dist-info}/RECORD

@@ -1,4 +1,4 @@
-py_dpm/__init__.py,sha256=UebIlIJlsFPrSAjcWcWrZjKo17MDQ2MIFWV2pjJMbq8,1858
+py_dpm/__init__.py,sha256=mCQT4E9AM2a8Gg_V4tbxaQkfJ_CB9uUJR0fH7DR9uVI,1859
 py_dpm/api/__init__.py,sha256=bPWo4KWW99GmGkQbq0yQ3_tbTxvidEVVrWmcDXWz-xA,828
 py_dpm/api/dpm/__init__.py,sha256=HQflgiRbs1eDi3KTadNhxS1NoaG6PGQDVMvFnuIEfXo,506
 py_dpm/api/dpm/data_dictionary.py,sha256=q6w_5bFdc6WPd5Z601PpDaCcnIw39CnI4wdby3GJmFU,29893
@@ -7,7 +7,7 @@ py_dpm/api/dpm/hierarchical_queries.py,sha256=X4AbpsWy3iItOTVIdVbtaTmRgOHPf0Y64I
 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=SOsCtwxuCkFQIdYoTcU6tVJdK1j96dPF4ZQpr8okLPc,576
-py_dpm/api/dpm_xl/ast_generator.py,sha256=kBU4GMJNCDaJQ8_9H-xuTpRPuIxA6wFlFh1AvV0saEU,94941
+py_dpm/api/dpm_xl/ast_generator.py,sha256=53Hq1I2Uey6VqNmehU-6vSjyUnfU56GhcJKZuNZAEFw,98334
 py_dpm/api/dpm_xl/complete_ast.py,sha256=jjn9tsns4X7EN4RV5mFh5DRxxZfBOuX2b1wic4oB_ls,3967
 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
@@ -16,8 +16,8 @@ py_dpm/cli/__init__.py,sha256=UrfGHoQ0sZLjWfA0hoOoI4iTrn-bjr2f9Q8wDWd5nMo,133
 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=Rt1b8zOSayXd9KhwyfkGJVhCai3YxUakmLYgwaiICWA,135660
+py_dpm/dpm/migration.py,sha256=I_OX1xS2eE3L2V1RAPyHOqFn3Z54NWE0ozLAJdQrLcc,13810
+py_dpm/dpm/models.py,sha256=YyOYXzN4tIT2rO6-PP-53C6f7skatgnz7VY_5SnOsLQ,136414
 py_dpm/dpm/utils.py,sha256=3w06_kKiFRPqHvRUfN_0nNQIpppfidFybdDge97qzI0,14918
 py_dpm/dpm/queries/base.py,sha256=EddMeJMwtp63DyyIFO7_XxGvdlCtJQWWpeOVImlKp4I,3648
 py_dpm/dpm/queries/basic_objects.py,sha256=JOXC235lMDfVENrFAhZAl7_nqePJ4RrwJhFF0WDyk0M,955
@@ -35,7 +35,7 @@ py_dpm/dpm_xl/ast/ml_generation.py,sha256=Lw_1Btln2x1ewD9xH-2Ea4NJJP3PIqFoivWASX
 py_dpm/dpm_xl/ast/module_analyzer.py,sha256=ZnldoYn-s41UMiJpcAV6hjIwH6fssZeOpc564epngg8,2872
 py_dpm/dpm_xl/ast/module_dependencies.py,sha256=tbCqoDcE1n1lJOjtbpD3rNPkXrLk-k2rM5zyVwmsNpc,8355
 py_dpm/dpm_xl/ast/nodes.py,sha256=5ob8MsCW0fPZgz9yP_6IgVTH2SGeoTk5VncJuQ2SgrE,25035
-py_dpm/dpm_xl/ast/operands.py,sha256=UN69SQB0S8VG4sjQPz6CNfwjg1uDPEXqKsJtVIgiGGA,21128
+py_dpm/dpm_xl/ast/operands.py,sha256=0Yye5z6l0BBh9nrMlkVVNy3fYgbeUzZYLmP5Jvzr95M,21606
 py_dpm/dpm_xl/ast/template.py,sha256=QhYm7Jh_a-ws3kSmf0hqXFLzB_quO9GgKcmcFe22_fg,3045
 py_dpm/dpm_xl/ast/visitor.py,sha256=yL9UpPMQlq8ToHR8COyFYpuSChnDRjnkQHbCyYX0tsY,509
 py_dpm/dpm_xl/ast/where_clause.py,sha256=g3cslQ8vmlm0doqQ_ghjXzhzItc_xlC_bQ9odn87FGk,328
@@ -76,9 +76,9 @@ py_dpm/exceptions/exceptions.py,sha256=6S3p-_i5O1oStvSMixt_JQG0xwTeSfBcdzrwL8yBy
 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=gRSg2dh1nEa0Srx9yKcN3bxiYidvZyRU_jsTNaKkP5I,10882
-pydpm_xl-0.2.9.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-pydpm_xl-0.2.9.dist-info/METADATA,sha256=_mvGUc4MEE6EeZDgllAD8p4KtB7QSRX9rw-mh0Cj1M4,9153
-pydpm_xl-0.2.9.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
-pydpm_xl-0.2.9.dist-info/entry_points.txt,sha256=6DDmBfw-AjtgvMHgq_I730i_LAAs_7-N3C95HD_bRr4,47
-pydpm_xl-0.2.9.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
-pydpm_xl-0.2.9.dist-info/RECORD,,
+pydpm_xl-0.2.11.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+pydpm_xl-0.2.11.dist-info/METADATA,sha256=JXXtaUl9tMD7TSrGR5G9KWu_d1gTwutLIVpWYBJY18g,9154
+pydpm_xl-0.2.11.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+pydpm_xl-0.2.11.dist-info/entry_points.txt,sha256=6DDmBfw-AjtgvMHgq_I730i_LAAs_7-N3C95HD_bRr4,47
+pydpm_xl-0.2.11.dist-info/top_level.txt,sha256=495PvWZRoKl2NvbQU25W7dqWIBHqY-mFMPt83uxPpcM,7
+pydpm_xl-0.2.11.dist-info/RECORD,,

{pydpm_xl-0.2.9.dist-info → pydpm_xl-0.2.11.dist-info}/WHEEL

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