vtlengine 1.0.3rc2__py3-none-any.whl → 1.0.4__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/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]