pydpm_xl 0.1.10__py3-none-any.whl

py_dpm/DataTypes/ScalarTypes.py

@@ -0,0 +1,324 @@
+import numpy as np
+import pandas as pd
+
+from py_dpm.DataTypes.TimeClasses import timeParser, timePeriodParser
+from py_dpm.Exceptions.exceptions import DataTypeError, SemanticError
+
+
+class ScalarType:
+    """
+    """
+
+    default = None
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}"
+
+    def strictly_same_class(self, obj) -> bool:
+        if not isinstance(obj, ScalarType):
+            raise Exception("Not use strictly_same_class")
+        return self.__class__ == obj.__class__
+
+    def __eq__(self, other):
+        return self.__class__.__name__ == other.__class__.__name__
+
+    def is_included(self, set_: set) -> bool:
+        return self.__class__ in set_
+
+    def is_subtype(self, obj) -> bool:
+        if not isinstance(obj, ScalarType):
+            raise Exception("Not use is_subtype")
+        return issubclass(self.__class__, obj.__class__)
+
+    def is_null_type(self) -> bool:
+        return False
+
+    def set_interval(self, interval: bool):
+        raise SemanticError("3-4", operand_type=self.__class__.__name__)
+
+    __str__ = __repr__
+
+
+class String(ScalarType):
+    """
+
+    """
+    default = ""
+
+    def __init__(self):
+        super().__init__()
+
+    def check_type(self, value):  # Not needed for semantic, but can be util later
+        if isinstance(value, str):
+            return True
+        raise DataTypeError(value, String)
+
+    def cast(self, value):
+        return str(value)
+
+    @property
+    def dtype(self):
+        return 'string'
+
+
+class Number(ScalarType):
+    """
+    """
+
+    def __init__(self, interval=False):
+        super().__init__()
+        self.interval: bool = interval
+
+    def check_type(self, value):
+        if isinstance(value, float):
+            return True
+
+        raise DataTypeError(value, Number)
+
+    def cast(self, value):
+        return float(value)
+
+    def set_interval(self, interval: bool):
+        self.interval = interval
+
+    @property
+    def dtype(self):
+        return 'Float64'
+
+
+class Integer(Number):
+    """
+    """
+
+    def __init__(self, interval=False):
+        super().__init__(interval)
+
+    def check_type(self, value):
+        if isinstance(value, int):
+            return True
+
+        raise DataTypeError(value, Integer)
+
+    def cast(self, value):
+        return int(round(float(value), 0))
+
+    @property
+    def dtype(self):
+        return 'Int64'
+
+
+class TimeInterval(ScalarType):
+    """
+
+    """
+    default = pd.NA
+
+    def __init__(self):
+        super().__init__()
+
+    def check_type(self, value):
+        if isinstance(value, str):
+            return True
+
+        raise DataTypeError(value, TimeInterval)
+
+    def cast(self, value):
+        return timeParser(value)
+
+    @property
+    def dtype(self):
+        return 'string'
+
+
+class Date(TimeInterval):
+    """
+
+    """
+    default = np.nan
+
+    def __init__(self):
+        super().__init__()
+
+    def check_type(self, value):
+        pass
+
+    def cast(self, value):
+        return str(value)
+
+    @property
+    def dtype(self):
+        return 'string'
+
+
+class TimePeriod(TimeInterval):
+    """
+
+    """
+    default = pd.NA
+
+    def __init__(self):
+        super().__init__()
+
+    def check_type(self, value):
+        pass
+
+    def cast(self, value):
+        return timePeriodParser(value)
+
+    @property
+    def dtype(self):
+        return 'string'
+
+
+class Duration(ScalarType):
+    pass
+
+
+class Boolean(ScalarType):
+    """
+    """
+    default = np.nan
+
+    def __init__(self):
+        super().__init__()
+
+    def check_type(self, value):
+        if isinstance(value, bool):
+            return True
+
+    def cast(self, value):
+        if isinstance(value, str):
+            if value.lower() == "true":
+                return True
+            elif value.lower() == "false":
+                return False
+            elif value.lower() == "1":
+                return True
+            elif value.lower() == "0":
+                return False
+            else:
+                return np.nan
+        if isinstance(value, int):
+            if value != 0:
+                return True
+            else:
+                return False
+        if isinstance(value, float):
+            if value != 0.0:
+                return True
+            else:
+                return False
+        if isinstance(value, bool):
+            return value
+        if isinstance(value, np.bool_):
+            return np.bool_(value)
+        if pd.isnull(value):
+            return np.nan
+        return np.nan
+
+    @property
+    def dtype(self):
+        return 'boolean'
+
+
+class Null(ScalarType):  # I think it is needed
+    """
+    All the Data Types are assumed to contain the conventional value null, which means “no value”, or “absence of known value” or “missing value”.
+    Note that the null value, therefore, is the only value of multiple different types. 
+    """
+    default = None
+
+    def __init__(self):
+        super().__init__()
+
+    def is_null_type(self) -> bool:
+        return True
+
+    def cast(self, value):
+        return type(None)()
+
+
+class Mixed(ScalarType):
+    """
+
+    """
+
+    def __init__(self):
+        super().__init__()
+
+
+class Item(ScalarType):
+    default = ""
+
+    def __init__(self):
+        super().__init__()
+
+    def cast(self, value):
+        return str(value)
+
+    @property
+    def dtype(self):
+        return 'string'
+
+
+class Subcategory(ScalarType):
+    pass
+
+
+class ScalarFactory:
+    types_dict = {
+        "String": String,
+        "Number": Number,
+        "Integer": Integer,
+        "TimeInterval": TimeInterval,
+        "Date": Date,
+        "TimePeriod": TimePeriod,
+        "Duration": Duration,
+        "Boolean": Boolean,
+        "Item": Item,
+        "Subcategory": Subcategory,
+        "Null": Null,
+        "Mixed": Mixed
+    }
+
+    database_types = {
+        "URI": String,
+        "PER": Number,
+        "ENU": Item,
+        "DAT": TimeInterval,
+        "STR": String,
+        "INT": Integer,
+        "MON": Number,
+        "BOO": Boolean,
+        "TRU": Boolean,
+        "DEC": Number,
+        "b": Boolean,
+        "d": TimeInterval,
+        "i": Integer,
+        "m": Number,
+        "p": Number,
+        "e": Item,
+        "s": String,
+        "es": String,
+        "r": Number,
+        "t": Boolean
+    }
+
+    def scalar_factory(self, code=None, interval=None):
+        if code in ("Number", "Integer"):
+            return self.types_dict[code](interval)
+        if code in self.types_dict:
+            return self.types_dict[code]()
+        return Null()
+
+    def database_types_mapping(self, code):
+        return self.database_types[code]
+
+    def all_types(self):
+        return (v for v in self.types_dict.values())
+
+    def from_database_to_scalar_types(self, code, interval):
+        scalar_type = self.database_types_mapping(code)
+        if isinstance(scalar_type(), Number):
+            return scalar_type(interval)
+        return scalar_type()

py_dpm/DataTypes/TimeClasses.py

@@ -0,0 +1,370 @@
+import calendar
+import operator
+from datetime import date, datetime
+from typing import Union
+
+import pandas as pd
+from pandas._libs.missing import NAType
+
+duration_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"
+}
+
+
+class TimePeriod:
+    _year: int
+    _period_indicator: str
+    _period_number: int
+
+    def __init__(self, period: str):
+        self.year = int(period[:4])
+        if len(period) > 4:
+            self.period_indicator = period[4]
+        else:
+            self.period_indicator = 'A'
+        if len(period) > 5:
+            self.period_number = int(period[5:])
+        else:
+            self.period_number = 1
+
+    def __str__(self):
+        if self.period_indicator == 'A':
+            return f"{self.year}{self.period_indicator}"
+        return f"{self.year}{self.period_indicator}{self.period_number}"
+
+    @staticmethod
+    def _check_year(year: int):
+        if year < 1900 or year > 9999:
+            raise ValueError(f'Invalid year {year}, must be between 1900 and 9999.')
+
+    @property
+    def year(self) -> int:
+        return self._year
+
+    @year.setter
+    def year(self, value: int):
+        self._check_year(value)
+        self._year = value
+
+    @property
+    def period_indicator(self) -> str:
+        return self._period_indicator
+
+    @period_indicator.setter
+    def period_indicator(self, value: str):
+        if value not in PeriodDuration():
+            raise ValueError(
+                f'Cannot set period indicator as {value}. Possible values: {PeriodDuration().member_names}')
+        self._period_indicator = value
+
+    @property
+    def period_number(self) -> int:
+        return self._period_number
+
+    @period_number.setter
+    def period_number(self, value: int):
+        if not PeriodDuration.check_period_range(self.period_indicator, value):
+            raise ValueError(f'Period Number must be between 1 and '
+                             f'{PeriodDuration.periods[self.period_indicator]} '
+                             f'for period indicator {self.period_indicator}.')
+        self._period_number = value
+
+    def _meta_comparison(self, other, py_op) -> bool:
+        return py_op(duration_mapping[self.period_indicator],
+                     duration_mapping[other.period_indicator])
+
+    def start_date(self, as_date=False) -> Union[date, str]:
+        """
+        Gets the starting date of the Period
+        """
+        date_value = period_to_date(year=self.year,
+                                    period_indicator=self.period_indicator,
+                                    period_number=self.period_number,
+                                    start=True)
+        if as_date:
+            return date_value
+        return date_value.isoformat()
+
+    def end_date(self, as_date=False) -> Union[date, str]:
+        """
+        Gets the ending date of the Period
+        """
+        date_value = period_to_date(year=self.year,
+                                    period_indicator=self.period_indicator,
+                                    period_number=self.period_number,
+                                    start=False)
+        if as_date:
+            return date_value
+        return date_value.isoformat()
+
+    def __eq__(self, other) -> bool:
+        return self._meta_comparison(other, operator.eq)
+
+    def __ne__(self, other) -> bool:
+        return not self._meta_comparison(other, operator.eq)
+
+    def __lt__(self, other) -> bool:
+        return self._meta_comparison(other, operator.lt)
+
+    def __le__(self, other) -> bool:
+        return self._meta_comparison(other, operator.le)
+
+    def __gt__(self, other) -> bool:
+        return self._meta_comparison(other, operator.gt)
+
+    def __ge__(self, other) -> bool:
+        return self._meta_comparison(other, operator.ge)
+
+    def change_indicator(self, new_indicator):
+        if self.period_indicator == new_indicator:
+            return
+        date_value = period_to_date(self.year, self.period_indicator, self.period_number)
+        self.period_indicator = new_indicator
+        self.period_number = date_to_period(date_value, period_indicator=new_indicator).period_number
+
+
+class Time:
+    _date1: str = '0'
+    _date2: str = 'Z'
+
+    def __init__(self, date1: str, date2: str):
+        self.date1 = date1
+        self.date2 = date2
+        if date1 > date2:
+            raise ValueError(f'Invalid Time with duration less than 0 ({self.length} days)')
+
+    @classmethod
+    def from_dates(cls, date1: date, date2: date):
+        return cls(date1.isoformat(), date2.isoformat())
+
+    @classmethod
+    def from_iso_format(cls, dates: str):
+        return cls(*dates.split('/', maxsplit=1))
+
+    @property
+    def date1(self, as_date=False) -> Union[date, str]:
+        if as_date:
+            return date.fromisoformat(self._date1)
+        return self._date1
+
+    @property
+    def date2(self) -> Union[date, str]:
+        return self._date2
+
+    @date1.setter
+    def date1(self, value: str):
+        date.fromisoformat(value)
+        if value > self.date2:
+            raise ValueError(f"({value} > {self.date2}). Cannot set date1 with a value greater than date2.")
+        self._date1 = value
+
+    def date1_asdate(self):
+        return date.fromisoformat(self._date1)
+
+    def date2_asdate(self):
+        return date.fromisoformat(self._date2)
+
+    @date2.setter
+    def date2(self, value: str):
+        date.fromisoformat(value)
+        if value < self.date1:
+            raise ValueError(f"({value} < {self.date1}). Cannot set date2 with a value lower than date1.")
+        self._date2 = value
+
+    @property
+    def length(self) -> int:
+        date_left = date.fromisoformat(self.date1)
+        date_right = date.fromisoformat(self.date2)
+        return (date_right - date_left).days
+
+    __len__ = length
+
+    def __str__(self):
+        return f"{self.date1}/{self.date2}"
+
+    __repr__ = __str__
+
+    def _meta_comparison(self, other, py_op):
+        return py_op(self.length, other.length)
+
+    def __eq__(self, other) -> bool:
+        return self._meta_comparison(other, operator.eq)
+
+    def __ne__(self, other) -> bool:
+        return self._meta_comparison(other, operator.ne)
+
+    def __lt__(self, other) -> bool:
+        return self._meta_comparison(other, operator.lt)
+
+    def __le__(self, other) -> bool:
+        return self._meta_comparison(other, operator.le)
+
+    def __gt__(self, other) -> bool:
+        return self._meta_comparison(other, operator.gt)
+
+    def __ge__(self, other) -> bool:
+        return self._meta_comparison(other, operator.ge)
+
+    @classmethod
+    def from_time_period(cls, value: TimePeriod):
+        date1 = period_to_date(value.year, value.period_indicator, value.period_number, start=True)
+        date2 = period_to_date(value.year, value.period_indicator, value.period_number, start=False)
+        return cls.from_dates(date1, date2)
+
+
+def timePeriodParser(str_: str) -> Union[TimePeriod, NAType]:
+    """
+    Examples: 2020, 2019A, 2018Q3, 2011M12 2023S2.
+    """
+
+    try:
+        if pd.isnull(str_) or len(str_) == 0:
+            return pd.NA
+        return TimePeriod(str_)
+
+    except ValueError:
+        # DATAMODEL_DATASET.13
+        raise ValueError('Not a valid time period format {}'.format(str_))
+
+
+def timeParser(str_: str) -> Union[NAType, Time]:
+    """
+    Example: 2000-01-01/2009-12-31
+    """
+    try:
+        if pd.isnull(str_) or len(str_) == 0:
+            return pd.NA
+        return Time.from_iso_format(str_)
+
+    except ValueError:
+        # DATAMODEL_DATASET.10
+        raise ValueError('Not a valid time format {}'.format(str_))
+
+
+def date_to_period(date_value: date, period_indicator):
+    if period_indicator == "A":
+        return TimePeriod(f"{date_value.year}A")
+    elif period_indicator == "S":
+        return TimePeriod(f"{date_value.year}S{((date_value.month - 1) // 6) + 1}")
+    elif period_indicator == "Q":
+        return TimePeriod(f"{date_value.year}Q{((date_value.month - 1) // 3) + 1}")
+    elif period_indicator == "M":
+        return TimePeriod(f"{date_value.year}M{date_value.month}")
+    elif period_indicator == "W":
+        cal = date_value.isocalendar()
+        return TimePeriod(f"{cal[0]}W{cal[1]}")
+    elif period_indicator == "D":  # Extract day of the year
+        return TimePeriod(f"{date_value.year}D{date_value.timetuple().tm_yday}")
+
+
+def period_to_date(year, period_indicator, period_number, start=False):
+    if period_indicator == 'A':
+        if start:
+            return date(year, 1, 1)
+        else:
+            return date(year, 12, 31)
+    if period_indicator == 'S':
+        if period_number == 1:
+            if start:
+                return date(year, 1, 1)
+            else:
+                return date(year, 6, 30)
+        else:
+            if start:
+                return date(year, 7, 1)
+            else:
+                return date(year, 12, 31)
+    if period_indicator == 'Q':
+        if period_number == 1:
+            if start:
+                return date(year, 1, 1)
+            else:
+                return date(year, 3, 31)
+        elif period_number == 2:
+            if start:
+                return date(year, 4, 1)
+            else:
+                return date(year, 6, 30)
+        elif period_number == 3:
+            if start:
+                return date(year, 7, 1)
+            else:
+                return date(year, 9, 30)
+        else:
+            if start:
+                return date(year, 10, 1)
+            else:
+                return date(year, 12, 31)
+    if period_indicator == "M":
+        if start:
+            return date(year, period_number, 1)
+        else:
+            day = int(calendar.monthrange(year, period_number)[1])
+            return date(year, period_number, day)
+    if period_indicator == "W":  # 0 for Sunday, 1 for Monday in %w
+        if start:
+            return datetime.strptime(f"{year}-W{period_number}-1", "%G-W%V-%w").date()
+        else:
+            return datetime.strptime(f"{year}-W{period_number}-0", "%G-W%V-%w").date()
+    if period_indicator == "D":
+        return datetime.strptime(f"{year}-D{period_number}", "%Y-D%j").date()
+
+    raise ValueError(f'Invalid Period Indicator {period_indicator}')
+
+
+class SingletonMeta(type):
+    """
+    The Singleton class can be implemented in different ways in Python. Some
+    possible methods include: base class, decorator, metaclass. We will use the
+    metaclass because it is best suited for this purpose.
+    """
+
+    _instances = {}
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Possible changes to the value of the `__init__` argument do not affect
+        the returned instance.
+        """
+        if cls not in cls._instances:
+            instance = super().__call__(*args, **kwargs)
+            cls._instances[cls] = instance
+        return cls._instances[cls]
+
+
+class PeriodDuration(metaclass=SingletonMeta):
+    periods = {
+        'D': 365,
+        'W': 53,
+        'M': 12,
+        'Q': 4,
+        'S': 2,
+        'A': 1
+    }
+
+    def __contains__(self, item):
+        return item in self.periods
+
+    @property
+    def member_names(self):
+        return list(self.periods.keys())
+
+    @classmethod
+    def check_period_range(cls, letter, value):
+        if letter == 'A':
+            return True
+        return value in range(1, cls.periods[letter] + 1)