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

vtlengine/AST/ASTConstructorModules/Expr.py

@@ -1,14 +1,34 @@
 import re
 from copy import copy
+from typing import Any
 
 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,
+    Case,
+    CaseObj,
+)
 from vtlengine.AST.ASTConstructorModules.ExprComponents import ExprComp
 from vtlengine.AST.ASTConstructorModules.Terminals import Terminals
 from vtlengine.AST.ASTDataExchange import de_ruleset_elements
@@ -23,27 +43,28 @@ 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
+               | CASE WHEN expr THEN expr ELSE expr END                             # caseExpr # noqa E501
+               | constant														        # constantExpr # noqa E501
+               | varID															        # varIdExpr # noqa E501
         ;
         """
         ctx_list = list(ctx.getChildren())
@@ -98,6 +119,26 @@ class Expr(VtlVisitor):
 
             return if_node
 
+        # CASE WHEN expr THEN expr ELSE expr END                             # caseExpr
+        elif isinstance(c, TerminalNodeImpl) and (c.getSymbol().type == Parser.CASE):
+
+            if len(ctx_list) % 4 != 3:
+                raise ValueError("Syntax error.")
+
+            else_node = self.visitExpr(ctx_list[-1])
+            ctx_list = ctx_list[1:-2]
+            cases = []
+
+            for i in range(0, len(ctx_list), 4):
+                condition = self.visitExpr(ctx_list[i + 1])
+                thenOp = self.visitExpr(ctx_list[i + 3])
+                case_obj = CaseObj(condition, thenOp)
+                cases.append(case_obj)
+
+            case_node = Case(cases, else_node)
+
+            return case_node
+
         # constant
         elif isinstance(ctx, Parser.ConstantExprContext):
             return Terminals().visitConstant(c)
@@ -163,15 +204,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 +299,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Join Functions             
+                                Join Functions
                         -----------------------------------
     """
 
@@ -265,7 +310,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 +342,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 +356,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 +372,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 +387,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 +424,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Generic Functions             
+                                Generic Functions
                         -----------------------------------
     """
 
@@ -400,46 +446,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 +512,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 +553,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 +610,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 +631,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 +649,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Numeric Functions             
+                                Numeric Functions
                         -----------------------------------
     """
 
@@ -624,7 +706,7 @@ class Expr(VtlVisitor):
 
     """
                         -----------------------------------
-                                Comparison Functions             
+                                Comparison Functions
                         -----------------------------------
     """
 
@@ -678,22 +760,27 @@ 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
                             -----------------------------------
         """
 
     def visitTimeFunctions(self, ctx: Parser.TimeFunctionsContext):
         if isinstance(ctx, Parser.PeriodAtomContext):
-            return self.visitPeriodAtom(ctx)
+            # return self.visitPeriodAtom(ctx)
+            return self.visitTimeUnaryAtom(ctx)
         elif isinstance(ctx, Parser.FillTimeAtomContext):
             return self.visitFillTimeAtom(ctx)
         elif isinstance(ctx, Parser.FlowAtomContext):
@@ -704,19 +791,39 @@ class Expr(VtlVisitor):
             return self.visitTimeAggAtom(ctx)
         elif isinstance(ctx, Parser.CurrentDateAtomContext):
             return self.visitCurrentDateAtom(ctx)
+        elif isinstance(ctx, Parser.DateDiffAtomContext):
+            return self.visitTimeDiffAtom(ctx)
+        elif isinstance(ctx, Parser.DateAddAtomContext):
+            return self.visitTimeAddAtom(ctx)
+        elif isinstance(ctx, Parser.YearAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.MonthAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayOfMonthAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayOfYearAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayToYearAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.DayToMonthAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.YearTodayAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
+        elif isinstance(ctx, Parser.MonthTodayAtomContext):
+            return self.visitTimeUnaryAtom(ctx)
         else:
             raise NotImplementedError
 
-    def visitPeriodAtom(self, ctx: Parser.PeriodAtomContext):
-        """
-        periodExpr: PERIOD_INDICATOR '(' expr? ')' ;
-        """
+    def visitTimeUnaryAtom(self, ctx: Any):
         ctx_list = list(ctx.getChildren())
         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
@@ -724,6 +831,26 @@ class Expr(VtlVisitor):
 
         return UnaryOp(op=op, operand=operand_node[0])
 
+    # def visitPeriodAtom(self, ctx: Parser.PeriodAtomContext):
+    #     """
+    #     periodExpr: PERIOD_INDICATOR '(' expr? ')' ;
+    #     """
+    #     ctx_list = list(ctx.getChildren())
+    #     c = ctx_list[0]
+    #
+    #     op = c.getSymbol().text
+    #     operand_node = [
+    #         self.visitExpr(operand)
+    #         for operand in ctx_list
+    #         if isinstance(operand, Parser.ExprContext)
+    #     ]
+    #
+    #     if len(operand_node) == 0:
+    #         # AST_ASTCONSTRUCTOR.15
+    #         raise NotImplementedError
+    #
+    #     return UnaryOp(op=op, operand=operand_node[0])
+
     def visitTimeShiftAtom(self, ctx: Parser.TimeShiftAtomContext):
         """
         timeShiftExpr: TIMESHIFT '(' expr ',' INTEGER_CONSTANT ')' ;
@@ -733,7 +860,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 +875,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 +883,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 +895,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 +919,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())
@@ -803,9 +934,38 @@ class Expr(VtlVisitor):
         c = list(ctx.getChildren())[0]
         return MulOp(op=c.getSymbol().text, children=[])
 
+    def visitTimeDiffAtom(self, ctx: Parser.TimeShiftAtomContext):
+        """ """
+        ctx_list = list(ctx.getChildren())
+        c = ctx_list[0]
+
+        op = c.getSymbol().text
+        left_node = self.visitExpr(ctx_list[2])
+        right_node = self.visitExpr(ctx_list[4])
+
+        return BinOp(left=left_node, op=op, right=right_node)
+
+    def visitTimeAddAtom(self, ctx: Parser.TimeShiftAtomContext):
+        """ """
+
+        ctx_list = list(ctx.getChildren())
+        c = ctx_list[0]
+
+        op = c.getSymbol().text
+        children_node = [self.visitExpr(ctx_list[2])]
+
+        param_constant_node = []
+
+        if len(ctx_list) > 4:
+            param_constant_node = [self.visitExpr(ctx_list[4])]
+            if len(ctx_list) > 6:
+                param_constant_node.append(self.visitExpr(ctx_list[6]))
+
+        return ParamOp(op=op, children=children_node, params=param_constant_node)
+
     """
                             -----------------------------------
-                                    Conditional Functions             
+                                    Conditional Functions
                             -----------------------------------
     """
 
@@ -828,15 +988,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 +1009,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 +1073,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 +1084,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 +1110,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 +1120,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 +1135,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 +1154,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 +1183,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 +1195,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 +1231,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 +1248,7 @@ class Expr(VtlVisitor):
 
     """
                             -----------------------------------
-                                    Aggregate Functions             
+                                    Aggregate Functions
                             -----------------------------------
     """
 
@@ -1101,7 +1275,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 +1291,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 +1344,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 +1368,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 +1383,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 +1454,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Rename Clause              
+                            Rename Clause
                     -----------------------------------
     """
 
@@ -1286,8 +1464,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 +1478,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 +1494,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Aggregate Clause              
+                            Aggregate Clause
                     -----------------------------------
     """
 
@@ -1325,8 +1506,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 +1532,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 +1563,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 +1598,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 +1636,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 +1652,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 +1660,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Filter Clause              
+                            Filter Clause
                     -----------------------------------
     """
 
@@ -1489,7 +1680,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Calc Clause              
+                            Calc Clause
                     -----------------------------------
     """
 
@@ -1500,8 +1691,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 +1716,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 +1724,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 +1749,7 @@ class Expr(VtlVisitor):
 
     """
                     -----------------------------------
-                            Pivot/Unpivot Clause              
+                            Pivot/Unpivot Clause
                     -----------------------------------
     """
 
@@ -1576,19 +1770,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 +1815,4 @@ class Expr(VtlVisitor):
         elif isinstance(c, TerminalNodeImpl):
             token = c.getSymbol()
             opt = token.text
-            return ID('OPTIONAL', opt)
+            return ID("OPTIONAL", opt)