vtlengine 1.1rc2__py3-none-any.whl → 1.2.0__py3-none-any.whl

vtlengine/AST/ASTTemplate.py

@@ -186,8 +186,6 @@ class ASTTemplate(NodeVisitor):
 
             return node.value
         """
-        if node.value in self.datasets:
-            return self.datasets[node.value]
         return node.value
 
     def visit_Optional(self, node: AST.Optional) -> AST.AST:
@@ -329,6 +327,18 @@ class ASTTemplate(NodeVisitor):
             self.visit(case.thenOp)
         self.visit(node.elseOp)
 
+    def visit_CaseObj(self, node: AST.CaseObj) -> Any:
+        """
+        CaseObj: (condition, thenOp)
+
+        Basic usage:
+
+            self.visit(node.condition)
+            self.visit(node.thenOp)
+        """
+        self.visit(node.condition)
+        self.visit(node.thenOp)
+
     def visit_Validation(self, node: AST.Validation) -> Any:
         """
         Validation: (op, validation, params, inbalance, invalid)
@@ -505,6 +515,12 @@ class ASTTemplate(NodeVisitor):
         for child in node.operands:
             self.visit(child)
 
+    def visit_ParFunction(self, node: AST.ParFunction) -> None:
+        """
+        ParFunction: (operand)
+        """
+        self.visit(node.operand)
+
     def visit_NoOp(self, node: AST.NoOp) -> None:  # pylint: disable=unused-argument
         """
         NoOp: ()
@@ -526,3 +542,13 @@ class ASTTemplate(NodeVisitor):
         """
         for param in node.params:
             self.visit(param)
+
+    def visit_Windowing(self, node: AST.Windowing) -> None:
+        """
+        Windowing: (type_, start, start_mode, stop, stop_mode)
+        """
+
+    def visit_Comment(self, node: AST.Comment) -> None:
+        """
+        Comment: (value)
+        """

vtlengine/AST/DAG/__init__.py

@@ -32,8 +32,8 @@ from vtlengine.AST import (
     VarID,
 )
 from vtlengine.AST.ASTTemplate import ASTTemplate
-from vtlengine.AST.DAG._words import DELETE, GLOBAL, INPUTS, INSERT, OUTPUTS, PERSISTENT
-from vtlengine.AST.Grammar.tokens import AS, MEMBERSHIP, TO
+from vtlengine.AST.DAG._words import DELETE, GLOBAL, INPUTS, INSERT, OUTPUTS, PERSISTENT, UNKNOWN
+from vtlengine.AST.Grammar.tokens import AS, DROP, KEEP, MEMBERSHIP, RENAME, TO
 from vtlengine.Exceptions import SemanticError
 
 
@@ -61,6 +61,8 @@ class DAGAnalyzer(ASTTemplate):
     inputs: Optional[list] = None
     outputs: Optional[list] = None
     persistent: Optional[list] = None
+    unknown_variables: Optional[list] = None
+    unknown_variables_statement: Optional[list] = None
 
     def __post_init__(self):
         self.dependencies = {}
@@ -72,6 +74,8 @@ class DAGAnalyzer(ASTTemplate):
         self.outputs = []
         self.persistent = []
         self.alias = []
+        self.unknown_variables = []
+        self.unknown_variables_statement = []
 
     @classmethod
     def ds_structure(cls, ast: AST):
@@ -85,10 +89,13 @@ class DAGAnalyzer(ASTTemplate):
         all_output = []
         global_inputs = []
         inserted = []
+        persistent_datasets = []
         for key, statement in self.dependencies.items():
             outputs = statement[OUTPUTS]
             persistent = statement[PERSISTENT]
             reference = outputs + persistent
+            if len(persistent) == 1 and persistent[0] not in persistent_datasets:
+                persistent_datasets.append(persistent[0])
             deletion_key = key
             all_output.append(reference[0])
             for subKey, subStatement in self.dependencies.items():
@@ -127,10 +134,11 @@ class DAGAnalyzer(ASTTemplate):
                         statements[INSERT][key] = [element]
 
         statements[GLOBAL] = global_inputs
+        statements[PERSISTENT] = persistent_datasets
         return statements
 
     @classmethod
-    def createDAG(cls, ast: AST):
+    def createDAG(cls, ast: Start):
         """ """
         # Visit AST.
         dag = cls()
@@ -143,6 +151,11 @@ class DAGAnalyzer(ASTTemplate):
             # Create output dict.
             if len(dag.edges) != 0:
                 dag.sortAST(ast)
+            else:
+                MLStatements: list = [
+                    ML for ML in ast.children if not isinstance(ML, (HRuleset, DPRuleset, Operator))
+                ]
+                dag.check_overwriting(MLStatements)
             return dag
 
         except nx.NetworkXUnfeasible as error:
@@ -167,7 +180,7 @@ class DAGAnalyzer(ASTTemplate):
         """ """
         # For each vertex
         for key, statement in self.dependencies.items():
-            output = statement[OUTPUTS] + statement[PERSISTENT]
+            output = statement[OUTPUTS] + statement[PERSISTENT] + statement[UNKNOWN]
             # If the statement has no := or -> symbol there is no vertex to add.
             if len(output) != 0:
                 self.vertex[key] = output[0]
@@ -236,12 +249,15 @@ class DAGAnalyzer(ASTTemplate):
         inputs = list(set(self.inputs))
         outputs = list(set(self.outputs))
         persistent = list(set(self.persistent))
+        unknown = list(set(self.unknown_variables_statement))
 
         # Remove inputs that are outputs of some statement.
         inputsF = [inputf for inputf in inputs if inputf not in outputs]
 
-        dict_ = {INPUTS: inputsF, OUTPUTS: outputs, PERSISTENT: persistent}
-
+        dict_ = {INPUTS: inputsF, OUTPUTS: outputs, PERSISTENT: persistent, UNKNOWN: unknown}
+        for variable in self.unknown_variables_statement:
+            if variable not in self.unknown_variables:
+                self.unknown_variables.append(variable)
         return dict_
 
     """______________________________________________________________________________________
@@ -284,6 +300,19 @@ class DAGAnalyzer(ASTTemplate):
                 self.inputs = []
                 self.outputs = []
                 self.persistent = []
+                self.unknown_variables_statement = []
+        aux = copy.copy(self.unknown_variables)
+        for variable in aux:
+            for _number_of_statement, dependency in self.dependencies.items():
+                if variable in dependency[OUTPUTS]:
+                    if variable in self.unknown_variables:
+                        self.unknown_variables.remove(variable)
+                    for _number_of_statement, dependency in self.dependencies.items():
+                        if variable in dependency[UNKNOWN]:
+                            dependency[UNKNOWN].remove(variable)
+                            dependency[INPUTS].append(variable)
+                        if variable not in self.inputs:
+                            self.inputs.append(variable)
 
     def visit_Assignment(self, node: Assignment) -> None:
         if self.isFirstAssignment:
@@ -301,6 +330,8 @@ class DAGAnalyzer(ASTTemplate):
 
     def visit_RegularAggregation(self, node: RegularAggregation) -> None:
         self.visit(node.dataset)
+        if node.op in [KEEP, DROP, RENAME]:
+            return
         for child in node.children:
             self.isFromRegularAggregation = True
             self.visit(child)
@@ -322,6 +353,13 @@ class DAGAnalyzer(ASTTemplate):
     def visit_VarID(self, node: VarID) -> None:
         if (not self.isFromRegularAggregation or self.isDataset) and node.value not in self.alias:
             self.inputs.append(node.value)
+        elif (
+            self.isFromRegularAggregation
+            and node.value not in self.alias
+            and not self.isDataset
+            and node.value not in self.unknown_variables_statement
+        ):
+            self.unknown_variables_statement.append(node.value)
 
     def visit_Identifier(self, node: Identifier) -> None:
         if node.kind == "DatasetID" and node.value not in self.alias:

vtlengine/AST/DAG/_words.py

@@ -7,3 +7,4 @@ INPUTS = "inputs"
 OUTPUTS = "outputs"
 PERSISTENT = "persistent"
 STATEMENT_ = "statement"
+UNKNOWN = "unknown_variables"

vtlengine/AST/Grammar/Vtl.g4

@@ -219,11 +219,11 @@ timeOperators:
     | YEAR_OP LPAREN expr RPAREN                                                # yearAtom
     | MONTH_OP LPAREN expr RPAREN                                               # monthAtom
     | DAYOFMONTH LPAREN expr RPAREN                                             # dayOfMonthAtom
-    | DAYOFYEAR LPAREN expr RPAREN                                              # datOfYearAtom
+    | DAYOFYEAR LPAREN expr RPAREN                                              # dayOfYearAtom
     | DAYTOYEAR LPAREN expr RPAREN                                              # dayToYearAtom
     | DAYTOMONTH LPAREN expr RPAREN                                             # dayToMonthAtom
-    | YEARTODAY LPAREN expr RPAREN                                              # yearTodayAtom
-    | MONTHTODAY LPAREN expr RPAREN                                             # monthTodayAtom
+    | YEARTODAY LPAREN expr RPAREN                                              # yearToDayAtom
+    | MONTHTODAY LPAREN expr RPAREN                                             # monthToDayAtom
 ;
 
 timeOperatorsComponent:
@@ -238,11 +238,11 @@ timeOperatorsComponent:
     | YEAR_OP LPAREN exprComponent RPAREN                                                # yearAtomComponent
     | MONTH_OP LPAREN exprComponent RPAREN                                               # monthAtomComponent
     | DAYOFMONTH LPAREN exprComponent RPAREN                                             # dayOfMonthAtomComponent
-    | DAYOFYEAR LPAREN exprComponent RPAREN                                              # datOfYearAtomComponent
+    | DAYOFYEAR LPAREN exprComponent RPAREN                                              # dayOfYearAtomComponent
     | DAYTOYEAR LPAREN exprComponent RPAREN                                              # dayToYearAtomComponent
     | DAYTOMONTH LPAREN exprComponent RPAREN                                             # dayToMonthAtomComponent
-    | YEARTODAY LPAREN exprComponent RPAREN                                              # yearTodayAtomComponent
-    | MONTHTODAY LPAREN exprComponent RPAREN                                             # monthTodayAtomComponent
+    | YEARTODAY LPAREN exprComponent RPAREN                                              # yearToDayAtomComponent
+    | MONTHTODAY LPAREN exprComponent RPAREN                                             # monthToDayAtomComponent
 ;
 
 setOperators:
@@ -363,7 +363,7 @@ calcClauseItem:
 
 /*SUBSPACE CLAUSE*/
 subspaceClauseItem:
-  componentID  EQ  scalarItem
+  componentID  EQ  (scalarItem | varID)
 ;
 
 scalarItem: