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

py_dpm/api/dpm_xl/complete_ast.py

@@ -12,7 +12,7 @@ For new code, prefer using ASTGeneratorAPI directly:
     result = generator.generate_complete_ast(expression)
 """
 
-from typing import Dict, Any, Optional, List
+from typing import Dict, Any, Optional, List, Union, Tuple
 from py_dpm.api.dpm_xl.ast_generator import ASTGeneratorAPI
 
 
@@ -46,35 +46,6 @@ def generate_complete_ast(
     return generator.generate_complete_ast(expression, release_id=release_id)
 
 
-def generate_complete_batch(
-    expressions: list,
-    database_path: str = None,
-    connection_url: str = None,
-    release_id: Optional[int] = None,
-):
-    """
-    Generate complete ASTs for multiple expressions.
-
-    This function delegates to ASTGeneratorAPI for backwards compatibility.
-
-    Args:
-        expressions: List of DPM-XL expression strings
-        database_path: Path to SQLite database file
-        connection_url: SQLAlchemy connection URL for PostgreSQL (optional)
-        release_id: Optional release ID to filter database lookups by specific release.
-            If None, uses all available data (release-agnostic).
-
-    Returns:
-        list: List of result dictionaries
-    """
-    generator = ASTGeneratorAPI(
-        database_path=database_path,
-        connection_url=connection_url,
-        enable_semantic_validation=True
-    )
-    return generator.generate_complete_batch(expressions, release_id=release_id)
-
-
 # Convenience function with cleaner interface
 def parse_with_data_fields(
     expression: str,
@@ -109,33 +80,42 @@ def parse_with_data_fields(
 
 
 def generate_enriched_ast(
-    expression: str,
+    expressions: Union[str, List[Tuple[str, str, Optional[str]]]],
     database_path: Optional[str] = None,
     connection_url: Optional[str] = None,
-    dpm_version: Optional[str] = None,
-    operation_code: Optional[str] = None,
+    release_code: Optional[str] = None,
     table_context: Optional[Dict[str, Any]] = None,
-    precondition: Optional[str] = None,
     release_id: Optional[int] = None,
     primary_module_vid: Optional[int] = None,
+    module_code: Optional[str] = None,
+    preferred_module_dependencies: Optional[List[str]] = None,
 ) -> Dict[str, Any]:
     """
-    Generate enriched, engine-ready AST from DPM-XL expression.
+    Generate enriched, engine-ready AST from DPM-XL expression(s).
 
     This function delegates to ASTGeneratorAPI for backwards compatibility.
 
+    Supports both single expressions (for backward compatibility) and multiple
+    expression/operation/precondition tuples for generating scripts with multiple operations.
+
     Args:
-        expression: DPM-XL expression string
+        expressions: Either a single DPM-XL expression string (backward compatible),
+            or a list of tuples: [(expression, operation_code, precondition), ...].
+            Each tuple contains:
+            - expression (str): The DPM-XL expression (required)
+            - operation_code (str): The operation code (required)
+            - precondition (Optional[str]): Optional precondition reference (e.g., {v_F_44_04})
         database_path: Path to SQLite database (or None for PostgreSQL)
         connection_url: PostgreSQL connection URL (takes precedence over database_path)
-        dpm_version: DPM version code (e.g., "4.0", "4.1", "4.2")
-        operation_code: Optional operation code (defaults to "default_code")
+        release_code: DPM release code (e.g., "4.0", "4.1", "4.2")
         table_context: Optional table context dict with keys: 'table', 'columns', 'rows', 'sheets', 'default', 'interval'
-        precondition: Optional precondition variable reference (e.g., {v_F_44_04})
         release_id: Optional release ID to filter database lookups by specific release.
             If None, uses all available data (release-agnostic).
         primary_module_vid: Optional module version ID of the module being exported.
             When provided, enables detection of cross-module dependencies.
+        module_code: Optional module code (e.g., "FINREP9") to specify the main module.
+        preferred_module_dependencies: Optional list of module codes to prefer when
+            multiple dependency scopes are possible.
 
     Returns:
         dict: {
@@ -143,6 +123,25 @@ def generate_enriched_ast(
             'enriched_ast': dict,  # Engine-ready AST with framework structure
             'error': str           # Error message if failed
         }
+
+    Example:
+        >>> # Single expression (backward compatible)
+        >>> result = generate_enriched_ast(
+        ...     "{tF_01.00, r0010, c0010}",
+        ...     database_path="data.db",
+        ...     release_code="4.2",
+        ... )
+        >>>
+        >>> # Multiple expressions
+        >>> result = generate_enriched_ast(
+        ...     [
+        ...         ("{tF_01.00, r0010, c0010} = 0", "v1234_m", None),
+        ...         ("{tF_01.00, r0020, c0010} > 0", "v1235_m", "{v_F_44_04}"),
+        ...     ],
+        ...     database_path="data.db",
+        ...     release_code="4.2",
+        ...     module_code="FINREP9",
+        ... )
     """
     generator = ASTGeneratorAPI(
         database_path=database_path,
@@ -150,13 +149,13 @@ def generate_enriched_ast(
         enable_semantic_validation=True
     )
     return generator.generate_enriched_ast(
-        expression=expression,
-        dpm_version=dpm_version,
-        operation_code=operation_code,
+        expressions=expressions,
+        release_code=release_code,
         table_context=table_context,
-        precondition=precondition,
         release_id=release_id,
         primary_module_vid=primary_module_vid,
+        module_code=module_code,
+        preferred_module_dependencies=preferred_module_dependencies,
     )
 
 
@@ -166,7 +165,7 @@ def enrich_ast_with_metadata(
     context: Optional[Dict[str, Any]],
     database_path: Optional[str] = None,
     connection_url: Optional[str] = None,
-    dpm_version: Optional[str] = None,
+    release_code: Optional[str] = None,
     operation_code: Optional[str] = None,
     precondition: Optional[str] = None,
     release_id: Optional[int] = None,
@@ -183,7 +182,7 @@ def enrich_ast_with_metadata(
         context: Context dict with table, rows, columns, sheets, default, interval
         database_path: Path to SQLite database
         connection_url: PostgreSQL connection URL (takes precedence)
-        dpm_version: DPM version code (e.g., "4.2")
+        release_code: DPM release code (e.g., "4.2")
         operation_code: Operation code (defaults to "default_code")
         precondition: Precondition variable reference (e.g., {v_F_44_04})
         release_id: Optional release ID to filter database lookups
@@ -201,7 +200,7 @@ def enrich_ast_with_metadata(
         ast_dict=ast_dict,
         expression=expression,
         context=context,
-        dpm_version=dpm_version,
+        release_code=release_code,
         operation_code=operation_code,
         precondition=precondition,
         release_id=release_id,

py_dpm/cli/main.py

@@ -61,41 +61,41 @@ def migrate_access(access_file: str):
     "--release-id", type=int, help="Release ID to use for validation", default=None
 )
 @click.option(
-    "--dpm-version",
+    "--release-code",
     type=str,
-    help="DPM Version (e.g. 4.2) to use for validation",
+    help="Release code (e.g. 4.2) to use for validation",
     default=None,
 )
-def semantic(expression: str, release_id: int, dpm_version: str):
+def semantic(expression: str, release_id: int, release_code: str):
     """
     Semantically analyses the input expression by applying the syntax validation, the operands checking, the data type
     validation and the structure validation
     :param expression: Expression to be analysed
     :param release_id: ID of the release used. If None, gathers the live release
-    :param dpm_version: Version code of the release used.
+    :param release_code: Version code of the release used.
     Used only in DPM-ML generation
     :return if Return_data is False, any Symbol, else data extracted from DB based on operands cell references
     """
 
-    if release_id is not None and dpm_version is not None:
-        raise click.UsageError("Cannot provide both --release-id and --dpm-version")
+    if release_id is not None and release_code is not None:
+        raise click.UsageError("Cannot provide both --release-id and --release-code")
 
     error_code = ""
     validation_type = STATUS_UNKNOWN
 
     semantic_api = SemanticAPI()
 
-    if dpm_version:
+    if release_code:
         from py_dpm.dpm.models import Release
 
         release_id = (
             semantic_api.session.query(Release.releaseid)
-            .filter(Release.code == dpm_version)
+            .filter(Release.code == release_code)
             .scalar()
         )
         if release_id is None:
             console.print(
-                f"Error: DPM version '{dpm_version}' not found.", style="bold red"
+                f"Error: Release code '{release_code}' not found.", style="bold red"
             )
             sys.exit(1)
 

py_dpm/dpm/models.py

@@ -720,16 +720,20 @@ class ModuleVersion(Base):
             release_id: Optional release ID to filter modules by release range
 
         Returns:
-            pandas DataFrame with columns: ModuleVID, TableVID (as VARIABLE_VID),
-            FromReferenceDate, ToReferenceDate, EndReleaseID
+            pandas DataFrame with columns: ModuleVID, TableVID (as variable_vid),
+            ModuleCode, VersionNumber, FromReferenceDate, ToReferenceDate,
+            StartReleaseID, EndReleaseID
         """
         if not tables_vids:
             return pd.DataFrame(
                 columns=[
                     "ModuleVID",
                     "variable_vid",
+                    "ModuleCode",
+                    "VersionNumber",
                     "FromReferenceDate",
                     "ToReferenceDate",
+                    "StartReleaseID",
                     "EndReleaseID",
                 ]
             )
@@ -738,8 +742,11 @@ 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(
@@ -759,16 +766,20 @@ class ModuleVersion(Base):
             )
 
         results = query.all()
-        return pd.DataFrame(
+        df = 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):
@@ -790,6 +801,8 @@ class ModuleVersion(Base):
                 columns=[
                     "ModuleVID",
                     "variable_vid",
+                    "ModuleCode",
+                    "VersionNumber",
                     "FromReferenceDate",
                     "ToReferenceDate",
                     "StartReleaseID",
@@ -804,6 +817,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"),
@@ -831,11 +846,13 @@ class ModuleVersion(Base):
             )
 
         results = query.all()
-        return pd.DataFrame(
+        df = pd.DataFrame(
             results,
             columns=[
                 "ModuleVID",
                 "variable_vid",
+                "ModuleCode",
+                "VersionNumber",
                 "FromReferenceDate",
                 "ToReferenceDate",
                 "StartReleaseID",
@@ -843,6 +860,7 @@ class ModuleVersion(Base):
                 "TableCode",
             ],
         )
+        return cls._apply_fallback_for_equal_dates(session, df)
 
     @classmethod
     def get_precondition_module_versions(
@@ -857,16 +875,21 @@ class ModuleVersion(Base):
             release_id: Optional release ID to filter modules by release range
 
         Returns:
-            pandas DataFrame with columns: ModuleVID, VariableVID (as VARIABLE_VID),
-            FromReferenceDate, ToReferenceDate, Code
+            pandas DataFrame with columns: ModuleVID, variable_vid (VariableVID),
+            ModuleCode, VersionNumber, FromReferenceDate, ToReferenceDate,
+            StartReleaseID, EndReleaseID, Code
         """
         if not precondition_items:
             return pd.DataFrame(
                 columns=[
                     "ModuleVID",
                     "variable_vid",
+                    "ModuleCode",
+                    "VersionNumber",
                     "FromReferenceDate",
                     "ToReferenceDate",
+                    "StartReleaseID",
+                    "EndReleaseID",
                     "Code",
                 ]
             )
@@ -875,8 +898,12 @@ 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)
@@ -899,16 +926,21 @@ class ModuleVersion(Base):
             )
 
         results = query.all()
-        return pd.DataFrame(
+        df = 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):
@@ -946,6 +978,176 @@ 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
+        # Convert to native Python int to avoid numpy.int64 issues with PostgreSQL
+        module_vids_needing_fallback = [
+            int(vid) for vid in rows_needing_fallback[module_vid_col].unique()
+        ]
+
+        # 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
+        # Skip versions that also have equal dates (ghost modules)
+        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:
+                    # Only use this version if it has different dates
+                    # (skip ghost modules where from == to)
+                    if mv.fromreferencedate != mv.toreferencedate:
+                        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"]:
+                # Convert to native Python int to match replacement_map keys
+                current_vid = int(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):
         """
@@ -1119,6 +1321,60 @@ 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"