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

vtlengine/DataTypes/__init__.py

@@ -1,151 +1,171 @@
-from typing import Any, Type
-
+from typing import Any, Optional, Type, Dict, Set, Union
 import pandas as pd
 
 from vtlengine.DataTypes.TimeHandling import str_period_to_date, check_max_date, date_to_period_str
 from vtlengine.Exceptions import SemanticError
 
-DTYPE_MAPPING = {
-    'String': 'string',
-    'Number': 'float64',
-    'Integer': 'int64',
-    'TimeInterval': 'string',
-    'Date': 'string',
-    'TimePeriod': 'string',
-    'Duration': 'string',
-    'Boolean': 'object',
+DTYPE_MAPPING: Dict[str, str] = {
+    "String": "string",
+    "Number": "float64",
+    "Integer": "int64",
+    "TimeInterval": "string",
+    "Date": "string",
+    "TimePeriod": "string",
+    "Duration": "string",
+    "Boolean": "object",
 }
 
-CAST_MAPPING = {
-    'String': str,
-    'Number': float,
-    'Integer': int,
-    'TimeInterval': str,
-    'Date': str,
-    'TimePeriod': str,
-    'Duration': str,
-    'Boolean': bool,
+CAST_MAPPING: Dict[str, type] = {
+    "String": str,
+    "Number": float,
+    "Integer": int,
+    "TimeInterval": str,
+    "Date": str,
+    "TimePeriod": str,
+    "Duration": str,
+    "Boolean": bool,
 }
 
 
 class ScalarType:
-    """
-    """
+    """ """
 
-    default = None
+    default: Optional[Union[str, "ScalarType"]] = None
+
+    def __name__(self) -> Any:
+        return self.__class__.__name__
 
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}"
+    def __str__(self) -> str:
+        return SCALAR_TYPES_CLASS_REVERSE[self.__class__]
 
-    def strictly_same_class(self, obj) -> bool:
+    __repr__ = __str__
+
+    def strictly_same_class(self, obj: "ScalarType") -> bool:
         if not isinstance(obj, ScalarType):
             raise Exception("Not use strictly_same_class")
         return self.__class__ == obj.__class__
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         return self.__class__.__name__ == other.__class__.__name__
 
-    def __ne__(self, other):
+    def __ne__(self, other: Any) -> bool:
         return not self.__eq__(other)
 
-    def instance_is_included(self, set_: set) -> bool:
+    def instance_is_included(self, set_: Set[Any]) -> bool:
         return self.__class__ in set_
 
     @classmethod
-    def is_included(cls, set_: set) -> bool:
+    def is_included(cls, set_: Set[Any]) -> bool:
         return cls in set_
 
     @classmethod
-    def promotion_changed_type(cls, promoted: Type['ScalarType']) -> bool:
+    def promotion_changed_type(cls, promoted: Any) -> bool:
         return not issubclass(cls, promoted)
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def implicit_cast(cls, value: Any, from_type: Any) -> Any:
         raise Exception("Method should be implemented by inheritors")
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def explicit_cast(cls, value: Any, from_type: Any) -> Any:
         raise Exception("Method should be implemented by inheritors")
 
     @classmethod
-    def is_subtype(cls, obj: Type["ScalarType"]) -> bool:
+    def is_subtype(cls, obj: Any) -> bool:
         return issubclass(cls, obj)
 
-    def is_null_type(self) -> bool:
+    @classmethod
+    def is_null_type(cls) -> bool:
         return False
 
     @classmethod
-    def check_type(cls, value):
-        if isinstance(value, CAST_MAPPING[cls.__name__]):
+    def check_type(cls, value: Any) -> bool:
+        if isinstance(value, CAST_MAPPING[cls.__name__]):  # type: ignore[index]
             return True
-
         raise Exception(f"Value {value} is not a {cls.__name__}")
 
     @classmethod
-    def cast(cls, value):
+    def cast(cls, value: Any) -> Any:
         if pd.isnull(value):
             return None
-        return CAST_MAPPING[cls.__name__](value)
+        class_name: str = cls.__name__.__str__()
+        return CAST_MAPPING[class_name](value)
 
     @classmethod
     def dtype(cls) -> str:
-        return DTYPE_MAPPING[cls.__name__]
-
-    __str__ = __repr__
+        class_name: str = cls.__name__.__str__()
+        return DTYPE_MAPPING[class_name]
 
 
 class String(ScalarType):
-    """
+    """ """
 
-    """
     default = ""
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> str:
+    def implicit_cast(cls, value: Any, from_type: Any) -> str:
         # if pd.isna(value):
         #     return cls.default
-        if from_type in {Number, Integer, Boolean, String, Date, TimePeriod, TimeInterval,
-                         Duration}:
+        if from_type in {
+            Number,
+            Integer,
+            Boolean,
+            String,
+            Date,
+            TimePeriod,
+            TimeInterval,
+            Duration,
+        }:
             return str(value)
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> str:
+    def explicit_cast(cls, value: Any, from_type: Any) -> str:
         if from_type in {TimePeriod, Date, String}:
             return str(value)
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
 
 class Number(ScalarType):
-    """
-    """
+    """ """
 
-    def __eq__(self, other):
-        return (self.__class__.__name__ == other.__class__.__name__ or
-                other.__class__.__name__ == Integer.__name__)
+    def __eq__(self, other: Any) -> bool:
+        return (
+            self.__class__.__name__ == other.__class__.__name__
+            or other.__class__.__name__ == Integer.__name__
+        )
 
-    def __ne__(self, other):
+    def __ne__(self, other: Any) -> bool:
         return not self.__eq__(other)
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> float:
+    def implicit_cast(cls, value: Any, from_type: Any) -> float:
         # if pd.isna(value):
         #     return cls.default
         if from_type in {Integer, Number}:
             return float(value)
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> float:
+    def explicit_cast(cls, value: Any, from_type: Any) -> float:
         if from_type in {Boolean}:
             if value:
                 return 1.0
@@ -157,12 +177,15 @@ class Number(ScalarType):
             except ValueError:
                 pass
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def cast(cls, value):
+    def cast(cls, value: Any) -> Optional[float]:
         if pd.isnull(value):
             return None
         if isinstance(value, str):
@@ -174,18 +197,19 @@ class Number(ScalarType):
 
 
 class Integer(Number):
-    """
-    """
+    """ """
 
-    def __eq__(self, other):
-        return (self.__class__.__name__ == other.__class__.__name__ or
-                other.__class__.__name__ == Number.__name__)
+    def __eq__(self, other: Any) -> bool:
+        return (
+            self.__class__.__name__ == other.__class__.__name__
+            or other.__class__.__name__ == Number.__name__
+        )
 
-    def __ne__(self, other):
+    def __ne__(self, other: Any) -> bool:
         return not self.__eq__(other)
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> int:
+    def implicit_cast(cls, value: Any, from_type: Any) -> int:
         if from_type.__name__ == "Integer":
             return value
 
@@ -193,16 +217,22 @@ class Integer(Number):
             if value.is_integer():
                 return int(value)
             else:
-                raise SemanticError("2-1-5-1", value=value,
-                                    type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                                    type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
-
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+                raise SemanticError(
+                    "2-1-5-1",
+                    value=value,
+                    type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+                    type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+                )
+
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> int:
+    def explicit_cast(cls, value: Any, from_type: Any) -> int:
         if from_type in {Boolean}:
             if value:
                 return 1
@@ -211,21 +241,30 @@ class Integer(Number):
         if from_type in {Number, String}:
             try:
                 if float(value) - int(value) != 0:
-                    raise SemanticError("2-1-5-1", value=value,
-                                        type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                                        type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+                    raise SemanticError(
+                        "2-1-5-1",
+                        value=value,
+                        type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+                        type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+                    )
             except ValueError:
-                raise SemanticError("2-1-5-1", value=value,
-                                    type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                                    type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+                raise SemanticError(
+                    "2-1-5-1",
+                    value=value,
+                    type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+                    type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+                )
             return int(value)
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def cast(cls, value):
+    def cast(cls, value: Any) -> Optional[int]:
         if pd.isnull(value):
             return None
         if isinstance(value, float):
@@ -243,13 +282,12 @@ class Integer(Number):
 
 
 class TimeInterval(ScalarType):
-    """
+    """ """
 
-    """
     default = None
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def implicit_cast(cls, value: Any, from_type: Any) -> Any:
         # TODO: Remove String, only for compatibility with previous engine
         if from_type in {TimeInterval, String}:
             return value
@@ -263,107 +301,133 @@ class TimeInterval(ScalarType):
             end_value = str_period_to_date(value, start=False).isoformat()
             return f"{init_value}/{end_value}"
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def explicit_cast(cls, value: Any, from_type: Any) -> Any:
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
 
 class Date(TimeInterval):
-    """
+    """ """
 
-    """
     default = None
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def implicit_cast(cls, value: Any, from_type: Any) -> Any:
         # TODO: Remove String, only for compatibility with previous engine
         if from_type in {Date, String}:
             return value
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def explicit_cast(cls, value: Any, from_type: Any) -> Any:
         # TODO: Remove String, only for compatibility with previous engine
         if from_type == String:
             return value
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
 
 class TimePeriod(TimeInterval):
-    """
+    """ """
 
-    """
     default = None
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def implicit_cast(cls, value: Any, from_type: Any) -> Any:
         # TODO: Remove String, only for compatibility with previous engine
         if from_type in {TimePeriod, String}:
             return value
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def explicit_cast(cls, value: Any, from_type: Any) -> Any:
         if from_type in {Date}:
             try:
                 period_str = date_to_period_str(value, "D")
             except ValueError:
-                raise SemanticError("2-1-5-1", value=value,
-                                    type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                                    type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+                raise SemanticError(
+                    "2-1-5-1",
+                    value=value,
+                    type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+                    type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+                )
             return period_str
         # TODO: Remove String, only for compatibility with previous engine
         elif from_type == String:
             return value
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
 
 class Duration(ScalarType):
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> str:
+    def implicit_cast(cls, value: Any, from_type: Any) -> str:
         if from_type in {Duration, String}:
             return value
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> Any:
+    def explicit_cast(cls, value: Any, from_type: Any) -> Any:
         if from_type == String:
             return value
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
 
 class Boolean(ScalarType):
-    """
-    """
+    """ """
+
     default = None
 
-    def cast(self, value):
+    @classmethod
+    def cast(cls, value: Any) -> Optional[bool]:
         if pd.isnull(value):
             return None
         if isinstance(value, str):
@@ -392,86 +456,95 @@ class Boolean(ScalarType):
         return value
 
     @classmethod
-    def implicit_cast(cls, value, from_type: Type['ScalarType']) -> bool:
+    def implicit_cast(cls, value: Any, from_type: Any) -> bool:
         if from_type in {Boolean}:
             return value
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
     @classmethod
-    def explicit_cast(cls, value, from_type: Type['ScalarType']) -> bool:
+    def explicit_cast(cls, value: Any, from_type: Any) -> bool:
         if from_type in {Number, Integer}:
             if value in {0, 0.0}:
                 return False
             return True
 
-        raise SemanticError("2-1-5-1", value=value,
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[cls])
+        raise SemanticError(
+            "2-1-5-1",
+            value=value,
+            type_1=SCALAR_TYPES_CLASS_REVERSE[from_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[cls],
+        )
 
 
 class Null(ScalarType):
-    """
-    """
+    """ """
 
-    def is_null_type(self) -> bool:
+    @classmethod
+    def is_null_type(cls) -> bool:
         return True
 
-    def check_type(self, value):
+    @classmethod
+    def check_type(cls, value: Any) -> bool:
         return True
 
-    def cast(self, value):
+    @classmethod
+    def cast(cls, value: Any) -> None:
         return None
 
-    def dtype(self):
-        return 'string'
-
-
-SCALAR_TYPES = {
-    'String': String,
-    'Number': Number,
-    'Integer': Integer,
-    'Time': TimeInterval,
-    'Date': Date,
-    'Time_Period': TimePeriod,
-    'Duration': Duration,
-    'Boolean': Boolean,
+    @classmethod
+    def dtype(cls) -> str:
+        return "string"
+
+
+SCALAR_TYPES: Dict[str, Type[ScalarType]] = {
+    "String": String,
+    "Number": Number,
+    "Integer": Integer,
+    "Time": TimeInterval,
+    "Date": Date,
+    "Time_Period": TimePeriod,
+    "Duration": Duration,
+    "Boolean": Boolean,
 }
 
-SCALAR_TYPES_CLASS_REVERSE = {
-    String: 'String',
-    Number: 'Number',
-    Integer: 'Integer',
-    TimeInterval: 'Time',
-    Date: 'Date',
-    TimePeriod: 'Time_Period',
-    Duration: 'Duration',
-    Boolean: 'Boolean',
+SCALAR_TYPES_CLASS_REVERSE: Dict[Type[ScalarType], str] = {
+    String: "String",
+    Number: "Number",
+    Integer: "Integer",
+    TimeInterval: "Time",
+    Date: "Date",
+    TimePeriod: "Time_Period",
+    Duration: "Duration",
+    Boolean: "Boolean",
 }
 
-BASIC_TYPES = {
+BASIC_TYPES: Dict[type, Type[ScalarType]] = {
     str: String,
     int: Integer,
     float: Number,
     bool: Boolean,
-    type(None): Null
+    type(None): Null,
 }
 
-COMP_NAME_MAPPING = {
-    String: 'str_var',
-    Number: 'num_var',
-    Integer: 'int_var',
-    TimeInterval: 'time_var',
-    TimePeriod: 'time_period_var',
-    Date: 'date_var',
-    Duration: 'duration_var',
-    Boolean: 'bool_var',
-    Null: 'null_var'
+COMP_NAME_MAPPING: Dict[Type[ScalarType], str] = {
+    String: "str_var",
+    Number: "num_var",
+    Integer: "int_var",
+    TimeInterval: "time_var",
+    TimePeriod: "time_period_var",
+    Date: "date_var",
+    Duration: "duration_var",
+    Boolean: "bool_var",
+    Null: "null_var",
 }
 
-IMPLICIT_TYPE_PROMOTION_MAPPING = {
+IMPLICIT_TYPE_PROMOTION_MAPPING: Dict[Type[ScalarType], Any] = {
     # TODO: Remove Time types, only for compatibility with previous engine
     String: {String, Boolean, TimePeriod},
     Number: {String, Number, Integer},
@@ -482,11 +555,11 @@ IMPLICIT_TYPE_PROMOTION_MAPPING = {
     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
-EXPLICIT_WITHOUT_MASK_TYPE_PROMOTION_MAPPING = {
+EXPLICIT_WITHOUT_MASK_TYPE_PROMOTION_MAPPING: Dict[Type[ScalarType], Any] = {
     # TODO: Remove time types, only for compatibility with previous engine
     String: {Integer, String, Date, TimePeriod, TimeInterval, Duration, Number},
     Number: {Integer, Boolean, String, Number},
@@ -497,10 +570,10 @@ EXPLICIT_WITHOUT_MASK_TYPE_PROMOTION_MAPPING = {
     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 = {
+EXPLICIT_WITH_MASK_TYPE_PROMOTION_MAPPING: Dict[Type[ScalarType], Any] = {
     String: {Number, TimeInterval, Date, TimePeriod, Duration},
     Number: {},
     Integer: {},
@@ -509,14 +582,16 @@ EXPLICIT_WITH_MASK_TYPE_PROMOTION_MAPPING = {
     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},
 }
 
 
-def binary_implicit_promotion(left_type: ScalarType,
-                              right_type: ScalarType,
-                              type_to_check: ScalarType = None,
-                              return_type: ScalarType = None) -> ScalarType:
+def binary_implicit_promotion(
+    left_type: Type[ScalarType],
+    right_type: Type[ScalarType],
+    type_to_check: Optional[Type[ScalarType]] = None,
+    return_type: Optional[Type[ScalarType]] = None,
+) -> Type[ScalarType]:
     """
     Validates the compatibility between the types of the operands and the operator
     (implicit type promotion : check_binary_implicit_type_promotion)
@@ -539,28 +614,33 @@ def binary_implicit_promotion(left_type: ScalarType,
             if right_type.is_included(left_implicities):
                 return right_type
             return type_to_check
-        raise SemanticError(code="1-1-1-2",
-                            type_1=SCALAR_TYPES_CLASS_REVERSE[left_type],
-                            type_2=SCALAR_TYPES_CLASS_REVERSE[right_type],
-                            type_check=SCALAR_TYPES_CLASS_REVERSE[type_to_check])
-        # raise Exception(f"Implicit cast not allowed from {left_type} and {right_type} to {type_to_check}")
-
-    if return_type and (left_type.is_included(
-            right_implicities) or right_type.is_included(left_implicities)):
+        raise SemanticError(
+            code="1-1-1-2",
+            type_1=SCALAR_TYPES_CLASS_REVERSE[left_type],
+            type_2=SCALAR_TYPES_CLASS_REVERSE[right_type],
+            type_check=SCALAR_TYPES_CLASS_REVERSE[type_to_check],
+        )
+        # raise Exception(f"Implicit cast not allowed from
+        # {left_type} and {right_type} to {type_to_check}")
+
+    if return_type and (
+        left_type.is_included(right_implicities) or right_type.is_included(left_implicities)
+    ):
         return return_type
     if left_type.is_included(right_implicities):
         return left_type
     if right_type.is_included(left_implicities):
         return right_type
 
-    raise SemanticError(code="1-1-1-1",
-                        type_1=SCALAR_TYPES_CLASS_REVERSE[left_type],
-                        type_2=SCALAR_TYPES_CLASS_REVERSE[right_type])
+    raise SemanticError(
+        code="1-1-1-1",
+        type_1=SCALAR_TYPES_CLASS_REVERSE[left_type],
+        type_2=SCALAR_TYPES_CLASS_REVERSE[right_type],
+    )
 
 
 def check_binary_implicit_promotion(
-        left: ScalarType, right: ScalarType,
-        type_to_check: ScalarType = None, return_type: ScalarType = 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
@@ -580,8 +660,10 @@ def check_binary_implicit_promotion(
 
 
 def unary_implicit_promotion(
-        operand_type: ScalarType, type_to_check: ScalarType = None, return_type: ScalarType = None
-) -> ScalarType:
+    operand_type: Type[ScalarType],
+    type_to_check: Optional[Type[ScalarType]] = None,
+    return_type: Optional[Type[ScalarType]] = None,
+) -> Type[ScalarType]:
     """
     Validates the compatibility between the type of the operand and the operator
     param operand: The operand
@@ -592,20 +674,24 @@ def unary_implicit_promotion(
     operand_implicities = IMPLICIT_TYPE_PROMOTION_MAPPING[operand_type]
     if type_to_check:
         if not type_to_check.is_included(operand_implicities):
-            raise SemanticError(code="1-1-1-1",
-                                type_1=SCALAR_TYPES_CLASS_REVERSE[operand_type],
-                                type_2=SCALAR_TYPES_CLASS_REVERSE[type_to_check])
-
+            raise SemanticError(
+                code="1-1-1-1",
+                type_1=SCALAR_TYPES_CLASS_REVERSE[operand_type],
+                type_2=SCALAR_TYPES_CLASS_REVERSE[type_to_check],
+            )
     if return_type:
         return return_type
-    if (type_to_check and not issubclass(operand_type, type_to_check)
-            and not issubclass(type_to_check, operand_type)):
+    if (
+        type_to_check
+        and not issubclass(operand_type, type_to_check)
+        and not issubclass(type_to_check, operand_type)
+    ):
         return type_to_check
     return operand_type
 
 
 def check_unary_implicit_promotion(
-        operand_type: ScalarType, type_to_check: ScalarType = None, return_type: ScalarType = None
+    operand_type: Type[ScalarType], type_to_check: Any = None, return_type: Any = None
 ) -> bool:
     """
     Validates the compatibility between the type of the operand and the operator