xian-tech-runtime-types 0.1.0__tar.gz

xian_tech_runtime_types-0.1.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: xian-tech-runtime-types
+Version: 0.1.0
+Summary: Shared deterministic runtime types for the Xian stack
+Author-email: Xian Network <info@xian.org>
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# xian-tech-runtime-types
+
+Shared deterministic runtime types for the Xian stack.

xian_tech_runtime_types-0.1.0/README.md

@@ -0,0 +1,3 @@
+# xian-tech-runtime-types
+
+Shared deterministic runtime types for the Xian stack.

xian_tech_runtime_types-0.1.0/pyproject.toml

@@ -0,0 +1,18 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "xian-tech-runtime-types"
+version = "0.1.0"
+description = "Shared deterministic runtime types for the Xian stack"
+readme = "README.md"
+license = "MIT"
+authors = [{ name = "Xian Network", email = "info@xian.org" }]
+requires-python = ">=3.11"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]

xian_tech_runtime_types-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

xian_tech_runtime_types-0.1.0/src/xian_runtime_types/__init__.py

@@ -0,0 +1,71 @@
+from xian_runtime_types.decimal import (
+    CONTEXT,
+    MAX_DECIMAL,
+    MAX_LOWER_PRECISION,
+    MAX_UPPER_PRECISION,
+    MIN_DECIMAL,
+    ContractingDecimal,
+    DecimalOverflowError,
+    exports,
+    fix_precision,
+    neg_sci_not,
+)
+from xian_runtime_types.encoding import (
+    Encoder,
+    as_object,
+    convert,
+    convert_dict,
+    decode,
+    decode_kv,
+    encode,
+    encode_int,
+    encode_ints_in_dict,
+    encode_kv,
+    safe_repr,
+)
+from xian_runtime_types.time import (
+    DAYS,
+    HOURS,
+    MINUTES,
+    SECONDS,
+    WEEKS,
+    Datetime,
+    Timedelta,
+    datetime_module,
+    get_raw_seconds,
+    to_contract_time,
+)
+
+__all__ = [
+    "CONTEXT",
+    "MAX_DECIMAL",
+    "MAX_LOWER_PRECISION",
+    "MAX_UPPER_PRECISION",
+    "MIN_DECIMAL",
+    "ContractingDecimal",
+    "DecimalOverflowError",
+    "exports",
+    "fix_precision",
+    "neg_sci_not",
+    "Encoder",
+    "as_object",
+    "convert",
+    "convert_dict",
+    "decode",
+    "decode_kv",
+    "encode",
+    "encode_int",
+    "encode_ints_in_dict",
+    "encode_kv",
+    "safe_repr",
+    "DAYS",
+    "HOURS",
+    "MINUTES",
+    "SECONDS",
+    "WEEKS",
+    "Datetime",
+    "Timedelta",
+    "datetime_module",
+    "get_raw_seconds",
+    "to_contract_time",
+]

xian_tech_runtime_types-0.1.0/src/xian_runtime_types/decimal.py

@@ -0,0 +1,203 @@
+import decimal
+from decimal import ROUND_DOWN, Context, Decimal, InvalidOperation
+
+MAX_UPPER_PRECISION = 61
+MAX_LOWER_PRECISION = 30
+
+CONTEXT = Context(
+    prec=MAX_UPPER_PRECISION + MAX_LOWER_PRECISION,
+    rounding=ROUND_DOWN,
+    Emin=-100,
+    Emax=100,
+)
+decimal.setcontext(CONTEXT)
+
+
+def make_min_decimal_str(prec):
+    return "0." + "0" * (prec - 1) + "1"
+
+
+def make_max_decimal_str(upper_prec, lower_prec=0):
+    whole = "9" * upper_prec
+    if lower_prec <= 0:
+        return whole
+    return f"{whole}.{'9' * lower_prec}"
+
+
+def neg_sci_not(s: str):
+    try:
+        base, exp = s.split("e-")
+        if float(base) > 9:
+            return s
+
+        base = base.replace(".", "")
+        numbers = ("0" * (int(exp) - 1)) + base
+
+        if int(exp) > 0:
+            numbers = "0." + numbers
+
+        return numbers
+    except ValueError:
+        return s
+
+
+MAX_DECIMAL = Decimal(
+    make_max_decimal_str(MAX_UPPER_PRECISION, MAX_LOWER_PRECISION)
+)
+MIN_DECIMAL = Decimal(make_min_decimal_str(MAX_LOWER_PRECISION))
+
+
+class DecimalOverflowError(OverflowError):
+    pass
+
+
+def fix_precision(x: Decimal):
+    try:
+        quantized = x.quantize(MIN_DECIMAL, rounding=ROUND_DOWN).normalize()
+    except InvalidOperation as exc:
+        raise DecimalOverflowError(
+            f"Value {x} exceeds the supported decimal range."
+        ) from exc
+    if quantized == 0:
+        return Decimal("0")
+    if quantized > MAX_DECIMAL or quantized < -MAX_DECIMAL:
+        raise DecimalOverflowError(
+            f"Value {x} exceeds the supported decimal range."
+        )
+    return quantized
+
+
+class ContractingDecimal:
+    def _get_other(self, other):
+        if isinstance(other, ContractingDecimal):
+            return other._d
+        elif isinstance(other, (float, int)):
+            return fix_precision(Decimal(neg_sci_not(str(other))))
+        return other
+
+    def __init__(self, a):
+        if isinstance(a, (float, int)):
+            self._d = Decimal(neg_sci_not(str(a)))
+        elif isinstance(a, str):
+            self._d = Decimal(neg_sci_not(a))
+        elif isinstance(a, Decimal):
+            self._d = a
+        else:
+            self._d = Decimal(a)
+
+        self._d = fix_precision(self._d)
+
+    def __bool__(self):
+        return self._d != 0
+
+    def __eq__(self, other):
+        return self._d == self._get_other(other)
+
+    def __lt__(self, other):
+        return self._d < self._get_other(other)
+
+    def __le__(self, other):
+        return self._d <= self._get_other(other)
+
+    def __gt__(self, other):
+        return self._d > self._get_other(other)
+
+    def __ge__(self, other):
+        return self._d >= self._get_other(other)
+
+    def __str__(self):
+        return self._d.to_eng_string()
+
+    def __repr__(self):
+        return self._d.to_eng_string()
+
+    def __neg__(self):
+        return ContractingDecimal(-self._d)
+
+    def __pos__(self):
+        return self
+
+    def __abs__(self):
+        return ContractingDecimal(abs(self._d))
+
+    def __add__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._d + self._get_other(other))
+        )
+
+    def __radd__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._get_other(other) + self._d)
+        )
+
+    def __sub__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._d - self._get_other(other))
+        )
+
+    def __rsub__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._get_other(other) - self._d)
+        )
+
+    def __mul__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._d * self._get_other(other))
+        )
+
+    def __rmul__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._get_other(other) * self._d)
+        )
+
+    def __truediv__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._d / self._get_other(other))
+        )
+
+    def __rtruediv__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._get_other(other) / self._d)
+        )
+
+    def __mod__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._d % self._get_other(other))
+        )
+
+    def __rmod__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._get_other(other) % self._d)
+        )
+
+    def __floordiv__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._d // self._get_other(other))
+        )
+
+    def __rfloordiv__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._get_other(other) // self._d)
+        )
+
+    def __pow__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._d ** self._get_other(other))
+        )
+
+    def __rpow__(self, other):
+        return ContractingDecimal(
+            fix_precision(self._get_other(other) ** self._d)
+        )
+
+    def __int__(self):
+        return int(self._d)
+
+    def __float__(self):
+        return float(self._d)
+
+    def __round__(self, n=None):
+        return round(self._d, n)
+
+
+exports = {"decimal": ContractingDecimal}

xian_tech_runtime_types-0.1.0/src/xian_runtime_types/encoding.py

@@ -0,0 +1,163 @@
+import decimal
+import json
+
+from xian_runtime_types.decimal import ContractingDecimal, fix_precision
+from xian_runtime_types.time import Datetime, Timedelta
+
+MIN_INT = -(2**63)
+MAX_INT = 2**63 - 1
+TYPES = {"__fixed__", "__delta__", "__bytes__", "__time__", "__big_int__"}
+
+
+def safe_repr(obj, max_len=1024):
+    try:
+        raw = obj.__repr__()
+        parts = raw.split(" at 0x")
+        if len(parts) > 1:
+            return parts[0] + ">"
+        return parts[0][:max_len]
+    except Exception:
+        return None
+
+
+class Encoder(json.JSONEncoder):
+    def default(self, value, *args):
+        if (
+            isinstance(value, Datetime)
+            or value.__class__.__name__ == Datetime.__name__
+        ):
+            return {
+                "__time__": [
+                    value.year,
+                    value.month,
+                    value.day,
+                    value.hour,
+                    value.minute,
+                    value.second,
+                    value.microsecond,
+                ]
+            }
+        if (
+            isinstance(value, Timedelta)
+            or value.__class__.__name__ == Timedelta.__name__
+        ):
+            return {
+                "__delta__": [
+                    value._timedelta.days,
+                    value._timedelta.seconds,
+                ]
+            }
+        if isinstance(value, bytes):
+            return {"__bytes__": value.hex()}
+        if (
+            isinstance(value, decimal.Decimal)
+            or value.__class__.__name__ == decimal.Decimal.__name__
+        ):
+            return {"__fixed__": str(fix_precision(value))}
+        if (
+            isinstance(value, ContractingDecimal)
+            or value.__class__.__name__ == ContractingDecimal.__name__
+        ):
+            return {"__fixed__": str(fix_precision(value._d))}
+        return super().default(value)
+
+
+def encode_int(value: int):
+    if MIN_INT < value < MAX_INT:
+        return value
+    return {"__big_int__": str(value)}
+
+
+def encode_ints_in_dict(data: dict):
+    encoded = {}
+    for key, value in data.items():
+        if isinstance(value, int):
+            encoded[key] = encode_int(value)
+        elif isinstance(value, dict):
+            encoded[key] = encode_ints_in_dict(value)
+        elif isinstance(value, list):
+            encoded[key] = []
+            for item in value:
+                if isinstance(item, dict):
+                    encoded[key].append(encode_ints_in_dict(item))
+                elif isinstance(item, int):
+                    encoded[key].append(encode_int(item))
+                else:
+                    encoded[key].append(item)
+        else:
+            encoded[key] = value
+    return encoded
+
+
+def encode(data):
+    if isinstance(data, int):
+        data = encode_int(data)
+    elif isinstance(data, dict):
+        data = encode_ints_in_dict(data)
+    return json.dumps(data, cls=Encoder, separators=(",", ":"))
+
+
+def as_object(value):
+    if "__time__" in value:
+        return Datetime(*value["__time__"])
+    if "__delta__" in value:
+        return Timedelta(
+            days=value["__delta__"][0], seconds=value["__delta__"][1]
+        )
+    if "__bytes__" in value:
+        return bytes.fromhex(value["__bytes__"])
+    if "__fixed__" in value:
+        return ContractingDecimal(value["__fixed__"])
+    if "__big_int__" in value:
+        return int(value["__big_int__"])
+    return dict(value)
+
+
+def decode(data):
+    if data is None:
+        return None
+    if isinstance(data, bytes):
+        data = data.decode()
+    try:
+        return json.loads(data, object_hook=as_object)
+    except json.decoder.JSONDecodeError:
+        return None
+
+
+def encode_kv(key, value):
+    return key.encode(), encode(value).encode()
+
+
+def decode_kv(key, value):
+    return key.decode(), decode(value)
+
+
+def convert(key, value):
+    if key == "__fixed__":
+        return ContractingDecimal(value)
+    if key == "__delta__":
+        return Timedelta(days=value[0], seconds=value[1])
+    if key == "__bytes__":
+        return bytes.fromhex(value)
+    if key == "__time__":
+        return Datetime(*value)
+    if key == "__big_int__":
+        return int(value)
+    return value
+
+
+def convert_dict(data):
+    if not isinstance(data, dict):
+        return data
+
+    converted = {}
+    for key, value in data.items():
+        if key in TYPES:
+            return convert(key, value)
+        if isinstance(value, dict):
+            converted[key] = convert_dict(value)
+        elif isinstance(value, list):
+            converted[key] = [convert_dict(item) for item in value]
+        else:
+            converted[key] = value
+    return converted

xian_tech_runtime_types-0.1.0/src/xian_runtime_types/time.py

@@ -0,0 +1,251 @@
+from datetime import datetime as dt
+from datetime import timedelta as td
+from types import ModuleType
+
+SECONDS_IN_MINUTE = 60
+SECONDS_IN_HOUR = 3600
+SECONDS_IN_DAY = 86400
+SECONDS_IN_WEEK = 604800
+
+
+def get_raw_seconds(weeks, days, hours, minutes, seconds):
+    m_sec = minutes * SECONDS_IN_MINUTE
+    h_sec = hours * SECONDS_IN_HOUR
+    d_sec = days * SECONDS_IN_DAY
+    w_sec = weeks * SECONDS_IN_WEEK
+    return seconds + m_sec + h_sec + d_sec + w_sec
+
+
+def to_contract_time(py_dt):
+    if isinstance(py_dt, Datetime):
+        dt_obj = py_dt
+    elif isinstance(py_dt, dt):
+        dt_obj = py_dt
+    else:
+        raise TypeError("Expected datetime.datetime or Datetime")
+
+    return {
+        "__time__": [
+            dt_obj.year,
+            dt_obj.month,
+            dt_obj.day,
+            dt_obj.hour,
+            dt_obj.minute,
+            dt_obj.second,
+        ]
+    }
+
+
+class Datetime:
+    def __init__(
+        self, year, month, day, hour=0, minute=0, second=0, microsecond=0
+    ):
+        self._datetime = dt(
+            year=year,
+            month=month,
+            day=day,
+            hour=hour,
+            minute=minute,
+            second=second,
+            microsecond=microsecond,
+        )
+        self.year = self._datetime.year
+        self.month = self._datetime.month
+        self.day = self._datetime.day
+        self.hour = self._datetime.hour
+        self.minute = self._datetime.minute
+        self.second = self._datetime.second
+        self.microsecond = self._datetime.microsecond
+
+    def __lt__(self, other):
+        if not isinstance(other, Datetime):
+            raise TypeError(f"{type(other)} is not a Datetime!")
+        return self._datetime < other._datetime
+
+    def __le__(self, other):
+        if not isinstance(other, Datetime):
+            raise TypeError(f"{type(other)} is not a Datetime!")
+        return self._datetime <= other._datetime
+
+    def __eq__(self, other):
+        if not isinstance(other, Datetime):
+            raise TypeError(f"{type(other)} is not a Datetime!")
+        return self._datetime == other._datetime
+
+    def __ge__(self, other):
+        if not isinstance(other, Datetime):
+            raise TypeError(f"{type(other)} is not a Datetime!")
+        return self._datetime >= other._datetime
+
+    def __gt__(self, other):
+        if not isinstance(other, Datetime):
+            raise TypeError(f"{type(other)} is not a Datetime!")
+        return self._datetime > other._datetime
+
+    def __ne__(self, other):
+        if not isinstance(other, Datetime):
+            raise TypeError(f"{type(other)} is not a Datetime!")
+        return self._datetime != other._datetime
+
+    def __sub__(self, other):
+        if isinstance(other, Datetime):
+            delta = self._datetime - other._datetime
+            return Timedelta(days=delta.days, seconds=delta.seconds)
+        return NotImplemented
+
+    def __add__(self, other):
+        if isinstance(other, Timedelta):
+            return Datetime._from_datetime(self._datetime + other._timedelta)
+        return NotImplemented
+
+    def __str__(self):
+        return str(self._datetime)
+
+    def __repr__(self):
+        return self.__str__()
+
+    @classmethod
+    def _from_datetime(cls, value: dt):
+        return cls(
+            year=value.year,
+            month=value.month,
+            day=value.day,
+            hour=value.hour,
+            minute=value.minute,
+            second=value.second,
+            microsecond=value.microsecond,
+        )
+
+    @classmethod
+    def strptime(cls, date_string, format):
+        return cls._from_datetime(dt.strptime(date_string, format))
+
+
+class Timedelta:
+    def __init__(self, weeks=0, days=0, hours=0, minutes=0, seconds=0):
+        self._timedelta = td(
+            weeks=int(weeks),
+            days=int(days),
+            hours=int(hours),
+            minutes=int(minutes),
+            seconds=int(seconds),
+        )
+        self.__raw_seconds = get_raw_seconds(
+            weeks=int(weeks),
+            days=int(days),
+            hours=int(hours),
+            minutes=int(minutes),
+            seconds=int(seconds),
+        )
+
+    def __lt__(self, other):
+        if not isinstance(other, Timedelta):
+            raise TypeError(f"{type(other)} is not a Timedelta!")
+        return self._timedelta < other._timedelta
+
+    def __le__(self, other):
+        if not isinstance(other, Timedelta):
+            raise TypeError(f"{type(other)} is not a Timedelta!")
+        return self._timedelta <= other._timedelta
+
+    def __eq__(self, other):
+        if not isinstance(other, Timedelta):
+            raise TypeError(f"{type(other)} is not a Timedelta!")
+        return self._timedelta == other._timedelta
+
+    def __ge__(self, other):
+        if not isinstance(other, Timedelta):
+            raise TypeError(f"{type(other)} is not a Timedelta!")
+        return self._timedelta >= other._timedelta
+
+    def __gt__(self, other):
+        if not isinstance(other, Timedelta):
+            raise TypeError(f"{type(other)} is not a Timedelta!")
+        return self._timedelta > other._timedelta
+
+    def __ne__(self, other):
+        if not isinstance(other, Timedelta):
+            raise TypeError(f"{type(other)} is not a Timedelta!")
+        return self._timedelta != other._timedelta
+
+    def __add__(self, other):
+        if isinstance(other, Timedelta):
+            return Timedelta(
+                days=self._timedelta.days + other._timedelta.days,
+                seconds=self._timedelta.seconds + other._timedelta.seconds,
+            )
+
+        if isinstance(other, Datetime):
+            return Datetime._from_datetime(other._datetime + self._timedelta)
+
+        return NotImplemented
+
+    def __sub__(self, other):
+        if isinstance(other, Timedelta):
+            return Timedelta(
+                days=self._timedelta.days - other._timedelta.days,
+                seconds=self._timedelta.seconds - other._timedelta.seconds,
+            )
+
+        if isinstance(other, Datetime):
+            return Datetime._from_datetime(other._datetime - self._timedelta)
+
+        return NotImplemented
+
+    def __mul__(self, other):
+        if isinstance(other, Timedelta):
+            return Timedelta(
+                days=self._timedelta.days * other._timedelta.days,
+                seconds=self._timedelta.seconds * other._timedelta.seconds,
+            )
+        if isinstance(other, int):
+            return Timedelta(
+                days=self._timedelta.days * other,
+                seconds=self._timedelta.seconds * other,
+            )
+
+        return NotImplemented
+
+    def __str__(self):
+        return str(self._timedelta)
+
+    def __repr__(self):
+        return self.__str__()
+
+    @property
+    def seconds(self):
+        return self.__raw_seconds
+
+    @property
+    def minutes(self):
+        return self.__raw_seconds // SECONDS_IN_MINUTE
+
+    @property
+    def hours(self):
+        return self.__raw_seconds // SECONDS_IN_HOUR
+
+    @property
+    def days(self):
+        return self.__raw_seconds // SECONDS_IN_DAY
+
+    @property
+    def weeks(self):
+        return self.__raw_seconds // SECONDS_IN_WEEK
+
+
+WEEKS = Timedelta(weeks=1)
+DAYS = Timedelta(days=1)
+HOURS = Timedelta(hours=1)
+MINUTES = Timedelta(minutes=1)
+SECONDS = Timedelta(seconds=1)
+
+datetime_module = ModuleType("datetime")
+datetime_module.datetime = Datetime
+datetime_module.timedelta = Timedelta
+datetime_module.WEEKS = WEEKS
+datetime_module.DAYS = DAYS
+datetime_module.HOURS = HOURS
+datetime_module.MINUTES = MINUTES
+datetime_module.SECONDS = SECONDS
+
+exports = {"datetime": datetime_module}

xian_tech_runtime_types-0.1.0/src/xian_tech_runtime_types.egg-info/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: xian-tech-runtime-types
+Version: 0.1.0
+Summary: Shared deterministic runtime types for the Xian stack
+Author-email: Xian Network <info@xian.org>
+License-Expression: MIT
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# xian-tech-runtime-types
+
+Shared deterministic runtime types for the Xian stack.

xian_tech_runtime_types-0.1.0/src/xian_tech_runtime_types.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+src/xian_runtime_types/__init__.py
+src/xian_runtime_types/decimal.py
+src/xian_runtime_types/encoding.py
+src/xian_runtime_types/time.py
+src/xian_tech_runtime_types.egg-info/PKG-INFO
+src/xian_tech_runtime_types.egg-info/SOURCES.txt
+src/xian_tech_runtime_types.egg-info/dependency_links.txt
+src/xian_tech_runtime_types.egg-info/top_level.txt

xian_tech_runtime_types-0.1.0/src/xian_tech_runtime_types.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

xian_tech_runtime_types-0.1.0/src/xian_tech_runtime_types.egg-info/top_level.txt

@@ -0,0 +1 @@
+xian_runtime_types