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

vtlengine/AST/ASTConstructorModules/Expr.py

@@ -3,12 +3,29 @@ from copy import copy
 
 from antlr4.tree.Tree import TerminalNodeImpl
 
-from vtlengine.AST import If, BinOp, RenameNode, UDOCall, UnaryOp, JoinOp, Identifier, ParamOp, \
-    EvalOp, \
-    ParamConstant, \
-    MulOp, \
-    RegularAggregation, Assignment, Aggregation, ID, TimeAggregation, Constant, Validation, \
-    Analytic, Windowing, VarID
+from vtlengine.AST import (
+    If,
+    BinOp,
+    RenameNode,
+    UDOCall,
+    UnaryOp,
+    JoinOp,
+    Identifier,
+    ParamOp,
+    EvalOp,
+    ParamConstant,
+    MulOp,
+    RegularAggregation,
+    Assignment,
+    Aggregation,
+    ID,
+    TimeAggregation,
+    Constant,
+    Validation,
+    Analytic,
+    Windowing,
+    VarID,
+)
 from vtlengine.AST.ASTConstructorModules.ExprComponents import ExprComp
 from vtlengine.AST.ASTConstructorModules.Terminals import Terminals
 from vtlengine.AST.ASTDataExchange import de_ruleset_elements
@@ -23,27 +40,27 @@ class Expr(VtlVisitor):
     """______________________________________________________________________________________
 
 
-                                        Expr Definition.
+                                Expr Definition.
 
-            _______________________________________________________________________________________"""
+    _______________________________________________________________________________________"""
 
     def visitExpr(self, ctx: Parser.ExprContext):
         """
         expr:
-            LPAREN expr RPAREN											            # parenthesisExpr
-               | functions                                                             # functionsExpression
-               | dataset=expr  QLPAREN  clause=datasetClause  QRPAREN                  # clauseExpr
-               | expr MEMBERSHIP simpleComponentId                                     # membershipExpr
-               | 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=(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
-               | constant														        # constantExpr
-               | varID															        # varIdExpr
+            LPAREN expr RPAREN											            # parenthesisExpr # noqa E501
+               | functions                                                             # functionsExpression # noqa E501
+               | dataset=expr  QLPAREN  clause=datasetClause  QRPAREN                  # clauseExpr # noqa E501
+               | expr MEMBERSHIP simpleComponentId                                     # membershipExpr # noqa E501
+               | op=(PLUS|MINUS|NOT) right=expr                                        # unaryExpr # noqa E501
+               | left=expr op=(MUL|DIV) right=expr                                     # arithmeticExpr # noqa E501
+               | left=expr op=(PLUS|MINUS|CONCAT) right=expr                           # arithmeticExprOrConcat # noqa E501
+               | left=expr op=comparisonOperand  right=expr                            # comparisonExpr # noqa E501
+               | left=expr op=(IN|NOT_IN)(lists|valueDomainID)                         # inNotInExpr # noqa E501
+               | left=expr op=AND right=expr                                           # booleanExpr # noqa E501
+               | left=expr op=(OR|XOR) right=expr							            # booleanExpr # noqa E501
+               | IF  conditionalExpr=expr  THEN thenExpr=expr ELSE elseExpr=expr       # ifExpr # noqa E501
+               | constant														        # constantExpr # noqa E501
+               | varID															        # varIdExpr # noqa E501
         ;
         """
         ctx_list = list(ctx.getChildren())
@@ -163,15 +180,19 @@ class Expr(VtlVisitor):
     def visitMembershipExpr(self, ctx: Parser.MembershipExprContext):
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
-        membership = [componentID for componentID in ctx_list if
-                      isinstance(componentID, Parser.SimpleComponentIdContext)]
+        membership = [
+            componentID
+            for componentID in ctx_list
+            if isinstance(componentID, Parser.SimpleComponentIdContext)
+        ]
 
         previous_node = self.visitExpr(c)
 
         # It is only possible to put a membership at the end so go the last one.
         if len(membership) != 0:
-            previous_node = BinOp(previous_node, '#',
-                                  Terminals().visitSimpleComponentId(membership[0]))
+            previous_node = BinOp(
+                previous_node, "#", Terminals().visitSimpleComponentId(membership[0])
+            )
 
         return previous_node
 
@@ -254,7 +275,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Join Functions             
+                                Join Functions
                         -----------------------------------
     """
 
@@ -265,7 +286,7 @@ class Expr(VtlVisitor):
 
         op_node = ctx_list[0].getSymbol().text
 
-        if op_node in ['inner_join', 'left_join']:
+        if op_node in ["inner_join", "left_join"]:
             clause_node, using_node = self.visitJoinClause(ctx_list[2])
         else:
             clause_node = self.visitJoinClauseWithoutUsing(ctx_list[2])
@@ -297,7 +318,7 @@ class Expr(VtlVisitor):
             return left_node
 
         intop_node = ctx_list[1].getSymbol().text
-        right_node = Identifier(Terminals().visitAlias(ctx_list[2]), 'DatasetID')
+        right_node = Identifier(Terminals().visitAlias(ctx_list[2]), "DatasetID")
         return BinOp(left_node, intop_node, right_node)
 
     def visitJoinClause(self, ctx: Parser.JoinClauseContext):
@@ -311,8 +332,9 @@ class Expr(VtlVisitor):
         using = None
 
         items = [item for item in ctx_list if isinstance(item, Parser.JoinClauseItemContext)]
-        components = [component for component in ctx_list if
-                      isinstance(component, Parser.ComponentIDContext)]
+        components = [
+            component for component in ctx_list if isinstance(component, Parser.ComponentIDContext)
+        ]
 
         for item in items:
             clause_nodes.append(self.visitJoinClauseItem(item))
@@ -326,7 +348,7 @@ class Expr(VtlVisitor):
 
     def visitJoinClauseWithoutUsing(self, ctx: Parser.JoinClauseWithoutUsingContext):
         """
-        joinClause: joinClauseItem (COMMA joinClauseItem)* (USING componentID (COMMA componentID)*)? ;
+        joinClause: joinClauseItem (COMMA joinClauseItem)* (USING componentID (COMMA componentID)*)? ; # noqa E501
         """
         ctx_list = list(ctx.getChildren())
 
@@ -341,7 +363,7 @@ class Expr(VtlVisitor):
 
     def visitJoinBody(self, ctx: Parser.JoinBodyContext):
         """
-        joinBody: filterClause? (calcClause|joinApplyClause|aggrClause)? (keepOrDropClause)? renameClause?
+        joinBody: filterClause? (calcClause|joinApplyClause|aggrClause)? (keepOrDropClause)? renameClause? # noqa E501
         """
         ctx_list = list(ctx.getChildren())
 
@@ -378,7 +400,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Generic Functions             
+                                Generic Functions
                         -----------------------------------
     """
 
@@ -400,46 +422,65 @@ class Expr(VtlVisitor):
         c = ctx_list[0]
 
         op = Terminals().visitOperatorID(c)
-        param_nodes = [self.visitParameter(element) for element in ctx_list if
-                       isinstance(element, Parser.ParameterContext)]
+        param_nodes = [
+            self.visitParameter(element)
+            for element in ctx_list
+            if isinstance(element, Parser.ParameterContext)
+        ]
 
         return UDOCall(op=op, params=param_nodes)
 
     def visitEvalAtom(self, ctx: Parser.EvalAtomContext):
         """
-            | 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 # noqa E501                       # evalAtom
         """
         ctx_list = list(ctx.getChildren())
 
         routine_name = Terminals().visitRoutineName(ctx_list[2])
 
         # Think of a way to maintain the order, for now its not necessary.
-        var_ids_nodes = [Terminals().visitVarID(varID) for varID in ctx_list if
-                         isinstance(varID, Parser.VarIDContext)]
-        constant_nodes = [Terminals().visitScalarItem(scalar) for scalar in ctx_list if
-                          isinstance(scalar, Parser.ScalarItemContext)]
+        var_ids_nodes = [
+            Terminals().visitVarID(varID)
+            for varID in ctx_list
+            if isinstance(varID, Parser.VarIDContext)
+        ]
+        constant_nodes = [
+            Terminals().visitScalarItem(scalar)
+            for scalar in ctx_list
+            if isinstance(scalar, Parser.ScalarItemContext)
+        ]
         children_nodes = var_ids_nodes + constant_nodes
 
         # Reference manual says it is mandatory.
-        language_name = [language for language in ctx_list if
-                         isinstance(language,
-                                    TerminalNodeImpl) and language.getSymbol().type == Parser.STRING_CONSTANT]
+        language_name = [
+            language
+            for language in ctx_list
+            if isinstance(language, TerminalNodeImpl)
+            and language.getSymbol().type == Parser.STRING_CONSTANT
+        ]
         if len(language_name) == 0:
             # AST_ASTCONSTRUCTOR.12
-            raise SemanticError("1-4-2-1", option='language')
+            raise SemanticError("1-4-2-1", option="language")
         # Reference manual says it is mandatory.
-        output_node = [Terminals().visitEvalDatasetType(output) for output in ctx_list if
-                       isinstance(output, Parser.EvalDatasetTypeContext)]
+        output_node = [
+            Terminals().visitEvalDatasetType(output)
+            for output in ctx_list
+            if isinstance(output, Parser.EvalDatasetTypeContext)
+        ]
         if len(output_node) == 0:
             # AST_ASTCONSTRUCTOR.13
-            raise SemanticError("1-4-2-1", option='output')
+            raise SemanticError("1-4-2-1", option="output")
 
-        return EvalOp(name=routine_name, operands=children_nodes, output=output_node[0],
-                      language=language_name[0].getSymbol().text)
+        return EvalOp(
+            name=routine_name,
+            operands=children_nodes,
+            output=output_node[0],
+            language=language_name[0].getSymbol().text,
+        )
 
     def visitCastExprDataset(self, ctx: Parser.CastExprDatasetContext):
         """
-            | CAST LPAREN expr COMMA (basicScalarType|valueDomainName) (COMMA STRING_CONSTANT)? RPAREN                                                                                  # castExprDataset
+        | CAST LPAREN expr COMMA (basicScalarType|valueDomainName) (COMMA STRING_CONSTANT)? RPAREN # noqa E501                                                                          # castExprDataset
         """
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
@@ -447,19 +488,28 @@ class Expr(VtlVisitor):
         token = c.getSymbol()
 
         op = token.text
-        expr_node = [self.visitExpr(expr) for expr in ctx_list if
-                     isinstance(expr, Parser.ExprContext)]
-        basic_scalar_type = [Terminals().visitBasicScalarType(type_) for type_ in ctx_list if
-                             isinstance(type_, Parser.BasicScalarTypeContext)]
-
-        [Terminals().visitValueDomainName(valueD) for valueD in ctx_list if
-         isinstance(valueD, Parser.ValueDomainNameContext)]
+        expr_node = [
+            self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
+        ]
+        basic_scalar_type = [
+            Terminals().visitBasicScalarType(type_)
+            for type_ in ctx_list
+            if isinstance(type_, Parser.BasicScalarTypeContext)
+        ]
+
+        [
+            Terminals().visitValueDomainName(valueD)
+            for valueD in ctx_list
+            if isinstance(valueD, Parser.ValueDomainNameContext)
+        ]
 
         if len(ctx_list) > 6:
-            param_node = [ParamConstant('PARAM_CAST', str_.symbol.text.strip('"')) for str_ in
-                          ctx_list if
-                          isinstance(str_,
-                                     TerminalNodeImpl) and str_.getSymbol().type == Parser.STRING_CONSTANT]
+            param_node = [
+                ParamConstant("PARAM_CAST", str_.symbol.text.strip('"'))
+                for str_ in ctx_list
+                if isinstance(str_, TerminalNodeImpl)
+                and str_.getSymbol().type == Parser.STRING_CONSTANT
+            ]
         else:
             param_node = []
 
@@ -479,13 +529,13 @@ class Expr(VtlVisitor):
         if isinstance(c, Parser.ExprContext):
             return self.visitExpr(c)
         elif isinstance(c, TerminalNodeImpl):
-            return ID('OPTIONAL', c.getSymbol().text)
+            return ID("OPTIONAL", c.getSymbol().text)
         else:
             raise NotImplementedError
 
     """
                         -----------------------------------
-                                String Functions             
+                                String Functions
                         -----------------------------------
     """
 
@@ -536,10 +586,14 @@ class Expr(VtlVisitor):
         c = ctx_list[0]
 
         token = c.getSymbol()
-        expressions = [self.visitExpr(expr) for expr in ctx_list if
-                       isinstance(expr, Parser.ExprContext)]
-        params = [self.visitOptionalExpr(param) for param in ctx_list if
-                  isinstance(param, Parser.OptionalExprContext)]
+        expressions = [
+            self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
+        ]
+        params = [
+            self.visitOptionalExpr(param)
+            for param in ctx_list
+            if isinstance(param, Parser.OptionalExprContext)
+        ]
 
         op_node = token.text
 
@@ -553,10 +607,14 @@ class Expr(VtlVisitor):
         c = ctx_list[0]
 
         token = c.getSymbol()
-        expressions = [self.visitExpr(expr) for expr in ctx_list if
-                       isinstance(expr, Parser.ExprContext)]
-        params = [self.visitOptionalExpr(param) for param in ctx_list if
-                  isinstance(param, Parser.OptionalExprContext)]
+        expressions = [
+            self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
+        ]
+        params = [
+            self.visitOptionalExpr(param)
+            for param in ctx_list
+            if isinstance(param, Parser.OptionalExprContext)
+        ]
 
         op_node = token.text
 
@@ -567,7 +625,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Numeric Functions             
+                                Numeric Functions
                         -----------------------------------
     """
 
@@ -624,7 +682,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Comparison Functions             
+                                Comparison Functions
                         -----------------------------------
     """
 
@@ -678,16 +736,20 @@ class Expr(VtlVisitor):
         token = ctx_list[0].getSymbol()
         op = token.text
 
-        operand_nodes = [self.visitExpr(expr) for expr in ctx_list if
-                         isinstance(expr, Parser.ExprContext)]
-        retain_nodes = [Terminals().visitRetainType(retain) for retain in ctx_list if
-                        isinstance(retain, Parser.RetainTypeContext)]
+        operand_nodes = [
+            self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
+        ]
+        retain_nodes = [
+            Terminals().visitRetainType(retain)
+            for retain in ctx_list
+            if isinstance(retain, Parser.RetainTypeContext)
+        ]
 
         return MulOp(op=op, children=operand_nodes + retain_nodes)
 
     """
                             -----------------------------------
-                                    Time Functions             
+                                    Time Functions
                             -----------------------------------
         """
 
@@ -715,8 +777,11 @@ class Expr(VtlVisitor):
         c = ctx_list[0]
 
         op = c.getSymbol().text
-        operand_node = [self.visitExpr(operand) for operand in ctx_list if
-                        isinstance(operand, Parser.ExprContext)]
+        operand_node = [
+            self.visitExpr(operand)
+            for operand in ctx_list
+            if isinstance(operand, Parser.ExprContext)
+        ]
 
         if len(operand_node) == 0:
             # AST_ASTCONSTRUCTOR.15
@@ -733,7 +798,7 @@ class Expr(VtlVisitor):
 
         op = c.getSymbol().text
         left_node = self.visitExpr(ctx_list[2])
-        right_node = Constant('INTEGER_CONSTANT', Terminals().visitSignedInteger(ctx_list[4]))
+        right_node = Constant("INTEGER_CONSTANT", Terminals().visitSignedInteger(ctx_list[4]))
 
         return BinOp(left=left_node, op=op, right=right_node)
 
@@ -748,7 +813,7 @@ class Expr(VtlVisitor):
         children_node = [self.visitExpr(ctx_list[2])]
 
         if len(ctx_list) > 4:
-            param_constant_node = [ParamConstant('PARAM_TIMESERIES', ctx_list[4].getSymbol().text)]
+            param_constant_node = [ParamConstant("PARAM_TIMESERIES", ctx_list[4].getSymbol().text)]
         else:
             param_constant_node = []
 
@@ -756,7 +821,7 @@ class Expr(VtlVisitor):
 
     def visitTimeAggAtom(self, ctx: Parser.TimeAggAtomContext):
         """
-        TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? (COMMA op=optionalExpr)? (COMMA (FIRST|LAST))? RPAREN     # timeAggAtom
+        TIME_AGG LPAREN periodIndTo=STRING_CONSTANT (COMMA periodIndFrom=(STRING_CONSTANT| OPTIONAL ))? (COMMA op=optionalExpr)? (COMMA (FIRST|LAST))? RPAREN     # timeAggAtom # noqa E501
         """
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
@@ -768,9 +833,12 @@ class Expr(VtlVisitor):
         if ctx.periodIndFrom is not None and ctx.periodIndFrom.type != Parser.OPTIONAL:
             period_from = str(ctx.periodIndFrom.text)[1:-1]
 
-        conf = [str_.getSymbol().text for str_ in ctx_list if
-                isinstance(str_, TerminalNodeImpl) and str_.getSymbol().type in [Parser.FIRST,
-                                                                                 Parser.LAST]]
+        conf = [
+            str_.getSymbol().text
+            for str_ in ctx_list
+            if isinstance(str_, TerminalNodeImpl)
+            and str_.getSymbol().type in [Parser.FIRST, Parser.LAST]
+        ]
 
         if len(conf) == 0:
             conf = None
@@ -789,8 +857,9 @@ class Expr(VtlVisitor):
         if operand_node is None:
             # AST_ASTCONSTRUCTOR.17
             raise Exception("Optional as expression node is not allowed in Time Aggregation")
-        return TimeAggregation(op=op, operand=operand_node, period_to=period_to,
-                               period_from=period_from, conf=conf)
+        return TimeAggregation(
+            op=op, operand=operand_node, period_to=period_to, period_from=period_from, conf=conf
+        )
 
     def visitFlowAtom(self, ctx: Parser.FlowAtomContext):
         ctx_list = list(ctx.getChildren())
@@ -805,7 +874,7 @@ class Expr(VtlVisitor):
 
     """
                             -----------------------------------
-                                    Conditional Functions             
+                                    Conditional Functions
                             -----------------------------------
     """
 
@@ -828,15 +897,15 @@ class Expr(VtlVisitor):
 
     """
                             -----------------------------------
-                                    Set Functions             
+                                    Set Functions
                             -----------------------------------
     """
 
     def visitSetFunctions(self, ctx: Parser.SetFunctionsContext):
         """
-        setExpr:     UNION LPAREN left=expr (COMMA expr)+ RPAREN                             # unionAtom
-                    | INTERSECT LPAREN left=expr (COMMA expr)+ RPAREN                       # intersectAtom
-                    | op=(SETDIFF|SYMDIFF) LPAREN left=expr COMMA right=expr RPAREN         # setOrSYmDiffAtom
+        setExpr:     UNION LPAREN left=expr (COMMA expr)+ RPAREN                             # unionAtom # noqa E501
+                    | INTERSECT LPAREN left=expr (COMMA expr)+ RPAREN                       # intersectAtom # noqa E501
+                    | op=(SETDIFF|SYMDIFF) LPAREN left=expr COMMA right=expr RPAREN         # setOrSYmDiffAtom # noqa E501
         """
         if isinstance(ctx, Parser.UnionAtomContext):
             return self.visitUnionAtom(ctx)
@@ -849,41 +918,44 @@ class Expr(VtlVisitor):
 
     def visitUnionAtom(self, ctx: Parser.UnionAtomContext):
         ctx_list = list(ctx.getChildren())
-        exprs_nodes = [self.visitExpr(expr) for expr in ctx_list if
-                       isinstance(expr, Parser.ExprContext)]
+        exprs_nodes = [
+            self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
+        ]
 
         return MulOp(ctx_list[0].getSymbol().text, exprs_nodes)
 
     def visitIntersectAtom(self, ctx: Parser.IntersectAtomContext):
         ctx_list = list(ctx.getChildren())
-        exprs_nodes = [self.visitExpr(expr) for expr in ctx_list if
-                       isinstance(expr, Parser.ExprContext)]
+        exprs_nodes = [
+            self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
+        ]
 
         return MulOp(op=ctx_list[0].getSymbol().text, children=exprs_nodes)
 
     def visitSetOrSYmDiffAtom(self, ctx: Parser.SetOrSYmDiffAtomContext):
         ctx_list = list(ctx.getChildren())
-        exprs_nodes = [self.visitExpr(expr) for expr in ctx_list if
-                       isinstance(expr, Parser.ExprContext)]
+        exprs_nodes = [
+            self.visitExpr(expr) for expr in ctx_list if isinstance(expr, Parser.ExprContext)
+        ]
 
         return MulOp(op=ctx_list[0].getSymbol().text, children=exprs_nodes)
 
     """
                             -----------------------------------
-                                    Hierarchy Functions             
+                                    Hierarchy Functions
                             -----------------------------------
     """
 
     def visitHierarchyFunctions(self, ctx: Parser.HierarchyFunctionsContext):
         """
-            HIERARCHY LPAREN op=expr COMMA hrName=IDENTIFIER (conditionClause)? (RULE ruleComponent=componentID)? (validationMode)? (inputModeHierarchy)? outputModeHierarchy? RPAREN
+        HIERARCHY LPAREN op=expr COMMA hrName=IDENTIFIER (conditionClause)? (RULE ruleComponent=componentID)? (validationMode)? (inputModeHierarchy)? outputModeHierarchy? RPAREN # noqa E501
         """
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
         op = c.getSymbol().text
         dataset_node = self.visitExpr(ctx_list[2])
-        rule_name_node = Identifier(value=ctx_list[4].getSymbol().text, kind='RuleID')
+        rule_name_node = Identifier(value=ctx_list[4].getSymbol().text, kind="RuleID")
 
         conditions = []
         modes = "non_null"
@@ -910,9 +982,9 @@ class Expr(VtlVisitor):
             raise NotImplementedError("Dataset Priority input mode on HR is not implemented")
         param_constant_node = []
 
-        param_constant_node.append(ParamConstant('PARAM_MODE', modes))
-        param_constant_node.append(ParamConstant('PARAM_INPUT', inputs))
-        param_constant_node.append(ParamConstant('PARAM_OUTPUT', retains))
+        param_constant_node.append(ParamConstant("PARAM_MODE", modes))
+        param_constant_node.append(ParamConstant("PARAM_INPUT", inputs))
+        param_constant_node.append(ParamConstant("PARAM_OUTPUT", retains))
 
         if not rule_comp:
             if isinstance(de_ruleset_elements[rule_name_node.value], list):
@@ -921,16 +993,19 @@ class Expr(VtlVisitor):
                 rule_element = de_ruleset_elements[rule_name_node.value]
             if rule_element.kind == "DatasetID":
                 check_hierarchy_rule = rule_element.value
-                rule_comp = Identifier(check_hierarchy_rule, 'ComponentID')
+                rule_comp = Identifier(check_hierarchy_rule, "ComponentID")
             else:  # ValuedomainID
                 raise SemanticError("1-1-10-4", op=op)
 
-        return ParamOp(op=op, children=[dataset_node, rule_comp, rule_name_node, *conditions],
-                       params=param_constant_node)
+        return ParamOp(
+            op=op,
+            children=[dataset_node, rule_comp, rule_name_node, *conditions],
+            params=param_constant_node,
+        )
 
     """
                             -----------------------------------
-                                    Validation Functions             
+                                    Validation Functions
                             -----------------------------------
     """
 
@@ -944,7 +1019,7 @@ class Expr(VtlVisitor):
 
     def visitValidateDPruleset(self, ctx: Parser.ValidateDPrulesetContext):
         """
-            validationDatapoint: CHECK_DATAPOINT '(' expr ',' IDENTIFIER (COMPONENTS componentID (',' componentID)*)? (INVALID|ALL_MEASURES|ALL)? ')' ;
+        validationDatapoint: CHECK_DATAPOINT '(' expr ',' IDENTIFIER (COMPONENTS componentID (',' componentID)*)? (INVALID|ALL_MEASURES|ALL)? ')' ; # noqa E501
         """
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
@@ -954,8 +1029,11 @@ class Expr(VtlVisitor):
         operand_node = self.visitExpr(ctx_list[2])
         rule_name = ctx_list[4].getSymbol().text
 
-        components = [Terminals().visitComponentID(comp) for comp in ctx_list if
-                      isinstance(comp, Parser.ComponentIDContext)]
+        components = [
+            Terminals().visitComponentID(comp)
+            for comp in ctx_list
+            if isinstance(comp, Parser.ComponentIDContext)
+        ]
         aux_components = []
         for x in components:
             if isinstance(x, BinOp):
@@ -966,18 +1044,17 @@ class Expr(VtlVisitor):
         components = aux_components
 
         # Default value for output is invalid.
-        output = 'invalid'
+        output = "invalid"
 
         if isinstance(ctx_list[-2], Parser.ValidationOutputContext):
             output = Terminals().visitValidationOutput(ctx_list[-2])
 
-        return ParamOp(op=op, children=[operand_node, rule_name, *components],
-                       params=[output])
+        return ParamOp(op=op, children=[operand_node, rule_name, *components], params=[output])
 
     # TODO Not fully implemented only basic usage available.
     def visitValidateHRruleset(self, ctx: Parser.ValidateHRrulesetContext):
         """
-            CHECK_HIERARCHY LPAREN op=expr COMMA hrName=IDENTIFIER conditionClause? (RULE componentID)? validationMode? inputMode? validationOutput? RPAREN 	                # validateHRruleset
+        CHECK_HIERARCHY LPAREN op=expr COMMA hrName=IDENTIFIER conditionClause? (RULE componentID)? validationMode? inputMode? validationOutput? RPAREN # noqa E501 	                # validateHRruleset
         """
 
         ctx_list = list(ctx.getChildren())
@@ -986,13 +1063,13 @@ class Expr(VtlVisitor):
         op = c.getSymbol().text
 
         dataset_node = self.visitExpr(ctx_list[2])
-        rule_name_node = Identifier(value=ctx_list[4].getSymbol().text, kind='RuleID')
+        rule_name_node = Identifier(value=ctx_list[4].getSymbol().text, kind="RuleID")
 
         conditions = []
         # Default values
-        modes = 'non_null'
-        inputs = 'dataset'
-        retains = 'invalid'
+        modes = "non_null"
+        inputs = "dataset"
+        retains = "invalid"
         rule_comp = None
         for c in ctx_list:
             if isinstance(c, Parser.ConditionClauseContext):
@@ -1015,9 +1092,9 @@ class Expr(VtlVisitor):
         if inputs == DATASET_PRIORITY:
             raise NotImplementedError("Dataset Priority input mode on HR is not implemented")
 
-        param_constant_node.append(ParamConstant('PARAM_MODE', modes))
-        param_constant_node.append(ParamConstant('PARAM_INPUT', inputs))
-        param_constant_node.append(ParamConstant('PARAM_OUTPUT', retains))
+        param_constant_node.append(ParamConstant("PARAM_MODE", modes))
+        param_constant_node.append(ParamConstant("PARAM_INPUT", inputs))
+        param_constant_node.append(ParamConstant("PARAM_OUTPUT", retains))
 
         if not rule_comp:
             if isinstance(de_ruleset_elements[rule_name_node.value], list):
@@ -1027,16 +1104,19 @@ class Expr(VtlVisitor):
 
             if rule_element.kind == "DatasetID":
                 check_hierarchy_rule = rule_element.value
-                rule_comp = Identifier(check_hierarchy_rule, 'ComponentID')
+                rule_comp = Identifier(check_hierarchy_rule, "ComponentID")
             else:  # ValuedomainID
                 raise SemanticError("1-1-10-4", op=op)
 
-        return ParamOp(op=op, children=[dataset_node, rule_comp, rule_name_node, *conditions],
-                       params=param_constant_node)
+        return ParamOp(
+            op=op,
+            children=[dataset_node, rule_comp, rule_name_node, *conditions],
+            params=param_constant_node,
+        )
 
     def visitValidationSimple(self, ctx: Parser.ValidationSimpleContext):
         """
-          | CHECK LPAREN op=expr (codeErr=erCode)? (levelCode=erLevel)? imbalanceExpr?  output=(INVALID|ALL)? RPAREN													        # validationSimple
+        | CHECK LPAREN op=expr (codeErr=erCode)? (levelCode=erLevel)? imbalanceExpr?  output=(INVALID|ALL)? RPAREN # noqa E501													        # validationSimple
         """
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
@@ -1060,13 +1140,16 @@ class Expr(VtlVisitor):
         if invalid is None:
             invalid_value = False
         else:
-            invalid_value = True if invalid.getSymbol().text == 'invalid' else False
+            invalid_value = True if invalid.getSymbol().text == "invalid" else False
 
-        return Validation(op=token.text, validation=validation_node,
-                          error_code=error_code,
-                          error_level=error_level,
-                          imbalance=inbalance_node,
-                          invalid=invalid_value)
+        return Validation(
+            op=token.text,
+            validation=validation_node,
+            error_code=error_code,
+            error_level=error_level,
+            imbalance=inbalance_node,
+            invalid=invalid_value,
+        )
 
     def visitImbalanceExpr(self, ctx: Parser.ImbalanceExprContext):
         ctx_list = list(ctx.getChildren())
@@ -1074,7 +1157,7 @@ class Expr(VtlVisitor):
 
     """
                             -----------------------------------
-                                    Aggregate Functions             
+                                    Aggregate Functions
                             -----------------------------------
     """
 
@@ -1101,7 +1184,7 @@ class Expr(VtlVisitor):
 
     def visitAggrDataset(self, ctx: Parser.AggrDatasetContext):
         ctx_list = list(ctx.getChildren())
-        c = ctx_list[0]
+        # c = ctx_list[0]
 
         grouping_op = None
         group_node = None
@@ -1117,19 +1200,24 @@ class Expr(VtlVisitor):
             grouping_op, group_node = self.visitGroupingClause(groups[0])
         if len(haves) != 0:
             have_node, expr = self.visitHavingClause(haves[0])
-            setattr(have_node, 'expr', expr)
+            setattr(have_node, "expr", expr)
 
-        return Aggregation(op=op_node, operand=operand, grouping_op=grouping_op,
-                           grouping=group_node, having_clause=have_node)
+        return Aggregation(
+            op=op_node,
+            operand=operand,
+            grouping_op=grouping_op,
+            grouping=group_node,
+            having_clause=have_node,
+        )
 
     """
                             -----------------------------------
-                                    Analytic Functions             
+                                    Analytic Functions
                             -----------------------------------
     """
 
     def visitAnalyticFunctions(self, ctx: Parser.AnalyticFunctionsContext):
-        ctx_list = list(ctx.getChildren())
+        # ctx_list = list(ctx.getChildren())
 
         if isinstance(ctx, Parser.AnSimpleFunctionContext):
             return self.visitAnSimpleFunction(ctx)
@@ -1165,15 +1253,12 @@ class Expr(VtlVisitor):
 
         if window is None:
             window = Windowing(
-                type_='data',
-                start=-1,
-                stop=0,
-                start_mode='preceding',
-                stop_mode='current'
+                type_="data", start=-1, stop=0, start_mode="preceding", stop_mode="current"
             )
 
-        return Analytic(op=op_node, operand=operand, partition_by=partition_by, order_by=order_by,
-                        window=window)
+        return Analytic(
+            op=op_node, operand=operand, partition_by=partition_by, order_by=order_by, window=window
+        )
 
     def visitLagOrLeadAn(self, ctx: Parser.LagOrLeadAnContext):
         ctx_list = list(ctx.getChildren())
@@ -1192,8 +1277,9 @@ class Expr(VtlVisitor):
             elif isinstance(c, Parser.OrderByClauseContext):
                 order_by = Terminals().visitOrderByClause(c)
                 continue
-            elif isinstance(c, Parser.SignedIntegerContext) or isinstance(c,
-                                                                          Parser.ScalarItemContext):
+            elif isinstance(c, Parser.SignedIntegerContext) or isinstance(
+                c, Parser.ScalarItemContext
+            ):
                 if params is None:
                     params = []
                 if isinstance(c, Parser.SignedIntegerContext):
@@ -1206,13 +1292,14 @@ class Expr(VtlVisitor):
             # AST_ASTCONSTRUCTOR.16
             raise Exception(f"{op_node} requires an offset parameter.")
 
-        return Analytic(op=op_node, operand=operand, partition_by=partition_by, order_by=order_by,
-                        params=params)
+        return Analytic(
+            op=op_node, operand=operand, partition_by=partition_by, order_by=order_by, params=params
+        )
 
     def visitRatioToReportAn(self, ctx: Parser.RatioToReportAnContext):
         ctx_list = list(ctx.getChildren())
 
-        params = None
+        # params = None
         order_by = None
 
         op_node = ctx_list[0].getSymbol().text
@@ -1276,7 +1363,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Rename Clause              
+                            Rename Clause
                     -----------------------------------
     """
 
@@ -1286,8 +1373,11 @@ class Expr(VtlVisitor):
         """
         ctx_list = list(ctx.getChildren())
 
-        renames = [ctx_child for ctx_child in ctx_list if
-                   isinstance(ctx_child, Parser.RenameClauseItemContext)]
+        renames = [
+            ctx_child
+            for ctx_child in ctx_list
+            if isinstance(ctx_child, Parser.RenameClauseItemContext)
+        ]
         rename_nodes = []
 
         for ctx_rename in renames:
@@ -1297,13 +1387,13 @@ class Expr(VtlVisitor):
 
     def visitRenameClauseItem(self, ctx: Parser.RenameClauseItemContext):
         """
-            renameClauseItem: fromName=componentID TO toName=componentID;
+        renameClauseItem: fromName=componentID TO toName=componentID;
         """
         ctx_list = list(ctx.getChildren())
 
         left_node = Terminals().visitComponentID(ctx_list[0])
         if isinstance(left_node, BinOp):
-            left_node = f'{left_node.left.value}{left_node.op}{left_node.right.value}'
+            left_node = f"{left_node.left.value}{left_node.op}{left_node.right.value}"
         else:
             left_node = left_node.value
 
@@ -1313,7 +1403,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Aggregate Clause              
+                            Aggregate Clause
                     -----------------------------------
     """
 
@@ -1325,8 +1415,11 @@ class Expr(VtlVisitor):
 
         aggregates_nodes = []
 
-        aggregates = [aggregate for aggregate in ctx_list if
-                      isinstance(aggregate, Parser.AggrFunctionClauseContext)]
+        aggregates = [
+            aggregate
+            for aggregate in ctx_list
+            if isinstance(aggregate, Parser.AggrFunctionClauseContext)
+        ]
 
         for agg in aggregates:
             aggregates_nodes.append(self.visitAggrFunctionClause(agg))
@@ -1348,11 +1441,11 @@ class Expr(VtlVisitor):
             role = Role.MEASURE
 
         left_node = Terminals().visitSimpleComponentId(ctx_list[base_index])
-        op_node = ':='
+        op_node = ":="
         right_node = ExprComp().visitAggregateFunctionsComponents(ctx_list[base_index + 2])
         # Encoding the role information inside the Assignment for easiness and simplicity.
         # Cannot find another way with less lines of code
-        setattr(left_node, 'role', role)
+        setattr(left_node, "role", role)
 
         return Assignment(left_node, op_node, right_node)
 
@@ -1379,21 +1472,25 @@ class Expr(VtlVisitor):
             grouping_op, group_node = self.visitGroupingClause(groups[0])
         if len(haves) > 0:
             have_node, expr = self.visitHavingClause(haves[0])
-            setattr(have_node, 'expr', expr)
+            setattr(have_node, "expr", expr)
         for element in aggregate_nodes:
-            element.right = Aggregation(op=element.right.op, operand=element.right.operand,
-                                        grouping_op=grouping_op, grouping=group_node,
-                                        having_clause=have_node)
+            element.right = Aggregation(
+                op=element.right.op,
+                operand=element.right.operand,
+                grouping_op=grouping_op,
+                grouping=group_node,
+                having_clause=have_node,
+            )
             children.append(copy(element))
 
         return RegularAggregation(op=op_node, children=children)
 
     def visitGroupingClause(self, ctx: Parser.GroupingClauseContext):
         """
-            groupingClause:
-                GROUP op=(BY | EXCEPT) componentID (COMMA componentID)*     # groupByOrExcept
-                | GROUP ALL exprComponent                                   # groupAll
-              ;
+        groupingClause:
+            GROUP op=(BY | EXCEPT) componentID (COMMA componentID)*     # groupByOrExcept
+            | GROUP ALL exprComponent                                   # groupAll
+          ;
         """
         if isinstance(ctx, Parser.GroupByOrExceptContext):
             return self.visitGroupByOrExcept(ctx)
@@ -1410,24 +1507,24 @@ class Expr(VtlVisitor):
         op_node = ctx_list[0].getSymbol().text
 
         text = ctx_list[1].start.source[1].strdata
-        expr = re.split('having', text)[1]
-        expr = 'having ' + expr[:-2].strip()
+        expr = re.split("having", text)[1]
+        expr = "having " + expr[:-2].strip()
 
-        if ']' in expr:
-            index = expr.index(']')
+        if "]" in expr:
+            index = expr.index("]")
             expr = expr[:index]
-        if 'end' in expr:
-            index = expr.index('end')
+        if "end" in expr:
+            index = expr.index("end")
             expr = expr[:index]
-        if expr.count(')') > expr.count('('):
-            index = expr.rindex(')')
+        if expr.count(")") > expr.count("("):
+            index = expr.rindex(")")
             expr = expr[:index]
 
-        if '{' in expr or '}' in expr:
-            expr = expr.replace('{', '(')
-            expr = expr.replace('}', ')')
-        if 'not_in' in expr:
-            expr = expr.replace('not_in', 'not in')
+        if "{" in expr or "}" in expr:
+            expr = expr.replace("{", "(")
+            expr = expr.replace("}", ")")
+        if "not_in" in expr:
+            expr = expr.replace("not_in", "not in")
         if '"' in expr:
             expr = expr.replace('"', "'")
 
@@ -1448,10 +1545,13 @@ class Expr(VtlVisitor):
         token_left = ctx_list[0].getSymbol().text
         token_right = ctx_list[1].getSymbol().text
 
-        op_node = token_left + ' ' + token_right
+        op_node = token_left + " " + token_right
 
-        children_nodes = [Terminals().visitComponentID(identifier) for identifier in ctx_list if
-                          isinstance(identifier, Parser.ComponentIDContext)]
+        children_nodes = [
+            Terminals().visitComponentID(identifier)
+            for identifier in ctx_list
+            if isinstance(identifier, Parser.ComponentIDContext)
+        ]
 
         return op_node, children_nodes
 
@@ -1461,7 +1561,7 @@ class Expr(VtlVisitor):
         token_left = ctx_list[0].getSymbol().text
         token_right = ctx_list[1].getSymbol().text
 
-        op_node = token_left + ' ' + token_right
+        op_node = token_left + " " + token_right
 
         children_nodes = [ExprComp().visitExprComponent(ctx_list[2])]
 
@@ -1469,7 +1569,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Filter Clause              
+                            Filter Clause
                     -----------------------------------
     """
 
@@ -1489,7 +1589,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Calc Clause              
+                            Calc Clause
                     -----------------------------------
     """
 
@@ -1500,8 +1600,11 @@ class Expr(VtlVisitor):
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
-        calcClauseItems = [calcClauseItem for calcClauseItem in ctx_list if
-                           isinstance(calcClauseItem, Parser.CalcClauseItemContext)]
+        calcClauseItems = [
+            calcClauseItem
+            for calcClauseItem in ctx_list
+            if isinstance(calcClauseItem, Parser.CalcClauseItemContext)
+        ]
         calcClauseItems_nodes = []
 
         op_node = c.getSymbol().text
@@ -1522,7 +1625,7 @@ class Expr(VtlVisitor):
             role = Terminals().visitComponentRole(c)
 
             left_node = Terminals().visitComponentID(ctx_list[1])
-            op_node = ':='
+            op_node = ":="
             right_node = ExprComp().visitExprComponent(ctx_list[3])
             operand_node = Assignment(left_node, op_node, right_node)
             if role is None:
@@ -1530,7 +1633,7 @@ class Expr(VtlVisitor):
             return UnaryOp(role.value.lower(), operand_node)
         else:
             left_node = Terminals().visitSimpleComponentId(c)
-            op_node = ':='
+            op_node = ":="
             right_node = ExprComp().visitExprComponent(ctx_list[2])
 
             operand_node = Assignment(left_node, op_node, right_node)
@@ -1555,7 +1658,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Pivot/Unpivot Clause              
+                            Pivot/Unpivot Clause
                     -----------------------------------
     """
 
@@ -1576,19 +1679,22 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Subspace Clause              
+                            Subspace Clause
                     -----------------------------------
     """
 
     def visitSubspaceClause(self, ctx: Parser.SubspaceClauseContext):
         """
-        subspaceClause: SUBSPACE subspaceClauseItem (COMMA subspaceClauseItem)*;        """
+        subspaceClause: SUBSPACE subspaceClauseItem (COMMA subspaceClauseItem)*;"""
         ctx_list = list(ctx.getChildren())
         c = ctx_list[0]
 
         subspace_nodes = []
-        subspaces = [subspace for subspace in ctx_list if
-                     isinstance(subspace, Parser.SubspaceClauseItemContext)]
+        subspaces = [
+            subspace
+            for subspace in ctx_list
+            if isinstance(subspace, Parser.SubspaceClauseItemContext)
+        ]
 
         for subspace in subspaces:
             subspace_nodes.append(self.visitSubspaceClauseItem(subspace))
@@ -1618,4 +1724,4 @@ class Expr(VtlVisitor):
         elif isinstance(c, TerminalNodeImpl):
             token = c.getSymbol()
             opt = token.text
-            return ID('OPTIONAL', opt)
+            return ID("OPTIONAL", opt)