vtlengine 1.0.2__py3-none-any.whl → 1.0.3rc1__py3-none-any.whl

vtlengine/Exceptions/messages.py

@@ -10,7 +10,7 @@ All exceptions exposed by the Vtl engine.
 centralised_messages = {
     # Input Validation errors
     "0-1-2-1": "Invalid json structure because additional properties have been supplied "
-    "on file {filename}.",
+               "on file {filename}.",
     "0-1-2-2": "Errors found on file {filename}: {errors}",
     "0-1-2-3": "Component {component} is duplicated.",
     "0-1-2-4": "Invalid json structure because {err} on file {filename}.",
@@ -22,18 +22,19 @@ centralised_messages = {
     "0-1-1-2": "The provided {source} must have data to can infer the data structure.",
     "0-1-1-3": "Can not infer data structure: {errors}.",
     "0-1-1-4": "On Dataset {name} loading:  An identifier cannot have null values, found null "
-    "values on {null_identifier}.",
+               "values on {null_identifier}.",
     "0-1-1-5": "On Dataset {name} loading: Datasets without identifiers must have 0 or "
-    "1 datapoints.",
+               "1 datapoints.",
     "0-1-1-6": "Duplicated records. Combination of identifiers are repeated.",
     "0-1-1-7": "G1 - The provided CSV file is empty.",
     "0-1-1-8": "The following identifiers {ids} were not found , review file {file}.",
     "0-1-1-9": "You have a problem related with commas, review rfc4180 standard, review file "
-    "{file}.",
+               "{file}.",
     "0-1-1-10": "On Dataset {name} loading: Component {comp_name} is missing in Datapoints.",
     "0-1-1-11": "Wrong data in the file for this scalardataset {name}.",
     "0-1-1-12": "On Dataset {name} loading: not possible to cast column {column} to {type}.",
     "0-1-1-13": "Invalid key on {field} field: {key}{closest_key}.",
+    "0-1-1-14": "Empty datasets {dataset1} and {dataset2} shape missmatch.",
     "0-1-0-1": " Trying to redefine input datasets {dataset}.",  # Semantic Error
     # ------------Operators-------------
     # General Semantic errors
@@ -58,7 +59,7 @@ centralised_messages = {
     "1-1-1-13": "At op {op}: Component {comp_name} role must be '{role_1}', found '{role_2}'.",
     # "1-1-1-14": "At op {op}: Dataset {name} type must be '{type_1}'.",
     "1-1-1-15": "At op {op}: Datasets {name_1} and {name_2} does not contain the same number of "
-    "{type}.",
+                "{type}.",
     "1-1-1-16": "Found structure not nullable and null values.",
     # "1-1-1-17": "At op {op}: Problem with nullability for this components {name_1} and {name_2}.",
     # "1-1-1-18": "No {type} {value} found.",
@@ -75,36 +76,36 @@ centralised_messages = {
     # TODO: Use error message 1-1-1-8
     # "1-1-2-1": "At op {op}: No measures found to aggregate.",
     "1-1-2-2": "At op {op}: Only Identifiers are allowed for grouping, "
-    "found {id_name} - {id_type}.",
+               "found {id_name} - {id_type}.",
     "1-1-2-3": "Having component output type must be boolean, found {type}.",
     # "1-1-2-4": "At op {op}: Component {id_name} not found in dataset",
     # Analytic errors
     # TODO: Use error message 1-1-1-8
     # "1-1-3-1": "At op {op}: No measures found to analyse.",
     "1-1-3-2": "At op {op}: Only Identifiers are allowed for partitioning, "
-    "found {id_name} - {id_type}.",
+               "found {id_name} - {id_type}.",
     # Cast errors
     "1-1-5-1": "Type {type_1}, cannot be cast to {type_2}.",
     "1-1-5-3": "Impossible to cast from type {type_1} to {type_2}, without providing a mask.",
     "1-1-5-4": "Invalid mask to cast from type {type_1} to {type_2}.",
     "1-1-5-5": "A mask can't be provided to cast from type {type_1} to {type_2}. Mask provided: "
-    "{mask_value}.",
+               "{mask_value}.",
     "2-1-5-1": "Impossible to cast {value} from type {type_1} to {type_2}.",
     # Clause errors
     # "1-1-6-1": "At op {op}: Component {comp_name} not found in dataset {dataset_name}.",
     "1-1-6-2": "At op {op}: The identifier {name} in dataset {dataset} could not be included "
-    "in the {op} op.",
+               "in the {op} op.",
     # TODO: This is not possible at all, as calc clause adds a new column and
     #  identifiers are still unique
     # "1-1-6-3": "Found duplicated values on identifiers after Calc clause.",
     "1-1-6-4": "At op {op}: Alias symbol cannot have the name of a component symbol: "
-    "{symbol_name} - {comp_name}.",
+               "{symbol_name} - {comp_name}.",
     "1-1-6-5": "At op {op}: Scalar values are not allowed at sub operator, found {name}.",
     "1-1-6-6": "Membership is not allowed inside a clause, found {dataset_name}#{comp_name}.",
     "1-1-6-7": "Cannot use component {comp_name} as it was generated in another calc expression.",
     # all the components used in calccomp must belong to the operand dataset
     "1-1-6-8": "Cannot use component {comp_name} for rename, it is already in the dataset "
-    "{dataset_name}.",
+               "{dataset_name}.",
     # it is the same error that 1-1-8-1 AND similar but not the same 1-3-1
     "1-1-6-9": "At op {op}: The following components are repeated: {from_components}.",
     "1-1-6-10": "At op {op}: Component {operand} in dataset {dataset_name} is not an identifier",
@@ -115,25 +116,25 @@ centralised_messages = {
     # "1-1-6-15": "At op {op}: Component {comp_name} already exists in dataset {dataset_name}",
     # Comparison errors
     "1-1-7-1": "At op {op}: Value in {left_name} of type {left_type} is not comparable to value "
-    "{right_name} of type {right_type}.",
+               "{right_name} of type {right_type}.",
     # Conditional errors
     "1-1-9-1": "At op {op}: The evaluation condition must result in a Boolean "
-    "expression, found '{type}'.",
+               "expression, found '{type}'.",
     "1-1-9-3": "At op {op}: Then clause {then_name} and else clause {else_name}, both must be "
-    "Scalars.",
+               "Scalars.",
     "1-1-9-4": "At op {op}: The condition dataset {name} must contain an unique measure.",
     "1-1-9-5": "At op {op}: The condition dataset Measure must be a Boolean, found '{type}'.",
     "1-1-9-6": "At op {op}: Then-else datasets have different number of identifiers compared "
-    "with condition dataset.",
+               "with condition dataset.",
     "1-1-9-9": "At op {op}: {clause} component {clause_name} role must be {role_1}, found "
-    "{role_2}.",
+               "{role_2}.",
     "1-1-9-10": "At op {op}: {clause} dataset have different number of identifiers compared with "
-    "condition dataset.",
+                "condition dataset.",
     "1-1-9-11": "At op {op}: Condition component {name} must be Boolean, found {type}.",
     "1-1-9-12": "At op {op}: then clause {then_symbol} and else clause {else_symbol}, both must "
-    "be Datasets or at least one of them a Scalar.",
+                "be Datasets or at least one of them a Scalar.",
     "1-1-9-13": "At op {op}: then {then} and else {else_clause} datasets must contain the same "
-    "number of components.",
+                "number of components.",
     "2-1-9-1": "At op {op}: Condition operators must have the same operator type.",
     "2-1-9-2": "At op {op}: Condition {name} it's not a boolean.",
     "2-1-9-3": "At op {op}: All then and else operands must be scalars.",
@@ -141,21 +142,20 @@ centralised_messages = {
     "2-1-9-5": "At op {op}: Condition Dataset {name} measure must be Boolean.",
     "2-1-9-6": "At op {op}: At least a then or else operand must be Dataset.",
     "2-1-9-7": "At op {op}: All Dataset operands must have the same components.",
-
     # Data Validation errors
     "1-1-10-1": "At op {op}: The {op_type} operand must have exactly one measure of type {me_type}",
     "1-1-10-2": "At op {op}: Number of variable has to be equal between the call and signature.",
     "1-1-10-3": "At op {op}: Name in the call {found} has to be equal to variable rule in "
-    "signature {expected}.",
+                "signature {expected}.",
     "1-1-10-4": "At op {op}: When a hierarchical ruleset is defined for value domain, it is "
-    "necessary to specify the component with the rule clause on call.",
+                "necessary to specify the component with the rule clause on call.",
     "1-1-10-5": "No rules to analyze on Hierarchy Roll-up as rules have no = operator.",
     "1-1-10-6": "At op {op}: Name in the call {found} has to be equal to variable condition in "
-    "signature {expected} .",
+                "signature {expected} .",
     "1-1-10-7": "Not found component {comp_name} on signature.",
     "1-1-10-8": "At op {op}: Measures involved have to be numerical, other types found {found}.",
     "1-1-10-9": "Invalid signature for the ruleset {ruleset}. On variables, condComp and "
-    "ruleComp must be the same",
+                "ruleComp must be the same",
     # General Operators
     # "1-1-12-1": "At op {op}: You could not recalculate the identifier {name} on dataset "
     # "{dataset}.",
@@ -165,49 +165,49 @@ centralised_messages = {
     "1-1-13-1": "At op {op}: Duplicated alias {duplicates}.",
     "1-1-13-2": "At op {op}: Missing mandatory aliasing.",
     "1-1-13-3": "At op {op}: Join conflict with duplicated names for column {name} from original "
-    "datasets.",
+                "datasets.",
     "1-1-13-4": "At op {op}: Using clause, using={using_names}, does not define all the "
-    "identifiers, of non reference dataset {dataset}.",
+                "identifiers, of non reference dataset {dataset}.",
     "1-1-13-5": "At op {op}: Invalid subcase B1, All the datasets must share as identifiers the "
-    "using ones.",
+                "using ones.",
     # not in use but we keep for later, in use 1-1-13-4
     "1-1-13-6": "At op {op}: Invalid subcase B2, All the declared using components "
-    "'{using_components}' must be present as components in the reference dataset "
-    "'{reference}'.",
+                "'{using_components}' must be present as components in the reference dataset "
+                "'{reference}'.",
     "1-1-13-7": "At op {op}: Invalid subcase B2, All the non reference datasets must share as "
-    "identifiers the using ones.",
+                "identifiers the using ones.",
     "1-1-13-8": "At op {op}: No available using clause.",
     "1-1-13-9": "Ambiguity for this variable {comp_name} inside a join clause.",
     "1-1-13-10": "The join operator does not perform scalar/component operations.",
     "1-1-13-11": "At op {op}: Invalid subcase A, {dataset_reference} should be a superset but "
-    "{component} not found.",
+                 "{component} not found.",
     # inner_join and left join
     "1-1-13-12": "At op {op}: Invalid subcase A. There are different identifiers for the provided "
-    "datasets",
+                 "datasets",
     # full_join
     "1-1-13-13": "At op {op}: Invalid subcase A. There are not same number of identifiers for the "
-    "provided datasets",
+                 "provided datasets",
     # full_join
     "1-1-13-14": "Cannot perform a join over a Dataset Without Identifiers: {name}.",
     "1-1-13-15": "At op {op}: {comp_name} has to be a Measure for all the provided datasets inside "
-    "the join",
+                 "the join",
     "1-1-13-16": "At op {op}: Invalid use, please review : {msg}.",
     "1-1-13-17": "At op {op}: {comp_name} not present in the dataset(result from join VDS) at the "
-    "time it is called",
+                 "time it is called",
     # Operators general errors
     "1-1-14-1": "At op {op}: Measure names don't match: {left} - {right}.",
     "1-1-14-3": "At op {op}: Invalid scalar types for identifiers at DataSet {dataset}. One {type} "
-    "identifier expected, {count} found.",
+                "identifier expected, {count} found.",
     "1-1-14-5": "At op {op}: {names} with type/s {types} is not compatible with {op}",
     "1-1-14-6": "At op {op}: {comp_name} with type {comp_type} and scalar_set with type "
-    "{scalar_type} is not compatible with {op}",
+                "{scalar_type} is not compatible with {op}",
     # "1-1-14-8": "At op {op}: Operation not allowed for multimeasure datasets.",
     "1-1-14-9": "At op {op}: {names} with type/s {types} is not compatible with {op} on datasets "
-    "{datasets}.",
+                "{datasets}.",
     # Numeric Operators
     "1-1-15-8": "At op {op}: {op} operator cannot have a {comp_type} as parameter.",
     "2-1-15-1": "At op {op}: Component {comp_name} from dataset {dataset_name} contains negative "
-    "values.",
+                "values.",
     "2-1-15-2": "At op {op}: Value {value} could not be negative.",
     "2-1-15-3": "At op {op}: Base value {value} could not be less or equal 0.",
     "2-1-15-4": "At op {op}: Invalid values in Component {name}.",
@@ -216,7 +216,7 @@ centralised_messages = {
     "2-1-15-7": "At op {op}: {op} operator cannot be a dataset.",
     # Set Operators
     "1-1-17-1": "At op {op}: Datasets {dataset_1} and {dataset_2} have different number of "
-    "components",
+                "components",
     # String Operators
     # "1-1-18-1": "At op {op}: Invalid Dataset {name}. Dataset with one measure expected.",
     "1-1-18-2": "At op {op}: Composition of DataSet and Component is not allowed.",
@@ -230,29 +230,41 @@ centralised_messages = {
     "1-1-19-2": "At op {op}: Unknown date type for {op}.",
     "1-1-19-3": "At op {op}: Invalid {param} for {op}.",
     "1-1-19-4": "At op {op}: Invalid values {value_1} and {value_2}, periodIndTo parameter must be "
-    "a larger duration value than periodIndFrom parameter.",
+                "a larger duration value than periodIndFrom parameter.",
     "1-1-19-5": "At op {op}: periodIndTo parameter must be a larger duration value than the values "
-    "to aggregate.",
+                "to aggregate.",
     "1-1-19-6": "At op {op}: Time type used in the component {comp} is not supported.",
     "1-1-19-7": "At op {op}: can be applied only on Data Sets (of time series) and returns a Data "
-    "Set (of time series).",
+                "Set (of time series).",
     # flow_to_stock, stock_to_flow
     "1-1-19-8": "At op {op}: {op} can only be applied to a {comp_type}",
     "1-1-19-9": "At op {op}: {op} can only be applied to a {comp_type} with a {param}",
+    # New Unary time operators
+    "1-1-19-10": "{op} can only be applied to operands with data type as Date or Time Period",
     # Other time operators
     "2-1-19-1": "At op {op}: Invalid values {value_1} and {value_2} for duration, "
-    "periodIndTo parameter must be a larger duration value than the "
-    "values to aggregate.",
+                "periodIndTo parameter must be a larger duration value than the "
+                "values to aggregate.",
     "2-1-19-2": "Invalid period indicator {period}.",
     "2-1-19-3": "Only same period indicator allowed for both parameters ({period1} != {period2}).",
     "2-1-19-4": "Date setter, ({value} > {date}). Cannot set date1 with a value higher than date2.",
     "2-1-19-5": "Date setter, ({value} < {date}). Cannot set date2 with a value lower than date1.",
     "2-1-19-6": "Invalid period format, must be YYYY-(L)NNN: {period_format}",
     "2-1-19-7": "Period Number must be between 1 and {periods} for period indicator "
-    "{period_indicator}.",
-    "2-1-19-8": "Invalid date format, must be YYYY-MM-DD: {str}",
+                "{period_indicator}.",
+    "2-1-19-8": "Invalid date format, must be YYYY-MM-DD: {date}",
     "2-1-19-9": "Invalid day {day} for year {year}.",
     "2-1-19-10": "Invalid year {year}, must be between 1900 and 9999.",
+    "2-1-19-11": "{op} operator is not compatible with time values",
+    "2-1-19-12": "At op {op}: Invalid param type {type} for param {name}, "
+                 "expected {expected}.",
+    "2-1-19-13": "At op {op}: Invalid param data_type {type} for param {name}, "
+                 "expected {expected}.",
+    "2-1-19-14": "At op {op}: Invalid dataset {name}, requires at least one Date/Time_Period "
+                 "measure.",
+    "2-1-19-15": "{op} can only be applied according to the following mask: PY/YDDD/D",
+    "2-1-19-16": "{op} can only be applied according to the following mask: PM/MDD/D",
+    "2-1-19-17": "{op} can only be positive numbers",
     # ----------- Interpreter Common ------
     "2-3-1": "{comp_type} {comp_name} not found.",
     "2-3-2": "{op_type} cannot be used with {node_op} operators.",
@@ -281,13 +293,13 @@ centralised_messages = {
     "1-3-22": "Unable to categorize {node_value}.",
     "1-3-23": "Missing value domain '{name}' definition, please provide an structure.",
     "1-3-24": "Internal error on Analytic operators inside a calc, No partition or "
-    "order symbol found.",
+              "order symbol found.",
     "1-3-26": "Value domain {name} not found.",
     "1-3-27": "Dataset without identifiers are not allowed in {op} operator.",
     "1-3-28": "At op {op}: invalid number of parameters: received {received}, expected at "
-    "least: {expected}",
+              "least: {expected}",
     "1-3-29": "At op {op}: can not use user defined operator that returns a component outside "
-    "clause operator or rule",
+              "clause operator or rule",
     "1-3-30": "At op {op}: too many parameters: received {received}, expected: {expected}",
     "1-3-31": "Cannot use component {name} outside an aggregate function in a having clause.",
     "1-3-32": "Cannot perform operation {op} inside having clause.",
@@ -301,23 +313,23 @@ centralised_messages = {
     "1-4-1-3": "At op {op}: using variable {value}, not defined as an argument.",
     "1-4-1-4": "Found duplicates at arguments naming, please review {type} " "definition {op}.",
     "1-4-1-5": "Found duplicates at rule naming: {names}. Please review {type} "
-    "{ruleset_name} definition.",
+               "{ruleset_name} definition.",
     "1-4-1-6": "At op {op}: Arguments incoherence, {defined} defined {passed} passed.",
     "1-4-1-7": "All rules must be named or not named, but found mixed criteria at {type} "
-    "definition {name}.",
+               "definition {name}.",
     "1-4-1-8": "All rules must have different code items in the left side of '=' in hierarchy "
-    "operator at hierachical ruleset definition {name}.",
+               "operator at hierachical ruleset definition {name}.",
     "1-4-1-9": "At op check_datapoint: {name} has an invalid datatype expected DataSet, found "
-    "Scalar.",
+               "Scalar.",
     # AST Creation
     "1-4-2-1": "Eval could not be called without a {option} type definition.",
     "1-4-2-2": "Optional or empty expression node is not allowed in time_agg.",
     "1-4-2-3": "{value} could not be called in the count.",
     "1-4-2-4": "At op {op}: Only one order_by element must be used in Analytic with range "
-    "windowing.",
+               "windowing.",
     "1-4-2-5": "At op {op}: User defined operator without returns is not implemented.",
     "1-4-2-6": "At op {op}: Window must be provided.",
     "1-4-2-7": "At op {op}: Partition by or order by clause must be provided for Analytic "
-    "operators.",
+               "operators.",
     # Not Implemented Error
 }

vtlengine/Interpreter/__init__.py

@@ -3,61 +3,35 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
+import pandas as pd
+
 import vtlengine.AST as AST
 import vtlengine.Exceptions
 import vtlengine.Operators as Operators
-import pandas as pd
-from vtlengine.DataTypes import (
-    BASIC_TYPES,
-    check_unary_implicit_promotion,
-    ScalarType,
-    Boolean,
-    SCALAR_TYPES_CLASS_REVERSE,
-)
-from vtlengine.Operators.Aggregation import extract_grouping_identifiers
-from vtlengine.Operators.Assignment import Assignment
-from vtlengine.Operators.CastOperator import Cast
-from vtlengine.Operators.Comparison import Between, ExistIn
-from vtlengine.Operators.Conditional import If, Case
-from vtlengine.Operators.General import Eval
-from vtlengine.Operators.HROperators import get_measure_from_dataset, HAAssignment, Hierarchy
-from vtlengine.Operators.Numeric import Round, Trunc
-from vtlengine.Operators.String import Instr, Replace, Substr
-from vtlengine.Operators.Time import Fill_time_series, Time_Aggregation, Current_Date
-from vtlengine.Operators.Validation import Check, Check_Datapoint, Check_Hierarchy
-from vtlengine.Utils import (
-    AGGREGATION_MAPPING,
-    ANALYTIC_MAPPING,
-    BINARY_MAPPING,
-    JOIN_MAPPING,
-    REGULAR_AGGREGATION_MAPPING,
-    ROLE_SETTER_MAPPING,
-    SET_MAPPING,
-    UNARY_MAPPING,
-    THEN_ELSE,
-    HR_UNARY_MAPPING,
-    HR_COMP_MAPPING,
-    HR_NUM_BINARY_MAPPING,
-)
-from vtlengine.files.output import save_datapoints
-from vtlengine.files.output._time_period_representation import TimePeriodRepresentation
-from vtlengine.files.parser import load_datapoints, _fill_dataset_empty_data
-
 from vtlengine.AST.ASTTemplate import ASTTemplate
 from vtlengine.AST.DAG import HRDAGAnalyzer
-from vtlengine.AST.DAG._words import GLOBAL, DELETE, INSERT
+from vtlengine.AST.DAG._words import DELETE, GLOBAL, INSERT
 from vtlengine.AST.Grammar.tokens import (
     AGGREGATE,
     ALL,
     APPLY,
     AS,
     BETWEEN,
+    CALC,
+    CAST,
     CHECK_DATAPOINT,
+    CHECK_HIERARCHY,
+    COUNT,
+    CURRENT_DATE,
+    DATE_ADD,
     DROP,
+    EQ,
     EXISTS_IN,
     EXTERNAL,
+    FILL_TIME_SERIES,
     FILTER,
     HAVING,
+    HIERARCHY,
     INSTR,
     KEEP,
     MEMBERSHIP,
@@ -66,26 +40,53 @@ from vtlengine.AST.Grammar.tokens import (
     SUBSTR,
     TRUNC,
     WHEN,
-    FILL_TIME_SERIES,
-    CAST,
-    CHECK_HIERARCHY,
-    HIERARCHY,
-    EQ,
-    CURRENT_DATE,
-    CALC,
-    COUNT,
+)
+from vtlengine.DataTypes import (
+    BASIC_TYPES,
+    SCALAR_TYPES_CLASS_REVERSE,
+    Boolean,
+    ScalarType,
+    check_unary_implicit_promotion,
 )
 from vtlengine.Exceptions import SemanticError
+from vtlengine.files.output import save_datapoints
+from vtlengine.files.output._time_period_representation import TimePeriodRepresentation
+from vtlengine.files.parser import _fill_dataset_empty_data, load_datapoints
 from vtlengine.Model import (
+    Component,
     DataComponent,
     Dataset,
     ExternalRoutine,
     Role,
     Scalar,
     ScalarSet,
-    Component,
     ValueDomain,
 )
+from vtlengine.Operators.Aggregation import extract_grouping_identifiers
+from vtlengine.Operators.Assignment import Assignment
+from vtlengine.Operators.CastOperator import Cast
+from vtlengine.Operators.Comparison import Between, ExistIn
+from vtlengine.Operators.Conditional import Case, If
+from vtlengine.Operators.General import Eval
+from vtlengine.Operators.HROperators import HAAssignment, Hierarchy, get_measure_from_dataset
+from vtlengine.Operators.Numeric import Round, Trunc
+from vtlengine.Operators.String import Instr, Replace, Substr
+from vtlengine.Operators.Time import Current_Date, Date_Add, Fill_time_series, Time_Aggregation
+from vtlengine.Operators.Validation import Check, Check_Datapoint, Check_Hierarchy
+from vtlengine.Utils import (
+    AGGREGATION_MAPPING,
+    ANALYTIC_MAPPING,
+    BINARY_MAPPING,
+    HR_COMP_MAPPING,
+    HR_NUM_BINARY_MAPPING,
+    HR_UNARY_MAPPING,
+    JOIN_MAPPING,
+    REGULAR_AGGREGATION_MAPPING,
+    ROLE_SETTER_MAPPING,
+    SET_MAPPING,
+    THEN_ELSE,
+    UNARY_MAPPING,
+)
 
 
 # noinspection PyTypeChecker
@@ -200,9 +201,9 @@ class InterpreterAnalyzer(ASTTemplate):
             if isinstance(child, (AST.Assignment, AST.PersistentAssignment)):
                 vtlengine.Exceptions.dataset_output = child.left.value  # type: ignore[attr-defined]
                 self._load_datapoints_efficient(statement_num)
-            if not isinstance(child, (AST.HRuleset, AST.DPRuleset, AST.Operator)):
-                if not isinstance(child, (AST.Assignment, AST.PersistentAssignment)):
-                    raise SemanticError("1-3-17")
+            if (not isinstance(child, (AST.HRuleset, AST.DPRuleset, AST.Operator)) and
+                    not isinstance(child, (AST.Assignment, AST.PersistentAssignment))):
+                raise SemanticError("1-3-17")
             result = self.visit(child)
 
             # Reset some handlers (joins and if)
@@ -368,14 +369,14 @@ class InterpreterAnalyzer(ASTTemplate):
             is_from_if = self.is_from_if
             self.is_from_if = False
 
-        if self.is_from_join and node.op in [MEMBERSHIP, AGGREGATE]:
-            if hasattr(node.left, "value") and hasattr(node.right, "value"):
-                if self.udo_params is not None and node.right.value in self.udo_params[-1]:
-                    comp_name = f"{node.left.value}#{self.udo_params[-1][node.right.value]}"
-                else:
-                    comp_name = f"{node.left.value}#{node.right.value}"
-                ast_var_id = AST.VarID(value=comp_name)
-                return self.visit(ast_var_id)
+        if (self.is_from_join and node.op in [MEMBERSHIP, AGGREGATE] and
+                hasattr(node.left, "value") and hasattr(node.right, "value")):
+            if self.udo_params is not None and node.right.value in self.udo_params[-1]:
+                comp_name = f"{node.left.value}#{self.udo_params[-1][node.right.value]}"
+            else:
+                comp_name = f"{node.left.value}#{node.right.value}"
+            ast_var_id = AST.VarID(value=comp_name)
+            return self.visit(ast_var_id)
         left_operand = self.visit(node.left)
         right_operand = self.visit(node.right)
         if is_from_if:
@@ -453,10 +454,7 @@ class InterpreterAnalyzer(ASTTemplate):
         grouping_op = node.grouping_op
         if node.grouping is not None:
             if grouping_op == "group all":
-                if self.only_semantic:
-                    data = None
-                else:
-                    data = copy(operand.data)
+                data = None if self.only_semantic else copy(operand.data)
                 self.aggregation_dataset = Dataset(
                     name=operand.name, components=operand.components, data=data
                 )
@@ -730,7 +728,7 @@ class InterpreterAnalyzer(ASTTemplate):
                 nullable=self.aggregation_dataset.components[node.value].nullable,
             )
         if self.is_from_regular_aggregation:
-            if self.is_from_join and node.value in self.datasets.keys():
+            if self.is_from_join and node.value in self.datasets:
                 return self.datasets[node.value]
             if self.regular_aggregation_dataset is not None:
                 if node.value in self.datasets and isinstance(self.datasets[node.value], Scalar):
@@ -746,10 +744,8 @@ class InterpreterAnalyzer(ASTTemplate):
                         is_partial_present = 0
                         found_comp = None
                         for comp_name in self.regular_aggregation_dataset.get_components_names():
-                            if "#" in comp_name and comp_name.split("#")[1] == node.value:
-                                is_partial_present += 1
-                                found_comp = comp_name
-                            elif "#" in node.value and node.value.split("#")[1] == comp_name:
+                            if ("#" in comp_name and comp_name.split("#")[1] == node.value or "#"
+                                    in node.value and node.value.split("#")[1] == comp_name):
                                 is_partial_present += 1
                                 found_comp = comp_name
                         if is_partial_present == 0:
@@ -789,10 +785,7 @@ class InterpreterAnalyzer(ASTTemplate):
                 raise SemanticError(
                     "1-1-1-10", comp_name=node.value, dataset_name=self.ruleset_dataset.name
                 )
-            if self.rule_data is None:
-                data = None
-            else:
-                data = self.rule_data[comp_name]
+            data = None if self.rule_data is None else self.rule_data[comp_name]
             return DataComponent(
                 name=comp_name,
                 data=data,
@@ -809,10 +802,7 @@ class InterpreterAnalyzer(ASTTemplate):
             elements = []
             duplicates = []
             for child in node.children:
-                if isinstance(child, AST.ParamOp):
-                    ref_element = child.children[1]
-                else:
-                    ref_element = child
+                ref_element = child.children[1] if isinstance(child, AST.ParamOp) else child
                 if ref_element in elements:
                     duplicates.append(ref_element)
                 elements.append(self.visit(child).value)
@@ -849,9 +839,8 @@ class InterpreterAnalyzer(ASTTemplate):
             self.is_from_regular_aggregation = True
             operands.append(self.visit(child))
             self.is_from_regular_aggregation = False
-        if node.op == CALC:
-            if any([isinstance(operand, Dataset) for operand in operands]):
-                raise SemanticError("1-3-35", op=node.op)
+        if node.op == CALC and any(isinstance(operand, Dataset) for operand in operands):
+            raise SemanticError("1-3-35", op=node.op)
         if node.op == AGGREGATE:
             # Extracting the role encoded inside the children assignments
             role_info = {
@@ -1056,11 +1045,7 @@ class InterpreterAnalyzer(ASTTemplate):
     def visit_ParamOp(self, node: AST.ParamOp) -> None:  # noqa: C901
         if node.op == ROUND:
             op_element = self.visit(node.children[0])
-            if len(node.params) != 0:
-                param_element = self.visit(node.params[0])
-            else:
-                param_element = None
-
+            param_element = self.visit(node.params[0]) if len(node.params) != 0 else None
             return Round.analyze(op_element, param_element)
 
         # Numeric Operator
@@ -1116,6 +1101,9 @@ class InterpreterAnalyzer(ASTTemplate):
         elif node.op == FILL_TIME_SERIES:
             mode = self.visit(node.params[0]) if len(node.params) == 1 else "all"
             return Fill_time_series.analyze(self.visit(node.children[0]), mode)
+        elif node.op == DATE_ADD:
+            params = [self.visit(node.params[0]), self.visit(node.params[1])]
+            return Date_Add.analyze(self.visit(node.children[0]), params)
         elif node.op == CAST:
             operand = self.visit(node.children[0])
             scalar_type = node.children[1]
@@ -1234,11 +1222,8 @@ class InterpreterAnalyzer(ASTTemplate):
                 if node.op == HIERARCHY:
                     aux = []
                     for rule in hr_info["rules"]:
-                        if rule.rule.op == EQ:
+                        if rule.rule.op == EQ or rule.rule.op == WHEN and rule.rule.right.op == EQ:
                             aux.append(rule)
-                        elif rule.rule.op == WHEN:
-                            if rule.rule.right.op == EQ:
-                                aux.append(rule)
                     # Filter only the rules with HRBinOP as =,
                     # as they are the ones that will be computed
                     if len(aux) == 0:
@@ -1411,12 +1396,10 @@ class InterpreterAnalyzer(ASTTemplate):
                     left_operand.data = pd.DataFrame({measure_name: []})
                 if right_operand.data is None:
                     right_operand.data = pd.DataFrame({measure_name: []})
-                left_null_indexes = set(
-                    list(left_operand.data[left_operand.data[measure_name].isnull()].index)
-                )
-                right_null_indexes = set(
-                    list(right_operand.data[right_operand.data[measure_name].isnull()].index)
-                )
+                left_null_indexes = set(left_operand.data[left_operand.data[
+                    measure_name].isnull()].index)
+                right_null_indexes = set(right_operand.data[right_operand.data[
+                    measure_name].isnull()].index)
                 # If no indexes are in common, then one datapoint is not null
                 invalid_indexes = list(left_null_indexes.intersection(right_null_indexes))
                 if len(invalid_indexes) > 0:
@@ -1504,10 +1487,7 @@ class InterpreterAnalyzer(ASTTemplate):
             if condition.data_type != BASIC_TYPES[bool]:
                 raise ValueError("Only boolean scalars are allowed on data component condition")
             name = condition.name
-            if condition.data is None:
-                data = None
-            else:
-                data = condition.data
+            data = None if condition.data is None else condition.data
 
         if data is not None:
             if self.nested_condition and self.condition_stack is not None:
@@ -1518,8 +1498,7 @@ class InterpreterAnalyzer(ASTTemplate):
                 )
                 indexes = merge_df.data[merge_df.data.columns[-1]]
             else:
-                indexes = data.index
-            data = data.fillna(False)
+                indexes = data[data.notnull()].index
 
             if isinstance(condition, Dataset):
                 filtered_data = data.iloc[indexes]
@@ -1644,8 +1623,7 @@ class InterpreterAnalyzer(ASTTemplate):
         # Getting Dataset elements
         result_components = {
             comp_name: copy(comp)
-            for comp_name, comp in
-            self.ruleset_dataset.components.items()  # type: ignore[union-attr]
+            for comp_name, comp in self.ruleset_dataset.components.items()  # type: ignore[union-attr]
         }
         if self.ruleset_signature is not None:
             hr_component = self.ruleset_signature["RULE_COMPONENT"]
@@ -1759,8 +1737,9 @@ class InterpreterAnalyzer(ASTTemplate):
                         signature_values[param["name"]] = self.visit(node.params[i])
                     elif param["type"] in ["Dataset", "Component"]:
                         if isinstance(node.params[i], AST.VarID):
-                            signature_values[param["name"]] = (
-                                node.params[i].value)  # type: ignore[attr-defined]
+                            signature_values[param["name"]] = node.params[
+                                i
+                            ].value  # type: ignore[attr-defined]
                         else:
                             param_element = self.visit(node.params[i])
                             if isinstance(param_element, Dataset):