pydpm_xl 0.2.5__tar.gz → 0.2.5rc1__tar.gz

{pydpm_xl-0.2.5 → pydpm_xl-0.2.5rc1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.2.5
+Version: 0.2.5rc1
 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.5 → pydpm_xl-0.2.5rc1}/py_dpm/__init__.py

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

{pydpm_xl-0.2.5 → pydpm_xl-0.2.5rc1}/py_dpm/api/dpm_xl/ast_generator.py

@@ -811,7 +811,7 @@ class ASTGeneratorAPI:
         preconditions = {}
         precondition_variables = {}
 
-        if precondition:
+        if precondition or (context and "table" in context):
             preconditions, precondition_variables = self._build_preconditions(
                 precondition=precondition,
                 context=context,
@@ -974,6 +974,8 @@ class ASTGeneratorAPI:
             match = re.match(r"\{v_([^}]+)\}", precondition)
             if match:
                 table_code = match.group(1)
+        elif context and "table" in context:
+            table_code = context["table"]
 
         if table_code:
             # Query database for actual variable ID and version
@@ -1037,81 +1039,6 @@ class ASTGeneratorAPI:
         extract_from_node(ast_dict)
         return all_variables, variables_by_table
 
-    def _extract_time_shifts_by_table(self, expression: str) -> Dict[str, str]:
-        """
-        Extract time shift information for each table in the expression.
-
-        Uses the AST to properly parse the expression and find TimeShiftOp nodes
-        to determine the ref_period for each table reference.
-
-        Args:
-            expression: DPM-XL expression
-
-        Returns:
-            Dict mapping table codes to ref_period values (e.g., {"C_01.00": "T-1Q"})
-            Tables without time shifts default to "T".
-        """
-        from py_dpm.dpm_xl.ast.template import ASTTemplate
-
-        time_shifts = {}
-        current_period = ["t"]  # Use list to allow mutation in nested function
-
-        class TimeShiftExtractor(ASTTemplate):
-            """Lightweight AST visitor that extracts time shifts for each table."""
-
-            def visit_TimeShiftOp(self, node):
-                # Save current time period and compute new one
-                previous_period = current_period[0]
-
-                period_indicator = node.period_indicator
-                shift_number = node.shift_number
-
-                # Compute time period (same logic as ModuleDependencies)
-                if "-" in str(shift_number):
-                    current_period[0] = f"t+{period_indicator}{shift_number}"
-                else:
-                    current_period[0] = f"t-{period_indicator}{shift_number}"
-
-                # Visit operand (which contains the VarID)
-                self.visit(node.operand)
-
-                # Restore previous time period
-                current_period[0] = previous_period
-
-            def visit_VarID(self, node):
-                if node.table and current_period[0] != "t":
-                    time_shifts[node.table] = current_period[0]
-
-        def convert_to_ref_period(internal_period: str) -> str:
-            """Convert internal time period format to ref_period format.
-
-            Internal format: "t+Q-1" or "t-Q1"
-            Output format: "T-1Q" for one quarter back
-            """
-            if internal_period.startswith("t+"):
-                # e.g., "t+Q-1" -> "T-1Q"
-                indicator = internal_period[2]
-                number = internal_period[3:]
-                if number.startswith("-"):
-                    return f"T{number}{indicator}"
-                return f"T+{number}{indicator}"
-            elif internal_period.startswith("t-"):
-                # e.g., "t-Q1" -> "T-1Q"
-                indicator = internal_period[2]
-                number = internal_period[3:]
-                return f"T-{number}{indicator}"
-            return "T"
-
-        try:
-            ast = self.syntax_api.parse_expression(expression)
-            extractor = TimeShiftExtractor()
-            extractor.visit(ast)
-
-            return {table: convert_to_ref_period(period) for table, period in time_shifts.items()}
-
-        except Exception:
-            return {}
-
     def _detect_cross_module_dependencies(
         self,
         expression: str,
@@ -1148,7 +1075,7 @@ class ASTGeneratorAPI:
         )
 
         try:
-            # Get tables with module info (includes module_version)
+            # Get tables with module info
             tables_with_modules = scopes_api.get_tables_with_metadata_from_expression(
                 expression=expression,
                 release_id=release_id
@@ -1164,35 +1091,10 @@ class ASTGeneratorAPI:
             if scope_result.has_error or not scope_result.is_cross_module:
                 return {}, []
 
-            # Extract time shifts for each table from expression
-            time_shifts_by_table = self._extract_time_shifts_by_table(expression)
-
             # Determine primary module from first table if not provided
             if primary_module_vid is None and tables_with_modules:
                 primary_module_vid = tables_with_modules[0].get("module_vid")
 
-            # Helper to normalize table code (remove 't' prefix if present)
-            def normalize_table_code(code: str) -> str:
-                return code[1:] if code and code.startswith('t') else code
-
-            # Helper to lookup ref_period for a table
-            def get_ref_period(table_code: str) -> str:
-                if not table_code:
-                    return "T"
-                ref = time_shifts_by_table.get(table_code)
-                if not ref:
-                    ref = time_shifts_by_table.get(normalize_table_code(table_code))
-                return ref or "T"
-
-            # Helper to lookup variables for a table
-            def get_table_variables(table_code: str) -> dict:
-                if not table_code:
-                    return {}
-                variables = variables_by_table.get(table_code)
-                if not variables:
-                    variables = variables_by_table.get(f"t{table_code}", {})
-                return variables or {}
-
             # Group external tables by module
             external_modules = {}
             for table_info in tables_with_modules:
@@ -1204,38 +1106,36 @@ class ASTGeneratorAPI:
                 if not module_code:
                     continue
 
-                # Get module URI
+                # Get module URI using existing ExplorerQuery
                 try:
                     module_uri = ExplorerQuery.get_module_url(
                         scopes_api.session,
                         module_code=module_code,
                         release_id=release_id,
                     )
+                    # Remove .json suffix if present (for consistency with expected format)
                     if module_uri.endswith(".json"):
                         module_uri = module_uri[:-5]
                 except Exception:
                     continue
 
-                table_code = table_info.get("code")
-                ref_period = get_ref_period(table_code)
-
                 if module_uri not in external_modules:
                     external_modules[module_uri] = {
                         "module_vid": module_vid,
-                        "module_version": table_info.get("module_version"),  # Already in table_info
-                        "ref_period": ref_period,
                         "tables": {},
                         "variables": {},
                         "from_date": None,
                         "to_date": None
                     }
-                elif ref_period != "T":
-                    # Keep most specific ref_period (non-T takes precedence)
-                    external_modules[module_uri]["ref_period"] = ref_period
 
-                # Add table and variables
+                # Add table - get variables from variables_by_table
+                table_code = table_info.get("code")
                 if table_code:
-                    table_variables = get_table_variables(table_code)
+                    # Look up variables in variables_by_table (handles t prefix)
+                    table_variables = variables_by_table.get(table_code, {})
+                    if not table_variables:
+                        # Try with t prefix
+                        table_variables = variables_by_table.get(f"t{table_code}", {})
                     external_modules[module_uri]["tables"][table_code] = {
                         "variables": table_variables,
                         "open_keys": {}
@@ -1269,16 +1169,11 @@ class ASTGeneratorAPI:
                 # cross_instance_dependencies entry (one per external module)
                 from_date = data["from_date"]
                 to_date = data["to_date"]
-                module_entry = {
-                    "URI": uri,
-                    "ref_period": data["ref_period"]
-                }
-                # Add module_version if available
-                if data["module_version"]:
-                    module_entry["module_version"] = data["module_version"]
-
                 cross_instance_dependencies.append({
-                    "modules": [module_entry],
+                    "modules": [{
+                        "URI": uri,
+                        "ref_period": "T"
+                    }],
                     "affected_operations": [operation_code],
                     "from_reference_date": str(from_date) if from_date else "",
                     "to_reference_date": str(to_date) if to_date else ""

{pydpm_xl-0.2.5 → pydpm_xl-0.2.5rc1}/py_dpm/dpm/models.py

@@ -720,20 +720,16 @@ class ModuleVersion(Base):
             release_id: Optional release ID to filter modules by release range
 
         Returns:
-            pandas DataFrame with columns: ModuleVID, TableVID (as variable_vid),
-            ModuleCode, VersionNumber, FromReferenceDate, ToReferenceDate,
-            StartReleaseID, EndReleaseID
+            pandas DataFrame with columns: ModuleVID, TableVID (as VARIABLE_VID),
+            FromReferenceDate, ToReferenceDate, EndReleaseID
         """
         if not tables_vids:
             return pd.DataFrame(
                 columns=[
                     "ModuleVID",
                     "variable_vid",
-                    "ModuleCode",
-                    "VersionNumber",
                     "FromReferenceDate",
                     "ToReferenceDate",
-                    "StartReleaseID",
                     "EndReleaseID",
                 ]
             )
@@ -742,11 +738,8 @@ class ModuleVersion(Base):
             session.query(
                 cls.modulevid.label("ModuleVID"),
                 ModuleVersionComposition.tablevid.label("variable_vid"),
-                cls.code.label("ModuleCode"),
-                cls.versionnumber.label("VersionNumber"),
                 cls.fromreferencedate.label("FromReferenceDate"),
                 cls.toreferencedate.label("ToReferenceDate"),
-                cls.startreleaseid.label("StartReleaseID"),
                 cls.endreleaseid.label("EndReleaseID"),
             )
             .join(
@@ -766,20 +759,16 @@ class ModuleVersion(Base):
             )
 
         results = query.all()
-        df = pd.DataFrame(
+        return pd.DataFrame(
             results,
             columns=[
                 "ModuleVID",
                 "variable_vid",
-                "ModuleCode",
-                "VersionNumber",
                 "FromReferenceDate",
                 "ToReferenceDate",
-                "StartReleaseID",
                 "EndReleaseID",
             ],
         )
-        return cls._apply_fallback_for_equal_dates(session, df)
 
     @classmethod
     def get_from_table_codes(cls, session, table_codes, release_id=None):
@@ -801,8 +790,6 @@ class ModuleVersion(Base):
                 columns=[
                     "ModuleVID",
                     "variable_vid",
-                    "ModuleCode",
-                    "VersionNumber",
                     "FromReferenceDate",
                     "ToReferenceDate",
                     "StartReleaseID",
@@ -817,8 +804,6 @@ class ModuleVersion(Base):
             session.query(
                 cls.modulevid.label("ModuleVID"),
                 ModuleVersionComposition.tablevid.label("variable_vid"),
-                cls.code.label("ModuleCode"),
-                cls.versionnumber.label("VersionNumber"),
                 cls.fromreferencedate.label("FromReferenceDate"),
                 cls.toreferencedate.label("ToReferenceDate"),
                 cls.startreleaseid.label("StartReleaseID"),
@@ -846,13 +831,11 @@ class ModuleVersion(Base):
             )
 
         results = query.all()
-        df = pd.DataFrame(
+        return pd.DataFrame(
             results,
             columns=[
                 "ModuleVID",
                 "variable_vid",
-                "ModuleCode",
-                "VersionNumber",
                 "FromReferenceDate",
                 "ToReferenceDate",
                 "StartReleaseID",
@@ -860,7 +843,6 @@ class ModuleVersion(Base):
                 "TableCode",
             ],
         )
-        return cls._apply_fallback_for_equal_dates(session, df)
 
     @classmethod
     def get_precondition_module_versions(
@@ -875,21 +857,16 @@ class ModuleVersion(Base):
             release_id: Optional release ID to filter modules by release range
 
         Returns:
-            pandas DataFrame with columns: ModuleVID, variable_vid (VariableVID),
-            ModuleCode, VersionNumber, FromReferenceDate, ToReferenceDate,
-            StartReleaseID, EndReleaseID, Code
+            pandas DataFrame with columns: ModuleVID, VariableVID (as VARIABLE_VID),
+            FromReferenceDate, ToReferenceDate, Code
         """
         if not precondition_items:
             return pd.DataFrame(
                 columns=[
                     "ModuleVID",
                     "variable_vid",
-                    "ModuleCode",
-                    "VersionNumber",
                     "FromReferenceDate",
                     "ToReferenceDate",
-                    "StartReleaseID",
-                    "EndReleaseID",
                     "Code",
                 ]
             )
@@ -898,12 +875,8 @@ class ModuleVersion(Base):
             session.query(
                 cls.modulevid.label("ModuleVID"),
                 VariableVersion.variablevid.label("variable_vid"),
-                cls.code.label("ModuleCode"),
-                cls.versionnumber.label("VersionNumber"),
                 cls.fromreferencedate.label("FromReferenceDate"),
                 cls.toreferencedate.label("ToReferenceDate"),
-                cls.startreleaseid.label("StartReleaseID"),
-                cls.endreleaseid.label("EndReleaseID"),
                 VariableVersion.code.label("Code"),
             )
             .join(ModuleParameters, cls.modulevid == ModuleParameters.modulevid)
@@ -926,21 +899,16 @@ class ModuleVersion(Base):
             )
 
         results = query.all()
-        df = pd.DataFrame(
+        return pd.DataFrame(
             results,
             columns=[
                 "ModuleVID",
                 "variable_vid",
-                "ModuleCode",
-                "VersionNumber",
                 "FromReferenceDate",
                 "ToReferenceDate",
-                "StartReleaseID",
-                "EndReleaseID",
                 "Code",
             ],
         )
-        return cls._apply_fallback_for_equal_dates(session, df)
 
     @classmethod
     def get_module_version_by_vid(cls, session, vid):
@@ -978,170 +946,6 @@ class ModuleVersion(Base):
             ],
         )
 
-    @classmethod
-    def _apply_fallback_for_equal_dates(cls, session, df, module_vid_col="ModuleVID"):
-        """
-        Apply fallback logic for rows where FromReferenceDate == ToReferenceDate.
-
-        For each such row, find the previous module version (same moduleid,
-        highest startreleaseid less than current) and replace module-specific
-        columns while preserving association columns (variable_vid, TableCode, Code).
-
-        Args:
-            session: SQLAlchemy session
-            df: pandas DataFrame with module version data
-            module_vid_col: Column name for module version ID (default: "ModuleVID")
-
-        Returns:
-            pandas DataFrame with fallback logic applied
-        """
-        if df.empty:
-            return df
-
-        # Identify rows needing fallback
-        mask = df["FromReferenceDate"] == df["ToReferenceDate"]
-        rows_needing_fallback = df[mask]
-
-        if rows_needing_fallback.empty:
-            return df
-
-        # Get unique ModuleVIDs that need fallback
-        module_vids_needing_fallback = (
-            rows_needing_fallback[module_vid_col].unique().tolist()
-        )
-
-        # Batch query: get module info (moduleid, startreleaseid) for affected rows
-        current_modules = (
-            session.query(
-                cls.modulevid,
-                cls.moduleid,
-                cls.startreleaseid,
-            )
-            .filter(cls.modulevid.in_(module_vids_needing_fallback))
-            .all()
-        )
-
-        # Build mapping: current_modulevid -> (moduleid, startreleaseid)
-        current_module_info = {
-            row.modulevid: (row.moduleid, row.startreleaseid) for row in current_modules
-        }
-
-        # Get all potential previous versions for the affected modules
-        unique_module_ids = list(set(info[0] for info in current_module_info.values()))
-
-        previous_versions_query = (
-            session.query(cls)
-            .filter(cls.moduleid.in_(unique_module_ids))
-            .order_by(cls.moduleid, cls.startreleaseid.desc())
-            .all()
-        )
-
-        # Build lookup: moduleid -> list of versions sorted by startreleaseid desc
-        versions_by_moduleid = {}
-        for mv in previous_versions_query:
-            if mv.moduleid not in versions_by_moduleid:
-                versions_by_moduleid[mv.moduleid] = []
-            versions_by_moduleid[mv.moduleid].append(mv)
-
-        # For each current modulevid, find the previous version
-        replacement_map = {}  # current_modulevid -> previous_moduleversion
-        for current_vid, (moduleid, current_startreleaseid) in current_module_info.items():
-            versions = versions_by_moduleid.get(moduleid, [])
-            for mv in versions:
-                if mv.startreleaseid < current_startreleaseid:
-                    replacement_map[current_vid] = mv
-                    break  # Already sorted desc, so first match is highest
-
-        # Apply replacements to DataFrame
-        if not replacement_map:
-            return df
-
-        # Create a copy to avoid modifying original
-        result_df = df.copy()
-
-        for idx, row in result_df.iterrows():
-            if row["FromReferenceDate"] == row["ToReferenceDate"]:
-                current_vid = row[module_vid_col]
-                if current_vid in replacement_map:
-                    prev_mv = replacement_map[current_vid]
-                    result_df.at[idx, "ModuleVID"] = prev_mv.modulevid
-                    result_df.at[idx, "ModuleCode"] = prev_mv.code
-                    result_df.at[idx, "VersionNumber"] = prev_mv.versionnumber
-                    result_df.at[idx, "FromReferenceDate"] = prev_mv.fromreferencedate
-                    result_df.at[idx, "ToReferenceDate"] = prev_mv.toreferencedate
-                    if "StartReleaseID" in result_df.columns:
-                        result_df.at[idx, "StartReleaseID"] = prev_mv.startreleaseid
-                    if "EndReleaseID" in result_df.columns:
-                        result_df.at[idx, "EndReleaseID"] = prev_mv.endreleaseid
-
-        return result_df
-
-    @classmethod
-    def get_from_release_id(
-        cls, session, release_id, module_id=None, module_code=None
-    ):
-        """
-        Get the module version applicable to a given release for a specific module.
-
-        If the resulting module version has fromreferencedate == toreferencedate,
-        the previous module version for the same module is returned instead.
-
-        Args:
-            session: SQLAlchemy session
-            release_id: The release ID to filter for
-            module_id: Optional module ID (mutually exclusive with module_code)
-            module_code: Optional module code (mutually exclusive with module_id)
-
-        Returns:
-            ModuleVersion instance or None if not found
-
-        Raises:
-            ValueError: If neither module_id nor module_code is provided,
-                        or if both are provided
-        """
-        if module_id is None and module_code is None:
-            raise ValueError("Either module_id or module_code must be provided.")
-        if module_id is not None and module_code is not None:
-            raise ValueError(
-                "Specify only one of module_id or module_code, not both."
-            )
-
-        # Build the base query with release filtering
-        query = session.query(cls).filter(
-            and_(
-                cls.startreleaseid <= release_id,
-                or_(cls.endreleaseid > release_id, cls.endreleaseid.is_(None)),
-            )
-        )
-
-        # Apply module filter
-        if module_id is not None:
-            query = query.filter(cls.moduleid == module_id)
-        else:  # module_code
-            query = query.filter(cls.code == module_code)
-
-        module_version = query.first()
-
-        if module_version is None:
-            return None
-
-        # Check if fromreferencedate == toreferencedate
-        if module_version.fromreferencedate == module_version.toreferencedate:
-            # Get the previous module version for the same module
-            prev_query = (
-                session.query(cls)
-                .filter(
-                    cls.moduleid == module_version.moduleid,
-                    cls.startreleaseid < module_version.startreleaseid,
-                )
-                .order_by(cls.startreleaseid.desc())
-            )
-            prev_module_version = prev_query.first()
-            if prev_module_version:
-                return prev_module_version
-
-        return module_version
-
     @classmethod
     def get_last_release(cls, session):
         """
@@ -1315,60 +1119,6 @@ class OperationScope(Base):
         "OperationScopeComposition", back_populates="operation_scope"
     )
 
-    def to_dict(self):
-        """
-        Convert the operation scope to a dictionary representation.
-
-        Returns:
-            dict: A dictionary with module codes as keys and module details as values.
-                  Format: {
-                      "<module_code>": {
-                          "module_version_number": <versionnumber>,
-                          "from_reference_date": <fromreferencedate>,
-                          "to_reference_date": <toreferencedate>
-                      },
-                      ...
-                  }
-        """
-        from sqlalchemy.orm import object_session
-
-        def format_date(date_value):
-            """Format date to string (YYYY-MM-DD) or None if NaT/None."""
-            if date_value is None:
-                return None
-            if pd.isna(date_value):
-                return None
-            if hasattr(date_value, "strftime"):
-                return date_value.strftime("%Y-%m-%d")
-            return str(date_value)
-
-        result = {}
-        for composition in self.operation_scope_compositions:
-            # For new/proposed scopes, use transient _module_info attribute
-            if hasattr(composition, "_module_info") and composition._module_info:
-                info = composition._module_info
-                result[info["code"]] = {
-                    "module_version_number": info["version_number"],
-                    "from_reference_date": format_date(info["from_reference_date"]),
-                    "to_reference_date": format_date(info["to_reference_date"]),
-                }
-            else:
-                # For existing scopes from DB, use relationship or query
-                module_version = composition.module_version
-                if module_version is None:
-                    session = object_session(self)
-                    if session is not None:
-                        module_version = session.query(ModuleVersion).filter(
-                            ModuleVersion.modulevid == composition.modulevid
-                        ).first()
-                if module_version is not None:
-                    result[module_version.code] = {
-                        "module_version_number": module_version.versionnumber,
-                        "from_reference_date": format_date(module_version.fromreferencedate),
-                        "to_reference_date": format_date(module_version.toreferencedate),
-                    }
-        return result
-
 
 class OperationScopeComposition(Base):
     __tablename__ = "OperationScopeComposition"

{pydpm_xl-0.2.5 → pydpm_xl-0.2.5rc1}/py_dpm/dpm_xl/utils/scopes_calculator.py

@@ -71,19 +71,9 @@ 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,
-                module_info={
-                    "code": module_code,
-                    "version_number": version_number,
-                    "from_reference_date": from_date,
-                    "to_reference_date": to_date,
-                },
+                operation_scope=operation_scope, module_vid=module_vid
             )
         else:
             intra_modules = []
@@ -93,10 +83,11 @@ class OperationScopeService:
             if table_codes:
                 unique_operands_number = len(table_codes) + len(precondition_items)
 
-                # 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]
+                # 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)
 
                 for module_vid, group_df in modules_info_dataframe.groupby(MODULE_VID):
                     table_codes_in_module = (
@@ -114,55 +105,31 @@ 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:
-                        # Track modules by table code and lifecycle
+                        # For cross-module, group by table code AND lifecycle stage
+                        target_dict = (
+                            starting_modules if is_starting else ending_modules
+                        )
                         for table_code in table_codes_in_module:
-                            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
+                            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
             else:
                 # Original logic for table VIDs
                 unique_operands_number = len(tables_vids) + len(precondition_items)
@@ -301,21 +268,12 @@ class OperationScopeService:
         :param modules_vids: list with module version ids
         """
         for module_vid in modules_vids:
-            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"]
+            from_date = modules_info[modules_info["ModuleVID"] == module_vid][
+                "FromReferenceDate"
+            ].values[0]
             operation_scope = self.create_operation_scope(from_date)
             self.create_operation_scope_composition(
-                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,
-                },
+                operation_scope=operation_scope, module_vid=module_vid
             )
 
     def process_cross_module(self, cross_modules, modules_dataframe):
@@ -355,18 +313,8 @@ 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,
-                    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],
-                    },
+                    operation_scope=operation_scope, module_vid=module
                 )
 
     def create_operation_scope(self, submission_date):
@@ -392,21 +340,17 @@ class OperationScopeService:
         self.session.add(operation_scope)
         return operation_scope
 
-    def create_operation_scope_composition(self, operation_scope, module_vid, module_info=None):
+    def create_operation_scope_composition(self, operation_scope, module_vid):
         """
         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):

{pydpm_xl-0.2.5 → pydpm_xl-0.2.5rc1}/pydpm_xl.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pydpm_xl
-Version: 0.2.5
+Version: 0.2.5rc1
 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.5 → pydpm_xl-0.2.5rc1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "pydpm_xl"
-version = "0.2.5"
+version = "0.2.5rc1"
 description = "Python library for DPM-XL data processing and analysis"
 authors = [
     {name = "MeaningfulData S.L.", email = "info@meaningfuldata.eu"}
@@ -52,7 +52,7 @@ exclude = []
 
 [tool.poetry]
 name = "pydpm_xl"
-version = "0.2.5"
+version = "0.2.5rc1"
 description = "Python library for DPM-XL data processing and analysis"
 authors = ["MeaningfulData S.L. <info@meaningfuldata.eu>"]
 readme = "README.md"