vtlengine 1.0__py3-none-any.whl → 1.0.2__py3-none-any.whl

vtlengine/AST/DAG/__init__.py

@@ -6,16 +6,31 @@ Description
 -----------
 Direct Acyclic Graph.
 """
+
 import copy
 from dataclasses import dataclass
 from typing import Any, Dict, Optional
 
 import networkx as nx
 
-from vtlengine.AST import AST, BinOp, VarID, Aggregation, Analytic, JoinOp, ParamOp, Operator, \
-    Identifier, \
-    DefIdentifier, Start, HRuleset, RegularAggregation, PersistentAssignment, Assignment, \
-    DPRuleset
+from vtlengine.AST import (
+    AST,
+    BinOp,
+    VarID,
+    Aggregation,
+    Analytic,
+    JoinOp,
+    ParamOp,
+    Operator,
+    Identifier,
+    DefIdentifier,
+    Start,
+    HRuleset,
+    RegularAggregation,
+    PersistentAssignment,
+    Assignment,
+    DPRuleset,
+)
 from vtlengine.AST.ASTTemplate import ASTTemplate
 from vtlengine.AST.DAG._words import INSERT, DELETE, OUTPUTS, PERSISTENT, INPUTS, GLOBAL
 from vtlengine.AST.Grammar.tokens import AS, MEMBERSHIP, TO
@@ -116,9 +131,7 @@ class DAGAnalyzer(ASTTemplate):
 
     @classmethod
     def createDAG(cls, ast: AST):
-        """
-
-        """
+        """ """
         # Visit AST.
         dag = cls()
         dag.visit(ast)
@@ -142,17 +155,16 @@ class DAGAnalyzer(ASTTemplate):
                         error_keys[aux_v1] = dag.dependencies[aux_v1]
                         break
             raise Exception(
-                'Vtl Script contains Cycles, no DAG established.\nSuggestion {}, more_info:{}'.format(
-                    error, error_keys)) from None
+                "Vtl Script contains Cycles, no DAG established.\nSuggestion {}, "
+                "more_info:{}".format(error, error_keys)
+            ) from None
         except SemanticError as error:
             raise error
         except Exception as error:
-            raise Exception('Error creating DAG.') from error
+            raise Exception("Error creating DAG.") from error
 
     def loadVertex(self):
-        """
-
-        """
+        """ """
         # For each vertex
         for key, statement in self.dependencies.items():
             output = statement[OUTPUTS] + statement[PERSISTENT]
@@ -164,9 +176,7 @@ class DAGAnalyzer(ASTTemplate):
         self.nov = len(self.vertex)
 
     def loadEdges(self):
-        """
-
-        """
+        """ """
         if len(self.vertex) != 0:
             countEdges = 0
             # For each vertex
@@ -182,9 +192,7 @@ class DAGAnalyzer(ASTTemplate):
                         countEdges += 1
 
     def nx_topologicalSort(self):
-        """
-
-        """
+        """ """
         edges = list(self.edges.values())
         DAG = nx.DiGraph()
         DAG.add_nodes_from(self.vertex)
@@ -208,26 +216,23 @@ class DAGAnalyzer(ASTTemplate):
                 non_repeated_outputs.append(statement.left.value)
 
     def sortAST(self, ast: AST):
-        """
-
-        """
+        """ """
         statements_nodes = ast.children
-        HRuleStatements: list = [HRule for HRule in statements_nodes if
-                                 isinstance(HRule, HRuleset)]
-        DPRuleStatement: list = [DPRule for DPRule in statements_nodes if
-                                 isinstance(DPRule, DPRuleset)]
+        HRuleStatements: list = [HRule for HRule in statements_nodes if isinstance(HRule, HRuleset)]
+        DPRuleStatement: list = [
+            DPRule for DPRule in statements_nodes if isinstance(DPRule, DPRuleset)
+        ]
         DOStatement: list = [DO for DO in statements_nodes if isinstance(DO, Operator)]
-        MLStatements: list = [ML for ML in statements_nodes if
-                              not isinstance(ML, (HRuleset, DPRuleset, Operator))]
+        MLStatements: list = [
+            ML for ML in statements_nodes if not isinstance(ML, (HRuleset, DPRuleset, Operator))
+        ]
 
         intermediate = self.sort_elements(MLStatements)
         self.check_overwriting(intermediate)
         ast.children = HRuleStatements + DPRuleStatement + DOStatement + intermediate
 
     def statementStructure(self) -> dict:
-        """
-
-        """
+        """ """
         inputs = list(set(self.inputs))
         outputs = list(set(self.outputs))
         persistent = list(set(self.persistent))
@@ -267,9 +272,11 @@ class DAGAnalyzer(ASTTemplate):
 
                 # Analyze inputs and outputs per each statement.
                 self.dependencies[self.numberOfStatements] = copy.deepcopy(
-                    self.statementStructure())
+                    self.statementStructure()
+                )
 
-                # Count the number of statements in order to name the scope symbol table for each one.
+                # Count the number of statements in order to name the scope symbol table for
+                # each one.
                 self.numberOfStatements += 1
 
                 self.alias = []
@@ -376,8 +383,9 @@ class HRDAGAnalyzer(DAGAnalyzer):
                         error_keys[aux_v1] = dag.dependencies[aux_v1]
                         break
             raise Exception(
-                f'Vtl Script contains Cycles, no DAG established.'
-                f'\nSuggestion {error}, more_info:{error_keys}')
+                f"Vtl Script contains Cycles, no DAG established."
+                f"\nSuggestion {error}, more_info:{error_keys}"
+            )
 
     def visit_HRuleset(self, node: HRuleset) -> None:
         """

vtlengine/AST/DAG/_words.py

@@ -1,9 +1,9 @@
 # DS analysis
-INSERT = 'insertion'
-DELETE = 'deletion'
-GLOBAL = 'global_inputs'
+INSERT = "insertion"
+DELETE = "deletion"
+GLOBAL = "global_inputs"
 
 INPUTS = "inputs"
 OUTPUTS = "outputs"
 PERSISTENT = "persistent"
-STATEMENT_ = 'statement'
+STATEMENT_ = "statement"

vtlengine/AST/Grammar/Vtl.g4

@@ -21,30 +21,33 @@ expr:
     | op=(PLUS|MINUS|NOT) right=expr                                        # unaryExpr
     | left=expr op=(MUL|DIV) right=expr                                     # arithmeticExpr
     | left=expr op=(PLUS|MINUS|CONCAT) right=expr                           # arithmeticExprOrConcat
-    | left=expr op=comparisonOperand right=expr                            # comparisonExpr
+    | left=expr op=comparisonOperand  right=expr                            # comparisonExpr
     | left=expr op=(IN|NOT_IN)(lists|valueDomainID)                         # inNotInExpr
     | left=expr op=AND right=expr                                           # booleanExpr
     | left=expr op=(OR|XOR) right=expr							            # booleanExpr
     | IF  conditionalExpr=expr  THEN thenExpr=expr ELSE elseExpr=expr       # ifExpr
+    | CASE (WHEN expr THEN expr)+ ELSE expr                                 # caseExpr
     | constant														        # constantExpr
     | varID															        # varIdExpr
 
+
 ;
 
 
 exprComponent:
-    LPAREN exprComponent RPAREN                                                                             # parenthesisExprComp
-    | functionsComponents                                                                                   # functionsExpressionComp
-    | op=(PLUS|MINUS|NOT) right=exprComponent                                                               # unaryExprComp
-    | left=exprComponent op=(MUL|DIV) right=exprComponent                                                   # arithmeticExprComp
-    | left=exprComponent op=(PLUS|MINUS|CONCAT) right=exprComponent                                         # arithmeticExprOrConcatComp
-    | left=exprComponent comparisonOperand right=exprComponent                                              # comparisonExprComp
-    | left=exprComponent op=(IN|NOT_IN)(lists|valueDomainID)                                                # inNotInExprComp
-    | left=exprComponent op=AND right=exprComponent                                                         # booleanExprComp
-    | left=exprComponent op=(OR|XOR) right=exprComponent                                                    # booleanExprComp
-    | IF  conditionalExpr=exprComponent  THEN thenExpr=exprComponent ELSE elseExpr=exprComponent            # ifExprComp
-    | constant                                                                                              # constantExprComp
-    | componentID                                                                                           # compId
+    LPAREN exprComponent RPAREN                                                                                 # parenthesisExprComp
+    | functionsComponents                                                                                       # functionsExpressionComp
+    | op=(PLUS|MINUS|NOT) right=exprComponent                                                                   # unaryExprComp
+    | left=exprComponent op=(MUL|DIV) right=exprComponent                                                       # arithmeticExprComp
+    | left=exprComponent op=(PLUS|MINUS|CONCAT) right=exprComponent                                             # arithmeticExprOrConcatComp
+    | left=exprComponent comparisonOperand right=exprComponent                                                  # comparisonExprComp
+    | left=exprComponent op=(IN|NOT_IN)(lists|valueDomainID)                                                    # inNotInExprComp
+    | left=exprComponent op=AND right=exprComponent                                                             # booleanExprComp
+    | left=exprComponent op=(OR|XOR) right=exprComponent                                                        # booleanExprComp
+    | IF  conditionalExpr=exprComponent  THEN thenExpr=exprComponent ELSE elseExpr=exprComponent                # ifExprComp
+    | CASE (WHEN exprComponent THEN exprComponent)+ ELSE exprComponent                                          # caseExprComp
+    | constant                                                                                                  # constantExprComp
+    | componentID                                                                                               # compId
 ;
 
 functionsComponents:
@@ -84,6 +87,7 @@ datasetClause:
     | calcClause
     | keepOrDropClause
     | pivotOrUnpivotClause
+ /*   | customPivotClause */
     | subspaceClause
 ;
 
@@ -112,6 +116,10 @@ pivotOrUnpivotClause:
     op=(PIVOT|UNPIVOT) id_=componentID COMMA mea=componentID
 ;
 
+customPivotClause:
+    CUSTOMPIVOT id_=componentID COMMA mea=componentID IN constant (COMMA constant)*
+;
+
 subspaceClause:
     SUBSPACE subspaceClauseItem (COMMA subspaceClauseItem)*
 ;
@@ -138,7 +146,7 @@ defOperators:
 /*---------------------------------------------------FUNCTIONS-------------------------------------------------*/
 genericOperators:
     operatorID LPAREN (parameter (COMMA parameter)*)? RPAREN                                                                                                                    # callDataset
-    | EVAL LPAREN routineName LPAREN (varID|scalarItem)? (COMMA (varID|scalarItem))* RPAREN (LANGUAGE STRING_CONSTANT)? (RETURNS evalDatasetType)? RPAREN                       # evalAtom
+    | EVAL LPAREN routineName LPAREN (varID|scalarItem)? (COMMA (varID|scalarItem))* RPAREN (LANGUAGE STRING_CONSTANT)? (RETURNS evalDatasetType)? RPAREN                               # evalAtom
     | CAST LPAREN expr COMMA (basicScalarType|valueDomainName) (COMMA STRING_CONSTANT)? RPAREN                                                                                  # castExprDataset
 ;
 
@@ -149,6 +157,7 @@ genericOperatorsComponent:
 
 ;
 
+
 parameterComponent:
     exprComponent
     | OPTIONAL
@@ -176,13 +185,13 @@ stringOperatorsComponent:
 numericOperators:
     op=(CEIL | FLOOR | ABS | EXP | LN | SQRT) LPAREN expr RPAREN						        # unaryNumeric
     | op=(ROUND | TRUNC) LPAREN expr (COMMA optionalExpr)? RPAREN							    # unaryWithOptionalNumeric
-    | op=(MOD | POWER|LOG) LPAREN left=expr COMMA right=expr RPAREN							    # binaryNumeric
+    | op=(MOD | POWER | LOG | RANDOM) LPAREN left=expr COMMA right=expr RPAREN					# binaryNumeric
 ;
 
 numericOperatorsComponent:
-    op=(CEIL | FLOOR | ABS | EXP | LN | SQRT) LPAREN exprComponent RPAREN						# unaryNumericComponent
-    | op=(ROUND | TRUNC) LPAREN exprComponent (COMMA optionalExprComponent)? RPAREN			    # unaryWithOptionalNumericComponent
-    | op=(MOD | POWER | LOG) LPAREN left=exprComponent COMMA right=exprComponent RPAREN		    # binaryNumericComponent
+    op=(CEIL | FLOOR | ABS | EXP | LN | SQRT) LPAREN exprComponent RPAREN						    # unaryNumericComponent
+    | op=(ROUND | TRUNC) LPAREN exprComponent (COMMA optionalExprComponent)? RPAREN			        # unaryWithOptionalNumericComponent
+    | op=(MOD | POWER | LOG | RANDOM) LPAREN left=exprComponent COMMA right=exprComponent RPAREN    # binaryNumericComponent
 ;
 
 comparisonOperators:
@@ -205,6 +214,16 @@ timeOperators:
     | TIMESHIFT LPAREN expr COMMA signedInteger RPAREN                                                                                  # timeShiftAtom
     | TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? (COMMA op=optionalExpr)? (COMMA (FIRST|LAST))? RPAREN     # timeAggAtom
     | CURRENT_DATE LPAREN RPAREN                                                                                                        # currentDateAtom
+    | DATEDIFF LPAREN dateFrom=expr COMMA dateTo=expr RPAREN                    # dateDiffAtom
+    | DATEADD LPAREN op=expr COMMA shiftNumber=expr COMMA periodInd=expr RPAREN # dateAddAtom
+    | YEAR_OP LPAREN expr RPAREN                                                # yearAtom
+    | MONTH_OP LPAREN expr RPAREN                                               # monthAtom
+    | DAYOFMONTH LPAREN expr RPAREN                                             # dayOfMonthAtom
+    | DAYOFYEAR LPAREN expr RPAREN                                              # datOfYearAtom
+    | DAYTOYEAR LPAREN expr RPAREN                                              # dayToYearAtom
+    | DAYTOMONTH LPAREN expr RPAREN                                             # dayToMonthAtom
+    | YEARTODAY LPAREN expr RPAREN                                              # yearTodayAtom
+    | MONTHTODAY LPAREN expr RPAREN                                             # monthTodayAtom
 ;
 
 timeOperatorsComponent:
@@ -213,7 +232,17 @@ timeOperatorsComponent:
     | op=(FLOW_TO_STOCK | STOCK_TO_FLOW) LPAREN exprComponent RPAREN	                                                                                    # flowAtomComponent
     | TIMESHIFT LPAREN exprComponent COMMA signedInteger RPAREN                                                                                 # timeShiftAtomComponent
     | TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? (COMMA op=optionalExprComponent)? (COMMA (FIRST|LAST))? RPAREN    # timeAggAtomComponent
-    | CURRENT_DATE LPAREN RPAREN                                                                                                                # currentDateAtomComponent
+    | CURRENT_DATE LPAREN RPAREN                                                                                                               # currentDateAtomComponent
+    | DATEDIFF LPAREN dateFrom=exprComponent COMMA dateTo=exprComponent RPAREN                    # dateDiffAtomComponent
+    | DATEADD LPAREN op=exprComponent COMMA shiftNumber=exprComponent COMMA periodInd=exprComponent RPAREN # dateAddAtomComponent
+    | YEAR_OP LPAREN exprComponent RPAREN                                                # yearAtomComponent
+    | MONTH_OP LPAREN exprComponent RPAREN                                               # monthAtomComponent
+    | DAYOFMONTH LPAREN exprComponent RPAREN                                             # dayOfMonthAtomComponent
+    | DAYOFYEAR LPAREN exprComponent RPAREN                                              # datOfYearAtomComponent
+    | DAYTOYEAR LPAREN exprComponent RPAREN                                              # dayToYearAtomComponent
+    | DAYTOMONTH LPAREN exprComponent RPAREN                                             # dayToMonthAtomComponent
+    | YEARTODAY LPAREN exprComponent RPAREN                                              # yearTodayAtomComponent
+    | MONTHTODAY LPAREN exprComponent RPAREN                                             # monthTodayAtomComponent
 ;
 
 setOperators:
@@ -284,7 +313,7 @@ aggrOperatorsGrouping:
         | FIRST_VALUE
         | LAST_VALUE)
         LPAREN expr OVER LPAREN (partition=partitionByClause? orderBy=orderByClause? windowing=windowingClause?)RPAREN RPAREN       #anSimpleFunction
-    | op=(LAG |LEAD)  LPAREN expr (COMMA offet=signedInteger(COMMA defaultValue=scalarItem)?)?  OVER  LPAREN (partition=partitionByClause? orderBy=orderByClause)   RPAREN RPAREN    # lagOrLeadAn
+    | op=(LAG |LEAD)  LPAREN expr (COMMA offset=signedInteger(COMMA defaultValue=scalarItem)?)?  OVER  LPAREN (partition=partitionByClause? orderBy=orderByClause)   RPAREN RPAREN    # lagOrLeadAn
     | op=RATIO_TO_REPORT LPAREN expr OVER  LPAREN (partition=partitionByClause) RPAREN RPAREN                                                                           # ratioToReportAn
 ;
 

vtlengine/AST/Grammar/VtlTokens.g4

@@ -28,11 +28,22 @@ lexer grammar VtlTokens;
   MEMBERSHIP		: '#';
   EVAL              : 'eval';
   IF                : 'if';
+  CASE              : 'case';
   THEN              : 'then';
   ELSE              : 'else';
   USING             : 'using';
   WITH              : 'with';
   CURRENT_DATE      : 'current_date';
+  DATEDIFF          : 'datediff';
+  DATEADD           : 'dateadd';
+  YEAR_OP           : 'year';
+  MONTH_OP          : 'month';
+  DAYOFMONTH        : 'dayofmonth';
+  DAYOFYEAR         : 'dayofyear';
+  DAYTOYEAR         : 'daytoyear';
+  DAYTOMONTH        : 'daytomonth';
+  YEARTODAY         : 'yeartoday';
+  MONTHTODAY        : 'monthtoday';
   ON                : 'on';
   DROP              : 'drop';
   KEEP              : 'keep';
@@ -54,6 +65,7 @@ lexer grammar VtlTokens;
   DIFF              : 'diff';
   SYMDIFF           : 'symdiff';
   INTERSECT         : 'intersect';
+  RANDOM            : 'random';
   KEYS              : 'keys';
   INTYEAR           : 'intyear';
   INTMONTH          : 'intmonth';
@@ -394,4 +406,4 @@ FREQUENCY
   | 'M'
   | 'W'
   | 'D'
-  ;*/
+  ;*/