vtlengine 1.0.3rc3__py3-none-any.whl → 1.1__py3-none-any.whl

vtlengine/AST/VtlVisitor.py

@@ -6,7 +6,6 @@ from vtlengine.AST.Grammar.parser import Parser
 
 
 class VtlVisitor(ParseTreeVisitor):
-
     # Visit a parse tree produced by Parser#start.
     def visitStart(self, ctx: Parser.StartContext):
         return self.visitChildren(ctx)

vtlengine/AST/__init__.py

@@ -11,7 +11,7 @@ from dataclasses import dataclass
 from typing import Any, Dict, List, Optional, Type, Union
 
 from vtlengine.DataTypes import ScalarType
-from vtlengine.Model import Role
+from vtlengine.Model import Dataset, Role
 
 
 @dataclass
@@ -20,6 +20,11 @@ class AST:
     AST: (children)
     """
 
+    line_start: int
+    column_start: int
+    line_stop: int
+    column_stop: int
+
     @classmethod
     def __all_annotations(cls) -> Dict[str, Any]:
         class_attributes = {}
@@ -47,6 +52,30 @@ class AST:
 
     __repr__ = __str__
 
+    def ast_equality(self, other):
+        if not isinstance(other, self.__class__):
+            return False
+        for k in self.__all_annotations():
+            if (
+                getattr(self, k) != getattr(other, k)
+                and k not in AST.__annotations__
+                and k != "children"  # We do not want to compare the children order here
+            ):
+                return False
+        return True
+
+    __eq__ = ast_equality
+
+
+@dataclass
+class Comment(AST):
+    """
+    Comment: (value)
+    """
+
+    value: str
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Start(AST):
@@ -56,6 +85,8 @@ class Start(AST):
 
     children: List[AST]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Assignment(AST):
@@ -67,6 +98,8 @@ class Assignment(AST):
     op: str
     right: AST
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class PersistentAssignment(Assignment):
@@ -85,7 +118,9 @@ class VarID(AST):
     Could be: DATASET or a COMPONENT.
     """
 
-    value: Any
+    value: str
+
+    __eq__ = AST.ast_equality
 
 
 @dataclass
@@ -100,6 +135,8 @@ class UnaryOp(AST):
     op: str
     operand: AST
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class BinOp(AST):
@@ -113,6 +150,8 @@ class BinOp(AST):
     op: str
     right: AST
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class MulOp(AST):
@@ -124,6 +163,8 @@ class MulOp(AST):
     op: str
     children: List[AST]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class ParamOp(AST):
@@ -137,12 +178,16 @@ class ParamOp(AST):
     children: List[AST]
     params: List[AST]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class UDOCall(AST):
     op: str
     params: List[AST]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class JoinOp(AST):
@@ -156,9 +201,11 @@ class JoinOp(AST):
 
     op: str
     clauses: List[AST]
-    using: Optional[List[AST]]
+    using: Optional[List[str]]
     isLast: bool = False
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Constant(AST):
@@ -172,6 +219,8 @@ class Constant(AST):
     type_: str
     value: Optional[Union[str, int, float, bool]]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class ParamConstant(Constant):
@@ -184,6 +233,8 @@ class ParamConstant(Constant):
     type_: str
     value: str
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Identifier(AST):
@@ -194,6 +245,8 @@ class Identifier(AST):
     value: str
     kind: str
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class ID(AST):
@@ -206,6 +259,8 @@ class ID(AST):
     type_: str
     value: str
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Collection(AST):
@@ -220,6 +275,8 @@ class Collection(AST):
     children: List[AST]
     kind: str = "Set"
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Windowing(AST):
@@ -234,11 +291,13 @@ class Windowing(AST):
     """
 
     type_: str
-    start: str
+    start: Union[int, str]
     start_mode: str
     stop: Union[int, str]
     stop_mode: str
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class OrderBy(AST):
@@ -249,6 +308,8 @@ class OrderBy(AST):
         if self.order not in ["asc", "desc"]:
             raise ValueError(f"Invalid order: {self.order}")
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Analytic(AST):
@@ -274,6 +335,8 @@ class Analytic(AST):
         if self.partition_by is None and self.order_by is None:
             raise ValueError("Partition by or order by must be provided on Analytic.")
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class RegularAggregation(AST):
@@ -288,6 +351,8 @@ class RegularAggregation(AST):
     dataset: Optional[AST] = None
     isLast: bool = False
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class RenameNode(AST):
@@ -298,6 +363,8 @@ class RenameNode(AST):
     old_name: str
     new_name: str
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Aggregation(AST):
@@ -316,6 +383,8 @@ class Aggregation(AST):
     grouping: Optional[List[AST]] = None
     having_clause: Optional[AST] = None
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class TimeAggregation(AST):
@@ -331,6 +400,8 @@ class TimeAggregation(AST):
     operand: Optional[AST] = None
     conf: Optional[str] = None
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class If(AST):
@@ -342,15 +413,14 @@ class If(AST):
     thenOp: AST
     elseOp: AST
 
+    __eq__ = AST.ast_equality
+
 
-class CaseObj:
+@dataclass
+class CaseObj(AST):
     condition: AST
     thenOp: AST
 
-    def __init__(self, condition: AST, thenOp: AST):
-        self.condition = condition
-        self.thenOp = thenOp
-
 
 @dataclass
 class Case(AST):
@@ -361,6 +431,8 @@ class Case(AST):
     cases: List[CaseObj]
     elseOp: AST
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Validation(AST):
@@ -375,6 +447,8 @@ class Validation(AST):
     imbalance: Optional[AST]
     invalid: bool
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class ComponentType(AST):
@@ -386,6 +460,8 @@ class ComponentType(AST):
     data_type: Optional[Type[ScalarType]] = None
     role: Optional[Role] = None
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class ASTScalarType(AST):
@@ -400,6 +476,8 @@ class DatasetType(AST):
 
     components: List[ComponentType]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Types(AST):
@@ -418,6 +496,8 @@ class Types(AST):
     nullable: Optional[bool]
     name: Optional[str] = None
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Argument(AST):
@@ -429,6 +509,8 @@ class Argument(AST):
     type_: Type[ScalarType]
     default: Optional[AST]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class Operator(AST):
@@ -441,6 +523,8 @@ class Operator(AST):
     output_type: str
     expression: AST
 
+    __eq__ = AST.ast_equality
+
 
 # TODO: Is this class necessary?
 @dataclass
@@ -452,6 +536,8 @@ class DefIdentifier(AST):
     value: str
     kind: str
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class DPRIdentifier(AST):
@@ -463,6 +549,8 @@ class DPRIdentifier(AST):
     kind: str
     alias: Optional[str] = None
 
+    __eq__ = AST.ast_equality
+
 
 # TODO: Are HRBinOp and HRUnOp necessary?
 @dataclass
@@ -476,6 +564,8 @@ class HRBinOp(AST):
     op: str
     right: DefIdentifier
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class HRUnOp(AST):
@@ -487,6 +577,8 @@ class HRUnOp(AST):
     op: str
     operand: DefIdentifier
 
+    __eq__ = AST.ast_equality
+
 
 # TODO: Unify HRule and DPRule?
 @dataclass
@@ -497,8 +589,10 @@ class HRule(AST):
 
     name: Optional[str]
     rule: HRBinOp
-    erCode: Optional[Constant]
-    erLevel: Optional[Constant]
+    erCode: Optional[str]
+    erLevel: Optional[int]
+
+    __eq__ = AST.ast_equality
 
 
 @dataclass
@@ -509,8 +603,10 @@ class DPRule(AST):
 
     name: Optional[str]
     rule: HRBinOp
-    erCode: Optional[Constant]
-    erLevel: Optional[Constant]
+    erCode: Optional[str]
+    erLevel: Optional[int]
+
+    __eq__ = AST.ast_equality
 
 
 # TODO: Unify HRuleset and DPRuleset?
@@ -525,6 +621,8 @@ class HRuleset(AST):
     element: DefIdentifier
     rules: List[HRule]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class DPRuleset(AST):
@@ -537,6 +635,8 @@ class DPRuleset(AST):
     params: Union[DefIdentifier, list]
     rules: List[DPRule]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class EvalOp(AST):
@@ -548,9 +648,11 @@ class EvalOp(AST):
 
     name: str
     operands: List[AST]
-    output: Optional[str]
+    output: Optional[Dataset]
     language: Optional[str]
 
+    __eq__ = AST.ast_equality
+
 
 @dataclass
 class NoOp(AST):
@@ -559,3 +661,14 @@ class NoOp(AST):
     """
 
     pass
+
+
+@dataclass
+class ParFunction(AST):
+    """
+    ParFunction: (operand)
+    """
+
+    operand: AST
+
+    __eq__ = AST.ast_equality

vtlengine/DataTypes/TimeHandling.py

@@ -9,9 +9,9 @@ import pandas as pd
 
 from vtlengine.Exceptions import SemanticError
 
-DURATION_MAPPING = {"A": 6, "S": 5, "Q": 4, "M": 3, "W": 2, "D": 1}
+PERIOD_IND_MAPPING = {"A": 6, "S": 5, "Q": 4, "M": 3, "W": 2, "D": 1}
 
-DURATION_MAPPING_REVERSED = {6: "A", 5: "S", 4: "Q", 3: "M", 2: "W", 1: "D"}
+PERIOD_IND_MAPPING_REVERSE = {6: "A", 5: "S", 4: "Q", 3: "M", 2: "W", 1: "D"}
 
 PERIOD_INDICATORS = ["A", "S", "Q", "M", "W", "D"]
 
@@ -32,15 +32,16 @@ def date_to_period(date_value: date, period_indicator: str) -> Any:
         return TimePeriodHandler(f"{date_value.year}D{date_value.timetuple().tm_yday}")
 
 
-def period_to_date(year: int,
-                   period_indicator: str,
-                   period_number: int,
-                   start: bool = False
-                   ) -> date:
+def period_to_date(
+    year: int, period_indicator: str, period_number: int, start: bool = False
+) -> date:
     if period_indicator == "A":
         return date(year, 1, 1) if start else date(year, 12, 31)
     periods = {
-        "S": [(date(year, 1, 1), date(year, 6, 30)), (date(year, 7, 1), date(year, 12, 31))],
+        "S": [
+            (date(year, 1, 1), date(year, 6, 30)),
+            (date(year, 7, 1), date(year, 12, 31)),
+        ],
         "Q": [
             (date(year, 1, 1), date(year, 3, 31)),
             (date(year, 4, 1), date(year, 6, 30)),
@@ -202,6 +203,10 @@ class TimePeriodHandler:
             raise SemanticError("2-1-19-2", period=value)
         self._period_indicator = value
 
+    @property
+    def period_magnitude(self) -> int:
+        return PERIOD_IND_MAPPING[self.period_indicator]
+
     @property
     def period_number(self) -> int:
         return self._period_number
@@ -229,16 +234,46 @@ class TimePeriodHandler:
                     # raise ValueError(f'Invalid day {value} for year {self.year}.')
         self._period_number = value
 
+    @property
+    def period_dates(self) -> tuple[date, date]:
+        return (
+            period_to_date(self.year, self.period_indicator, self.period_number, start=True),
+            period_to_date(self.year, self.period_indicator, self.period_number, start=False),
+        )
+
     def _meta_comparison(self, other: Any, py_op: Any) -> Optional[bool]:
         if pd.isnull(other):
             return None
+
+        if py_op in (operator.eq, operator.ne):
+            return py_op(str(self), str(other))
+
+        if py_op in (operator.ge, operator.le) and str(self) == str(other):
+            return True
+
         if isinstance(other, str):
-            if len(other) == 0:
-                return False
             other = TimePeriodHandler(other)
-        return py_op(
-            DURATION_MAPPING[self.period_indicator], DURATION_MAPPING[other.period_indicator]
-        )
+
+        self_lapse, other_lapse = self.period_dates, other.period_dates
+        is_lt_or_le = py_op in [operator.lt, operator.le]
+        is_gt_or_ge = py_op in [operator.gt, operator.ge]
+
+        if is_lt_or_le or is_gt_or_ge:
+            idx = 0 if is_lt_or_le else 1
+            if self_lapse[idx] != other_lapse[idx]:
+                return (
+                    self_lapse[idx] < other_lapse[idx]
+                    if is_lt_or_le
+                    else self_lapse[idx] > other_lapse[idx]
+                )
+            if self.period_magnitude != other.period_magnitude:
+                return (
+                    self.period_magnitude < other.period_magnitude
+                    if is_lt_or_le
+                    else self.period_magnitude > other.period_magnitude
+                )
+
+        return False
 
     def start_date(self, as_date: bool = False) -> Union[date, str]:
         """
@@ -453,7 +488,7 @@ def shift_period(x: TimePeriodHandler, shift_param: int) -> TimePeriodHandler:
 def sort_time_period(series: Any) -> Any:
     values_sorted = sorted(
         series.to_list(),
-        key=lambda s: (s.year, DURATION_MAPPING[s.period_indicator], s.period_number),
+        key=lambda s: (s.year, PERIOD_IND_MAPPING[s.period_indicator], s.period_number),
     )
     return pd.Series(values_sorted, name=series.name)
 
@@ -478,7 +513,7 @@ def generate_period_range(
 
 
 def check_max_date(str_: Optional[str]) -> Optional[str]:
-    if pd.isnull(str_) or str_ == "nan" or str_ == "NaT":
+    if pd.isnull(str_) or str_ == "nan" or str_ == "NaT" or str_ is None:
         return None
 
     if len(str_) == 9 and str_[7] == "-":

vtlengine/DataTypes/__init__.py

@@ -1,8 +1,13 @@
+import re
 from typing import Any, Dict, Optional, Set, Type, Union
 
 import pandas as pd
 
-from vtlengine.DataTypes.TimeHandling import check_max_date, date_to_period_str, str_period_to_date
+from vtlengine.DataTypes.TimeHandling import (
+    check_max_date,
+    date_to_period_str,
+    str_period_to_date,
+)
 from vtlengine.Exceptions import SemanticError
 
 DTYPE_MAPPING: Dict[str, str] = {
@@ -397,10 +402,19 @@ class TimePeriod(TimeInterval):
 
 
 class Duration(ScalarType):
+    iso8601_duration_pattern = r"^P((\d+Y)?(\d+M)?(\d+D)?)$"
+
+    @classmethod
+    def validate_duration(cls, value: Any) -> bool:
+        try:
+            match = re.match(cls.iso8601_duration_pattern, value)
+            return bool(match)
+        except Exception:
+            raise Exception("Must be valid")
 
     @classmethod
     def implicit_cast(cls, value: Any, from_type: Any) -> str:
-        if from_type in {Duration, String}:
+        if from_type == String and cls.validate_duration(value):
             return value
 
         raise SemanticError(
@@ -412,7 +426,7 @@ class Duration(ScalarType):
 
     @classmethod
     def explicit_cast(cls, value: Any, from_type: Any) -> Any:
-        if from_type == String:
+        if from_type == String and cls.validate_duration(value):
             return value
 
         raise SemanticError(
@@ -422,6 +436,31 @@ class Duration(ScalarType):
             type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
         )
 
+    @classmethod
+    def to_days(cls, value: Any) -> int:
+        if not cls.validate_duration(value):
+            raise SemanticError(
+                "2-1-19-15", "{op} can only be applied according to the iso 8601 format mask"
+            )
+
+        match = re.match(cls.iso8601_duration_pattern, value)
+
+        years = 0
+        months = 0
+        days = 0
+
+        years_str = match.group(2)  # type: ignore[union-attr]
+        months_str = match.group(3)  # type: ignore[union-attr]
+        days_str = match.group(4)  # type: ignore[union-attr]
+        if years_str:
+            years = int(years_str[:-1])
+        if months_str:
+            months = int(months_str[:-1])
+        if days_str:
+            days = int(days_str[:-1])
+        total_days = years * 365 + months * 30 + days
+        return int(total_days)
+
 
 class Boolean(ScalarType):
     """ """
@@ -549,7 +588,17 @@ IMPLICIT_TYPE_PROMOTION_MAPPING: Dict[Type[ScalarType], Any] = {
     TimePeriod: {TimeInterval, TimePeriod},
     Duration: {Duration},
     Boolean: {String, Boolean},
-    Null: {String, Number, Integer, TimeInterval, Date, TimePeriod, Duration, Boolean, Null},
+    Null: {
+        String,
+        Number,
+        Integer,
+        TimeInterval,
+        Date,
+        TimePeriod,
+        Duration,
+        Boolean,
+        Null,
+    },
 }
 
 # TODO: Implicit are valid as cast without mask
@@ -564,7 +613,17 @@ EXPLICIT_WITHOUT_MASK_TYPE_PROMOTION_MAPPING: Dict[Type[ScalarType], Any] = {
     TimePeriod: {TimePeriod, String},
     Duration: {Duration, String},
     Boolean: {Integer, Number, String, Boolean},
-    Null: {String, Number, Integer, TimeInterval, Date, TimePeriod, Duration, Boolean, Null},
+    Null: {
+        String,
+        Number,
+        Integer,
+        TimeInterval,
+        Date,
+        TimePeriod,
+        Duration,
+        Boolean,
+        Null,
+    },
 }
 
 EXPLICIT_WITH_MASK_TYPE_PROMOTION_MAPPING: Dict[Type[ScalarType], Any] = {
@@ -576,7 +635,17 @@ EXPLICIT_WITH_MASK_TYPE_PROMOTION_MAPPING: Dict[Type[ScalarType], Any] = {
     TimePeriod: {Date},
     Duration: {String},
     Boolean: {},
-    Null: {String, Number, Integer, TimeInterval, Date, TimePeriod, Duration, Boolean, Null},
+    Null: {
+        String,
+        Number,
+        Integer,
+        TimeInterval,
+        Date,
+        TimePeriod,
+        Duration,
+        Boolean,
+        Null,
+    },
 }
 
 
@@ -634,7 +703,10 @@ def binary_implicit_promotion(
 
 
 def check_binary_implicit_promotion(
-    left: Type[ScalarType], right: Any, type_to_check: Any = None, return_type: Any = None
+    left: Type[ScalarType],
+    right: Any,
+    type_to_check: Any = None,
+    return_type: Any = None,
 ) -> bool:
     """
     Validates the compatibility between the types of the operands and the operator

vtlengine/Exceptions/__init__.py

@@ -124,7 +124,7 @@ class InputValidationException(VTLEngineException):
         lino: Optional[str] = None,
         colno: Optional[str] = None,
         code: Optional[str] = None,
-        **kwargs: Any
+        **kwargs: Any,
     ) -> None:
         if code is not None:
             message = centralised_messages[code].format(**kwargs)
@@ -143,7 +143,7 @@ def check_key(field: str, dict_keys: Any, key: str) -> None:
 def find_closest_key(dict_keys: Any, key: str) -> Optional[str]:
     closest_key = None
     max_distance = 3
-    min_distance = float('inf')
+    min_distance = float("inf")
 
     for dict_key in dict_keys:
         distance = key_distance(key, dict_key)
@@ -167,8 +167,6 @@ def key_distance(key: str, objetive: str) -> int:
     for i in range(1, len(key) + 1):
         for j in range(1, len(objetive) + 1):
             cost = 0 if key[i - 1] == objetive[j - 1] else 1
-            dp[i][j] = min(dp[i - 1][j] + 1,
-                           dp[i][j - 1] + 1,
-                           dp[i - 1][j - 1] + cost)
+            dp[i][j] = min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + cost)
 
     return dp[-1][-1]