pydpm_xl 0.1.39rc32__py3-none-any.whl → 0.2.1__py3-none-any.whl

py_dpm/{OperationScopes/OperationScopeService.py → dpm_xl/utils/scopes_calculator.py}

@@ -5,10 +5,10 @@ from itertools import product
 import numpy
 import pandas as pd
 
-from py_dpm.Exceptions import exceptions
-from py_dpm.models import ModuleVersion, OperationScope, OperationScopeComposition
-from py_dpm.Utils.tokens import VARIABLE_VID, WARNING_SEVERITY
-from py_dpm.db_utils import get_session
+from py_dpm.exceptions import exceptions
+from py_dpm.dpm.models import ModuleVersion, OperationScope, OperationScopeComposition
+from py_dpm.dpm_xl.utils.tokens import VARIABLE_VID, WARNING_SEVERITY
+from py_dpm.dpm.utils import get_session
 
 FROM_REFERENCE_DATE = "FromReferenceDate"
 TO_REFERENCE_DATE = "ToReferenceDate"
@@ -17,7 +17,9 @@ TABLE_VID = "TableVID"
 
 
 def _check_if_existing(composition_modules, existing_scopes):
-    existing_scopes = existing_scopes[existing_scopes[MODULE_VID].isin(composition_modules)][MODULE_VID].tolist()
+    existing_scopes = existing_scopes[
+        existing_scopes[MODULE_VID].isin(composition_modules)
+    ][MODULE_VID].tolist()
     if len(existing_scopes) and set(composition_modules) == set(existing_scopes):
         return True
     return False
@@ -36,7 +38,13 @@ class OperationScopeService:
 
         self.operation_scopes = []
 
-    def calculate_operation_scope(self, tables_vids: list, precondition_items: list, release_id=None, table_codes: list = None):
+    def calculate_operation_scope(
+        self,
+        tables_vids: list,
+        precondition_items: list,
+        release_id=None,
+        table_codes: list = None,
+    ):
         """
         Calculate OperationScope and OperationScopeComposition tables for an operation version, taking as input
         a list with the operation table version ids in order to calculate the module versions involved in the operation
@@ -51,16 +59,22 @@ class OperationScopeService:
             release_id = ModuleVersion.get_last_release(self.session)
 
         modules_info_dataframe = self.extract_module_info(
-            tables_vids=tables_vids, precondition_items=precondition_items, release_id=release_id, table_codes=table_codes)  # We extract all the releases from the database
+            tables_vids=tables_vids,
+            precondition_items=precondition_items,
+            release_id=release_id,
+            table_codes=table_codes,
+        )  # We extract all the releases from the database
         if modules_info_dataframe is None:
             return [], []
 
         modules_vids = modules_info_dataframe[MODULE_VID].unique().tolist()
         if len(modules_info_dataframe) == 1:
             module_vid = modules_vids[0]
-            from_date = modules_info_dataframe['FromReferenceDate'].values[0]
+            from_date = modules_info_dataframe["FromReferenceDate"].values[0]
             operation_scope = self.create_operation_scope(from_date)
-            self.create_operation_scope_composition(operation_scope=operation_scope, module_vid=module_vid)
+            self.create_operation_scope_composition(
+                operation_scope=operation_scope, module_vid=module_vid
+            )
         else:
             intra_modules = []
             cross_modules = {}
@@ -70,20 +84,32 @@ class OperationScopeService:
                 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)
+                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 = group_df['TableCode'].unique().tolist() if 'TableCode' in group_df.columns else []
+                    table_codes_in_module = (
+                        group_df["TableCode"].unique().tolist()
+                        if "TableCode" in group_df.columns
+                        else []
+                    )
 
                     # Get module lifecycle info
-                    start_release = group_df['StartReleaseID'].values[0] if 'StartReleaseID' in group_df.columns else None
-                    end_release = group_df['EndReleaseID'].values[0]
+                    start_release = (
+                        group_df["StartReleaseID"].values[0]
+                        if "StartReleaseID" in group_df.columns
+                        else None
+                    )
+                    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))
+                    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
@@ -91,7 +117,9 @@ class OperationScopeService:
                         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
+                        target_dict = (
+                            starting_modules if is_starting else ending_modules
+                        )
                         for table_code in table_codes_in_module:
                             if table_code not in target_dict:
                                 target_dict[table_code] = []
@@ -99,9 +127,9 @@ class OperationScopeService:
 
                 # Process cross-module scopes separately for each generation
                 if starting_modules:
-                    cross_modules['_starting'] = starting_modules
+                    cross_modules["_starting"] = starting_modules
                 if ending_modules:
-                    cross_modules['_ending'] = ending_modules
+                    cross_modules["_ending"] = ending_modules
             else:
                 # Original logic for table VIDs
                 unique_operands_number = len(tables_vids) + len(precondition_items)
@@ -120,27 +148,52 @@ class OperationScopeService:
 
             if cross_modules:
                 # When using table_codes with lifecycle grouping
-                if table_codes and ('_starting' in cross_modules or '_ending' in cross_modules):
+                if table_codes and (
+                    "_starting" in cross_modules or "_ending" in cross_modules
+                ):
                     # Process each generation separately
-                    if '_starting' in cross_modules:
-                        self.process_cross_module(cross_modules=cross_modules['_starting'], modules_dataframe=modules_info_dataframe)
-                    if '_ending' in cross_modules:
-                        self.process_cross_module(cross_modules=cross_modules['_ending'], modules_dataframe=modules_info_dataframe)
+                    if "_starting" in cross_modules:
+                        self.process_cross_module(
+                            cross_modules=cross_modules["_starting"],
+                            modules_dataframe=modules_info_dataframe,
+                        )
+                    if "_ending" in cross_modules:
+                        self.process_cross_module(
+                            cross_modules=cross_modules["_ending"],
+                            modules_dataframe=modules_info_dataframe,
+                        )
                 # Legacy table_codes without lifecycle grouping
                 elif table_codes:
-                    self.process_cross_module(cross_modules=cross_modules, modules_dataframe=modules_info_dataframe)
-                elif set(cross_modules.keys())==set(tables_vids):
-                    self.process_cross_module(cross_modules=cross_modules, modules_dataframe=modules_info_dataframe)
+                    self.process_cross_module(
+                        cross_modules=cross_modules,
+                        modules_dataframe=modules_info_dataframe,
+                    )
+                elif set(cross_modules.keys()) == set(tables_vids):
+                    self.process_cross_module(
+                        cross_modules=cross_modules,
+                        modules_dataframe=modules_info_dataframe,
+                    )
                 else:
                     # add the missing table_vids to cross_modules
                     for table_vid in tables_vids:
                         if table_vid not in cross_modules:
-                            cross_modules[table_vid] =  modules_info_dataframe[modules_info_dataframe[VARIABLE_VID]==table_vid][MODULE_VID].unique().tolist()
-                    self.process_cross_module(cross_modules=cross_modules, modules_dataframe=modules_info_dataframe)
+                            cross_modules[table_vid] = (
+                                modules_info_dataframe[
+                                    modules_info_dataframe[VARIABLE_VID] == table_vid
+                                ][MODULE_VID]
+                                .unique()
+                                .tolist()
+                            )
+                    self.process_cross_module(
+                        cross_modules=cross_modules,
+                        modules_dataframe=modules_info_dataframe,
+                    )
 
         return self.get_scopes_with_status()
 
-    def extract_module_info(self, tables_vids, precondition_items, release_id=None, table_codes=None):
+    def extract_module_info(
+        self, tables_vids, precondition_items, release_id=None, table_codes=None
+    ):
         """
         Extracts modules information of tables version ids and preconditions from database and
         joins them in a single dataframe
@@ -156,14 +209,16 @@ class OperationScopeService:
         # If table_codes are provided, query by codes to get ALL versions
         if table_codes and len(table_codes):
             tables_modules_info_dataframe = ModuleVersion.get_from_table_codes(
-                session=self.session, table_codes=table_codes, release_id=release_id)
+                session=self.session, table_codes=table_codes, release_id=release_id
+            )
             if tables_modules_info_dataframe.empty:
                 raise exceptions.SemanticError("1-13", table_codes=table_codes)
             modules_info_lst.append(tables_modules_info_dataframe)
         # Otherwise use the traditional table VID approach
         elif len(tables_vids):
             tables_modules_info_dataframe = ModuleVersion.get_from_tables_vids(
-                session=self.session, tables_vids=tables_vids, release_id=release_id)
+                session=self.session, tables_vids=tables_vids, release_id=release_id
+            )
             if tables_modules_info_dataframe.empty:
                 missing_table_modules = tables_vids
             else:
@@ -171,23 +226,35 @@ class OperationScopeService:
                 missing_table_modules = set(tables_vids).difference(set(modules_tables))
 
             if len(missing_table_modules):
-                raise exceptions.SemanticError("1-13", table_version_ids=missing_table_modules)
+                raise exceptions.SemanticError(
+                    "1-13", table_version_ids=missing_table_modules
+                )
 
             modules_info_lst.append(tables_modules_info_dataframe)
 
         if len(precondition_items):
-            preconditions_modules_info_dataframe = ModuleVersion.get_precondition_module_versions(session=self.session,
-                                                                                                  precondition_items=precondition_items,
-                                                                                                  release_id=release_id)
+            preconditions_modules_info_dataframe = (
+                ModuleVersion.get_precondition_module_versions(
+                    session=self.session,
+                    precondition_items=precondition_items,
+                    release_id=release_id,
+                )
+            )
 
             if preconditions_modules_info_dataframe.empty:
                 missing_precondition_modules = precondition_items
             else:
-                modules_preconditions = preconditions_modules_info_dataframe['Code'].tolist()
-                missing_precondition_modules = set(precondition_items).difference(set(modules_preconditions))
+                modules_preconditions = preconditions_modules_info_dataframe[
+                    "Code"
+                ].tolist()
+                missing_precondition_modules = set(precondition_items).difference(
+                    set(modules_preconditions)
+                )
 
             if missing_precondition_modules:
-                raise exceptions.SemanticError("1-14", precondition_items=missing_precondition_modules)
+                raise exceptions.SemanticError(
+                    "1-14", precondition_items=missing_precondition_modules
+                )
 
             modules_info_lst.append(preconditions_modules_info_dataframe)
 
@@ -201,9 +268,13 @@ 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]
+            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)
+            self.create_operation_scope_composition(
+                operation_scope=operation_scope, module_vid=module_vid
+            )
 
     def process_cross_module(self, cross_modules, modules_dataframe):
         """
@@ -211,12 +282,18 @@ class OperationScopeService:
         :param cross_modules: dictionary with table version ids as key and its module version ids as values
         :param modules_dataframe: dataframe with modules data
         """
-        modules_dataframe[FROM_REFERENCE_DATE] = pd.to_datetime(modules_dataframe[FROM_REFERENCE_DATE], format='mixed', dayfirst=True)
-        modules_dataframe[TO_REFERENCE_DATE] = pd.to_datetime(modules_dataframe[TO_REFERENCE_DATE], format='mixed', dayfirst=True)
+        modules_dataframe[FROM_REFERENCE_DATE] = pd.to_datetime(
+            modules_dataframe[FROM_REFERENCE_DATE], format="mixed", dayfirst=True
+        )
+        modules_dataframe[TO_REFERENCE_DATE] = pd.to_datetime(
+            modules_dataframe[TO_REFERENCE_DATE], format="mixed", dayfirst=True
+        )
 
         values = cross_modules.values()
         for combination in product(*values):
-            combination_info = modules_dataframe[modules_dataframe[MODULE_VID].isin(combination)]
+            combination_info = modules_dataframe[
+                modules_dataframe[MODULE_VID].isin(combination)
+            ]
             from_dates = combination_info[FROM_REFERENCE_DATE].values
             to_dates = combination_info[TO_REFERENCE_DATE].values
             ref_from_date = from_dates.max()
@@ -224,7 +301,9 @@ class OperationScopeService:
 
             is_valid_combination = True
             for from_date, to_date in zip(from_dates, to_dates):
-                if to_date < ref_from_date or ((not pd.isna(ref_to_date)) and from_date > ref_to_date):
+                if to_date < ref_from_date or (
+                    (not pd.isna(ref_to_date)) and from_date > ref_to_date
+                ):
                     is_valid_combination = False
 
             if is_valid_combination:
@@ -234,7 +313,9 @@ class OperationScopeService:
             operation_scope = self.create_operation_scope(from_submission_date)
             combination = set(combination)
             for module in combination:
-                self.create_operation_scope_composition(operation_scope=operation_scope, module_vid=module)
+                self.create_operation_scope_composition(
+                    operation_scope=operation_scope, module_vid=module
+                )
 
     def create_operation_scope(self, submission_date):
         """
@@ -242,9 +323,9 @@ class OperationScopeService:
         """
         if not pd.isnull(submission_date):
             if isinstance(submission_date, numpy.datetime64):
-                submission_date = str(submission_date).split('T')[0]
+                submission_date = str(submission_date).split("T")[0]
             if isinstance(submission_date, str):
-                submission_date = datetime.strptime(submission_date, '%Y-%m-%d').date()
+                submission_date = datetime.strptime(submission_date, "%Y-%m-%d").date()
             elif isinstance(submission_date, datetime):
                 submission_date = submission_date.date()
         else:
@@ -254,7 +335,7 @@ class OperationScopeService:
             isactive=1,  # Use 1 instead of True for PostgreSQL bigint compatibility
             severity=WARNING_SEVERITY,
             fromsubmissiondate=submission_date,
-            rowguid=str(uuid.uuid4())
+            rowguid=str(uuid.uuid4()),
         )
         self.session.add(operation_scope)
         return operation_scope
@@ -268,7 +349,7 @@ class OperationScopeService:
         operation_scope_composition = OperationScopeComposition(
             operation_scope=operation_scope,
             modulevid=module_vid,
-            rowguid=str(uuid.uuid4())
+            rowguid=str(uuid.uuid4()),
         )
         self.session.add(operation_scope_composition)
 
@@ -279,16 +360,23 @@ class OperationScopeService:
         """
         existing_scopes = []
         new_scopes = []
-        operation_scopes = [o for o in self.session.new if isinstance(o, OperationScope)]
-        database_scopes = OperationScopeComposition.get_from_operation_version_id(self.session,
-                                                                                  self.operation_version_id)
+        operation_scopes = [
+            o for o in self.session.new if isinstance(o, OperationScope)
+        ]
+        database_scopes = OperationScopeComposition.get_from_operation_version_id(
+            self.session, self.operation_version_id
+        )
         if database_scopes.empty:
             new_scopes = operation_scopes
         else:
             for scope in operation_scopes:
-                composition_modules = [scope_comp.modulevid for scope_comp in scope.operation_scope_compositions]
-                result = database_scopes.groupby('OperationScopeID').filter(
-                    lambda x: _check_if_existing(composition_modules, x))
+                composition_modules = [
+                    scope_comp.modulevid
+                    for scope_comp in scope.operation_scope_compositions
+                ]
+                result = database_scopes.groupby("OperationScopeID").filter(
+                    lambda x: _check_if_existing(composition_modules, x)
+                )
 
                 if not result.empty:
                     existing_scopes.append(scope)
@@ -298,10 +386,12 @@ class OperationScopeService:
                     existing_previous = False
                     for vid in composition_modules:
                         if id not in existing_scopes:
-                            aux = ModuleVersion.get_module_version_by_vid(session=self.session, vid=vid)
+                            aux = ModuleVersion.get_module_version_by_vid(
+                                session=self.session, vid=vid
+                            )
                             if aux.empty:
                                 continue
-                            if aux['EndReleaseID'][0] is not None:
+                            if aux["EndReleaseID"][0] is not None:
                                 existing_previous = True
                                 break
 

py_dpm/{Utils/ast_serialization.py → dpm_xl/utils/serialization.py}

@@ -3,7 +3,7 @@
 AST to JSON serialization utilities for pyDPM
 """
 
-from py_dpm.AST.ASTVisitor import NodeVisitor
+from py_dpm.dpm_xl.ast.visitor import NodeVisitor
 
 class ASTToJSONVisitor(NodeVisitor):
     """Visitor that converts AST nodes to JSON using the existing visitor pattern infrastructure."""
@@ -542,10 +542,9 @@ class ASTToJSONVisitor(NodeVisitor):
 
         return result
 
-
 # Original serialization functions (kept for backward compatibility)
 import json
-from py_dpm.AST import ASTObjects
+from py_dpm.dpm_xl.ast import nodes as ASTObjects
 
 
 def expand_with_expression(node):
@@ -759,4 +758,4 @@ def ast_from_json_string(json_str):
         AST object instance
     """
     data = json.loads(json_str)
-    return deserialize_ast(data)
+    return deserialize_ast(data)

py_dpm/dpm_xl/validation/__init__.py

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

py_dpm/{Utils/ValidationsGenerationUtils.py → dpm_xl/validation/generation_utils.py}

@@ -3,11 +3,10 @@ from itertools import groupby
 
 import pandas as pd
 
-from py_dpm.Utils.tokens import CELL_COMPONENTS, COLUMN, COLUMN_CODE, EXISTENCE_REPORT, \
+from py_dpm.dpm_xl.utils.tokens import CELL_COMPONENTS, COLUMN, COLUMN_CODE, EXISTENCE_REPORT, \
     HIERARCHY_REPORT, ROW, ROW_CODE, SHEET, SHEET_CODE, \
     SIGN_REPORT
-from py_dpm.ValidationsGeneration.Utils import ExternalDataExistence, ExternalDataHierarchies, \
-    ExternalDataSign
+# from py_dpm.ValidationsGeneration.Utils import ExternalDataExistence, ExternalDataHierarchies, ExternalDataSign
 
 
 def from_generate_to_response(validations):

py_dpm/{ValidationsGeneration/PropertiesConstraintsProcessor.py → dpm_xl/validation/property_constraints.py}

@@ -1,12 +1,25 @@
 import pandas as pd
 
-from py_dpm.AST.ASTObjects import AggregationOp, BinOp, ComplexNumericOp, CondExpr, FilterOp, GetOp, PropertyReference, RenameOp, Scalar, \
-    TimeShiftOp, UnaryOp, VarID, WhereClauseOp
-from py_dpm.AST.ASTTemplate import ASTTemplate
-from py_dpm.Exceptions import exceptions
-from py_dpm.models import ItemCategory, ViewDatapoints
-from py_dpm.Utils.ValidationsGenerationUtils import ValidationsGenerationUtils
-from py_dpm.Utils.tokens import *
+from py_dpm.dpm_xl.ast.nodes import (
+    AggregationOp,
+    BinOp,
+    ComplexNumericOp,
+    CondExpr,
+    FilterOp,
+    GetOp,
+    PropertyReference,
+    RenameOp,
+    Scalar,
+    TimeShiftOp,
+    UnaryOp,
+    VarID,
+    WhereClauseOp,
+)
+from py_dpm.dpm_xl.ast.template import ASTTemplate
+from py_dpm.exceptions import exceptions
+from py_dpm.dpm.models import ItemCategory, ViewDatapoints
+from py_dpm.dpm_xl.validation.generation_utils import ValidationsGenerationUtils
+from py_dpm.dpm_xl.utils.tokens import *
 
 ALLOWED_OPERATORS = [MATCH, IN, EQ, NEQ, GT, GTE, LT, LTE, LENGTH, CONCATENATE]
 
@@ -41,7 +54,9 @@ class PropertiesConstraintsChecker(ASTTemplate):
             pass  # signature should have : to be a property constraint
         signature = node.code
         # look for property in models
-        property_query = ItemCategory.get_property_from_signature(signature, self.session)
+        property_query = ItemCategory.get_property_from_signature(
+            signature, self.session
+        )
         if property_query is None:
             raise exceptions.SemanticError("5-1-4", ref=signature)
         self.has_property = True
@@ -55,13 +70,17 @@ class PropertiesConstraintsChecker(ASTTemplate):
         if not self.has_property:
             if getattr(node, "scalar_type", None) == "Item":
                 # go to models and check if item exists and is a property
-                property_query = ItemCategory.get_property_from_signature(signature, self.session)
+                property_query = ItemCategory.get_property_from_signature(
+                    signature, self.session
+                )
                 if property_query:
                     self.has_property = True
                 # other assumption could be always first scalar is a property but this is not true
                 # self.has_property = True
         else:
-            other_property_query = ItemCategory.get_property_from_signature(signature, self.session)
+            other_property_query = ItemCategory.get_property_from_signature(
+                signature, self.session
+            )
             if other_property_query:
                 raise exceptions.SemanticError("5-1-2")
 
@@ -96,12 +115,21 @@ class PropertiesConstraintsProcessor(ASTTemplate):
             raise exceptions.SemanticError("5-1-1")
 
         item_category = ItemCategory.get_property_from_signature(
-                signature=self.property_constraint, session=self.session, release_id=self.release_id)
+            signature=self.property_constraint,
+            session=self.session,
+            release_id=self.release_id,
+        )
         if item_category is None:
-            raise exceptions.SemanticError("1-7", property_code=self.property_constraint)
-        variables: pd.DataFrame = ViewDatapoints.get_from_property(self.session, item_category.ItemID, self.release_id)
-        for table_code, group_df in variables.groupby(['table_code']):
-            datapoints = ViewDatapoints.get_table_data(session=self.session, table=str(table_code))
+            raise exceptions.SemanticError(
+                "1-7", property_code=self.property_constraint
+            )
+        variables: pd.DataFrame = ViewDatapoints.get_from_property(
+            self.session, item_category.ItemID, self.release_id
+        )
+        for table_code, group_df in variables.groupby(["table_code"]):
+            datapoints = ViewDatapoints.get_table_data(
+                session=self.session, table=str(table_code)
+            )
             self.generate_expressions(table_code, group_df, datapoints)
 
     def generate_expressions(self, table_code, data, datapoints_table):
@@ -111,12 +139,17 @@ class PropertiesConstraintsProcessor(ASTTemplate):
         :param data: dataframe with operand datapoints
         :param datapoints_table: table datapoints
         """
-        groups = ValidationsGenerationUtils.group_cells(datapoints_variable=data,
-                                                        datapoints_table=datapoints_table)
+        groups = ValidationsGenerationUtils.group_cells(
+            datapoints_variable=data, datapoints_table=datapoints_table
+        )
         for rows, cols, sheets in groups:
-            operand = ValidationsGenerationUtils.write_cell(table_code, rows, cols, sheets)
+            operand = ValidationsGenerationUtils.write_cell(
+                table_code, rows, cols, sheets
+            )
             new_expression = self.expression
-            new_expression = new_expression.replace(f"[{self.property_constraint}]", operand)
+            new_expression = new_expression.replace(
+                f"[{self.property_constraint}]", operand
+            )
             self.new_expressions.append(new_expression)
 
     def create_validation(self, expression, status):
@@ -133,7 +166,7 @@ class PropertiesConstraintsProcessor(ASTTemplate):
         return {
             VALIDATION_CODE: validation_code,
             EXPRESSION: expression,
-            STATUS: status
+            STATUS: status,
         }
 
     def visit_PropertyReference(self, node: PropertyReference):
@@ -148,7 +181,9 @@ class PropertiesConstraintsProcessor(ASTTemplate):
     def visit_Scalar(self, node: Scalar):
         if getattr(node, "scalar_type", None) == "Item":
             signature = node.item
-            property_query = ItemCategory.get_property_from_signature(signature, self.session)
+            property_query = ItemCategory.get_property_from_signature(
+                signature, self.session
+            )
             if property_query:
                 if not self.property_constraint:
                     self.property_constraint = signature

py_dpm/{ValidationsGeneration/auxiliary_functions.py → dpm_xl/validation/utils.py}

@@ -1,8 +1,8 @@
 import numpy as np
 import pandas as pd
 
-from py_dpm.Utils.ValidationsGenerationUtils import ValidationsGenerationUtils
-from py_dpm.Utils.tokens import *
+from py_dpm.dpm_xl.validation.generation_utils import ValidationsGenerationUtils
+from py_dpm.dpm_xl.utils.tokens import *
 
 
 def generate_context_structure(lst: list, group_df: pd.DataFrame):