pydpm_xl 0.1.10__py3-none-any.whl → 0.1.39rc24__py3-none-any.whl

py_dpm/AST/ASTConstructor.py

@@ -220,6 +220,9 @@ class ASTVisitor(dpm_xlParserVisitor):
         elif isinstance(ctx_list[2], dpm_xlParser.RenameExprContext):
             rename_nodes = self.visitRenameExpr(ctx_list[2])
             return RenameOp(operand=operand, rename_nodes=rename_nodes)
+        elif isinstance(ctx_list[2], dpm_xlParser.SubExprContext):
+            property_code, value = self.visitSubExpr(ctx_list[2])
+            return SubOp(operand=operand, property_code=property_code, value=value)
 
     def visitWhereExpr(self, ctx: dpm_xlParser.WhereExprContext):
         return self.visit(ctx.getChild(1))
@@ -241,6 +244,14 @@ class ASTVisitor(dpm_xlParserVisitor):
         new_name = self.visit(ctx_list[2])
         return RenameNode(old_name=old_name, new_name=new_name)
 
+    def visitSubExpr(self, ctx: dpm_xlParser.SubExprContext):
+        # SUB propertyCode EQ (literal | select | itemReference)
+        ctx_list = list(ctx.getChildren())
+        property_code = self.visit(ctx_list[1])  # propertyCode
+        # ctx_list[2] is EQ
+        value = self.visit(ctx_list[3])  # literal, select, or itemReference
+        return property_code, value
+
     def create_bin_op(self, ctx: dpm_xlParser.ExpressionContext):
         ctx_list = list(ctx.getChildren())
 

py_dpm/AST/ASTObjects.py

@@ -234,9 +234,11 @@ class VarID(AST):
         # If data has been populated (after operand checking), use that
         if hasattr(self, 'data') and self.data is not None:
             # Convert DataFrame to list of dictionaries
+            data_records = None
             try:
                 if hasattr(self.data, 'to_dict'):
-                    result['data'] = self.data.to_dict('records')
+                    data_records = self.data.to_dict('records')
+                    result['data'] = data_records
                 else:
                     result['data'] = self.data
             except Exception:
@@ -246,15 +248,43 @@ class VarID(AST):
                 except Exception:
                     result['data'] = str(self.data)
             result['table'] = self.table
-            result['interval'] = self.interval
+
+            # Interval handling: determine from data_type in data records
+            # According to DPM-XL spec, interval only applies to Number types
+            interval_value = False  # default
+
+            # First check if type attribute is set (from semantic validation)
+            if hasattr(self, 'type') and self.type is not None:
+                from py_dpm.DataTypes.ScalarTypes import Number
+                if isinstance(self.type, Number):
+                    interval_value = self.interval if self.interval is not None else False
+                else:
+                    interval_value = None
+            # Otherwise, infer from data_type in data records
+            elif data_records and len(data_records) > 0 and 'data_type' in data_records[0]:
+                data_type = data_records[0]['data_type']
+                # Map database data types to determine if numeric
+                # Numeric types: 'i' (integer), 'r' (decimal), 'm' (monetary), 'p' (percentage)
+                # Non-numeric types: 'b' (boolean), 's' (string), 'e' (enumeration/item), etc.
+                numeric_data_types = {'i', 'r', 'm', 'p', 'INT', 'DEC', 'MON', 'PER'}
+                if data_type in numeric_data_types:
+                    interval_value = self.interval if self.interval is not None else False
+                else:
+                    interval_value = None
+            else:
+                # No type info available - use explicit interval or default to False
+                interval_value = self.interval if self.interval is not None else False
+
+            result['interval'] = interval_value
         else:
             # Use original structure for unexpanded VarID
+            # When there's no data (no semantic validation), default interval to False
             result.update({
                 'table': self.table,
                 'rows': self.rows,
                 'cols': self.cols,
                 'sheets': self.sheets,
-                'interval': self.interval,
+                'interval': self.interval if self.interval is not None else False,
                 'default': self.default,
                 'is_table_group': self.is_table_group
             })
@@ -710,6 +740,40 @@ class RenameNode(AST):
         }
 
 
+class SubOp(AST):
+    """
+    AST Object for the Sub operator. Filters a recordset based on a property substitution.
+
+    :parameter operand: Recordset to be filtered
+    :parameter property_code: Property code to substitute
+    :parameter value: Value to substitute (can be a literal, select, or itemReference)
+    """
+
+    def __init__(self, operand, property_code, value):
+        super().__init__()
+        self.operand = operand
+        self.property_code = property_code
+        self.value = value
+
+    def __str__(self):
+        return "<AST(name='{name}', operand={operand}, property_code='{property_code}', value={value})>".format(
+            name=self.__class__.__name__,
+            operand=self.operand,
+            property_code=self.property_code,
+            value=self.value
+        )
+
+    __repr__ = __str__
+
+    def toJSON(self):
+        return {
+            'class_name': self.__class__.__name__,
+            'operand': self.operand,
+            'property_code': self.property_code,
+            'value': self.value
+        }
+
+
 class PropertyReference(AST):
 
     def __init__(self, code):

py_dpm/AST/ASTTemplate.py

@@ -1,5 +1,5 @@
 from py_dpm.AST.ASTObjects import AggregationOp, BinOp, ComplexNumericOp, CondExpr, Constant, Dimension, FilterOp, GetOp, GroupingClause, \
-    OperationRef, ParExpr, PersistentAssignment, PreconditionItem, PropertyReference, RenameOp, Scalar, Set, Start, TemporaryAssignment, \
+    OperationRef, ParExpr, PersistentAssignment, PreconditionItem, PropertyReference, RenameOp, Scalar, Set, Start, SubOp, TemporaryAssignment, \
     TimeShiftOp, UnaryOp, VarID, VarRef, WhereClauseOp, WithExpression
 from py_dpm.AST.ASTVisitor import NodeVisitor
 
@@ -84,6 +84,10 @@ class ASTTemplate(NodeVisitor):
     def visit_GetOp(self, node: GetOp):
         self.visit(node.operand)
 
+    def visit_SubOp(self, node: SubOp):
+        self.visit(node.operand)
+        self.visit(node.value)
+
     def visit_PreconditionItem(self, node: PreconditionItem):
         pass
 

py_dpm/AST/MLGeneration.py

@@ -400,6 +400,18 @@ class MLGeneration(ASTTemplate):
         )
         self.session.add(new_operand_ref)
 
+    def visit_SubOp(self, node: SubOp):
+        setattr(node, "op", "sub")
+        operand_node = self.create_operation_node(node)
+        setattr(node.operand, "parent", operand_node)
+        setattr(node.operand, "argument", "operand")
+        self.visit(node.operand)
+
+        # Visit the value (can be literal, select, or itemReference)
+        setattr(node.value, "parent", operand_node)
+        setattr(node.value, "argument", "value")
+        self.visit(node.value)
+
     def visit_PreconditionItem(self, node: PreconditionItem):
         operand_node = self.create_operation_node(node, is_leaf=True)
         operand_reference = "PreconditionItem"  # "$_{}".format(node.value)