opalib 0.2.0__tar.gz → 0.3.0__tar.gz

{opalib-0.2.0 → opalib-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opalib
-Version: 0.2.0
+Version: 0.3.0
 Summary: A library to do multiple things
 Author-email: Donovan <donovandelisle7@gmail.com>
 Requires-Python: >=3.8
@@ -10,3 +10,8 @@ Dynamic: license-file
 
 # opalib
 A library to do multiple things
+
+## New modules
+
+- `src/physics.py`: gravity, force, kinetic energy, potential energy, and projectile motion helpers.
+- `src/units.py`: length unit conversions including `studs`, meters, feet, and custom units.

opalib-0.3.0/README.md

@@ -0,0 +1,7 @@
+# opalib
+A library to do multiple things
+
+## New modules
+
+- `src/physics.py`: gravity, force, kinetic energy, potential energy, and projectile motion helpers.
+- `src/units.py`: length unit conversions including `studs`, meters, feet, and custom units.

{opalib-0.2.0 → opalib-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "opalib"
-version = "0.2.0"
+version = "0.3.0"
 description = "A library to do multiple things"
 authors = [
     { name="Donovan", email="donovandelisle7@gmail.com" }
@@ -13,7 +13,7 @@ requires = ["setuptools"]
 build-backend = "setuptools.build_meta"
 
 [tool.bumpver]
-current_version = "0.2.0"
+current_version = "0.3.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "bump version {old_version} -> {new_version}"
 tag_message = "v{new_version}"

{opalib-0.2.0 → opalib-0.3.0}/src/__init__.py

@@ -1,15 +1,21 @@
 # __init__.py
+
+"""opalib package API."""
+
 import os
 import importlib
 
-# Get all .py files in this folder (excluding this file)
+__all__ = []
+
 pkg_dir = os.path.dirname(__file__)
 for file in os.listdir(pkg_dir):
     if file.endswith(".py") and file != "__init__.py":
         module_name = file[:-3]
         module = importlib.import_module(f".{module_name}", package=__name__)
-        
-        # Expose everything from the module to the package level
+
         for attribute in dir(module):
-            if not attribute.startswith("_"):
-                globals()[attribute] = getattr(module, attribute)
+            if attribute.startswith("_"):
+                continue
+            globals()[attribute] = getattr(module, attribute)
+            if attribute not in __all__:
+                __all__.append(attribute)

opalib-0.3.0/src/format.py

@@ -0,0 +1,216 @@
+"""format - serialization format helpers for opalib."""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+
+from . import util
+
+
+class RefType:
+    def __init__(self) -> None:
+        self._cache: Dict[str, Dict[str, Any]] = {}
+
+    def __getattr__(self, name: str) -> Dict[str, Any]:
+        if name not in self._cache:
+            self._cache[name] = {"type": "ref", "of": name}
+        return self._cache[name]
+
+
+F = SimpleNamespace(
+    _VERSION=3,
+    ID={},
+    V3={},
+    Byte={},
+    Double={},
+    Int={},
+    Int64={},
+    String={},
+    Any={},
+    Bool={},
+    Ref=RefType(),
+)
+
+
+def map_(k_format: Any, v_format: Any) -> Dict[str, Any]:
+    return {"type": "map", "k_format": k_format, "v_format": v_format}
+
+
+def list_(v_format: Any, key: Optional[str] = None) -> Dict[str, Any]:
+    return {"type": "list", "v_format": v_format, "key": key}
+
+
+def array(len_: int, v_format: Any, key: Optional[str] = None) -> Dict[str, Any]:
+    return {"type": "array", "v_format": v_format, "len": len_, "key": key}
+
+
+def union(*args: Any) -> Dict[str, Any]:
+    return {"type": "union", "formats": list(args)}
+
+
+def struct(fields: Sequence[Dict[str, Any]]) -> Dict[str, Any]:
+    return {"type": "struct", "fields": list(fields)}
+
+
+def konst(value: Any, v_format: Any, is_serialized: bool) -> Dict[str, Any]:
+    return {
+        "type": "konst",
+        "value": value,
+        "v_format": v_format,
+        "is_serialized": is_serialized,
+    }
+
+
+def save(name: str, v_format: Any) -> Dict[str, Any]:
+    return {"type": "save", "name": name, "v_format": v_format}
+
+
+def compat(func: Callable[[Any], Any]) -> Dict[str, Any]:
+    return {"type": "compat", "func": func}
+
+
+def enable_if(cond: Callable[[bytes, int, Any], bool], v_format: Any) -> Dict[str, Any]:
+    return {"type": "enable_if", "cond": cond, "v_format": v_format}
+
+
+def format_(name: str, t: Dict[str, Any]) -> Dict[str, Any]:
+    t["name"] = name
+    setattr(F, name, t)
+    return t
+
+
+def new(name: str, t: Dict[str, Any]) -> Dict[str, Any]:
+    t["name"] = name
+    setattr(F, name, t)
+    return t
+
+
+def GE_VER(ver: int, on_true: Any, on_false: Any) -> Dict[str, Any]:
+    return compat(lambda ctx: on_true if getattr(ctx, "version", 0) >= ver else on_false)
+
+
+F.map = map_
+F.list = list_
+F.array = array
+F.union = union
+F.struct = struct
+F.konst = konst
+F.save = save
+F.compat = compat
+F.enable_if = enable_if
+F.format = format_
+F.new = new
+F.GE_VER = GE_VER
+
+
+def _load_string(data: bytes, i: int) -> tuple[str, int]:
+    return util.read_s(data, i)
+
+
+def _load_bool(data: bytes, i: int) -> tuple[bool, int]:
+    b = data[i]
+    return b == 1, i + 1
+
+
+def _load_v3(data: bytes, i: int) -> tuple[util.Vector3, int]:
+    return util.read_v(data, i)
+
+
+def _load_byte(data: bytes, i: int) -> tuple[int, int]:
+    return data[i], i + 1
+
+
+def _load_double(data: bytes, i: int) -> tuple[float, int]:
+    return util.read_d(data, i)
+
+
+def _load_int(data: bytes, i: int) -> tuple[int, int]:
+    return util.read_i(data, i)
+
+
+def _load_int64(data: bytes, i: int) -> tuple[int, int]:
+    return util.read_i64(data, i)
+
+
+def _load_any(data: bytes, i: int) -> tuple[Any, int]:
+    return util.read_a(data, i)
+
+
+def _save_string(data: List[bytes], value: str) -> None:
+    util.a(data, util.s2b(value))
+
+
+def _save_bool(data: List[bytes], value: bool) -> None:
+    util.a(data, b"\x01" if value else b"\x00")
+
+
+def _save_v3(data: List[bytes], value: util.Vector3) -> None:
+    util.a(data, util.v2b(value))
+
+
+def _save_byte(data: List[bytes], value: int) -> None:
+    util.a(data, bytes([value]))
+
+
+def _save_double(data: List[bytes], value: float) -> None:
+    util.a(data, util.d2b(value))
+
+
+def _save_int(data: List[bytes], value: int) -> None:
+    util.a(data, util.i2b(value))
+
+
+def _save_int64(data: List[bytes], value: int) -> None:
+    util.a(data, util.i642b(value))
+
+
+def _save_any(data: List[bytes], value: Any) -> None:
+    util.a(data, util.a2b(value))
+
+
+F.String["load"] = _load_string
+F.Bool["load"] = _load_bool
+F.V3["load"] = _load_v3
+F.Byte["load"] = _load_byte
+F.Double["load"] = _load_double
+F.Int["load"] = _load_int
+F.Int64["load"] = _load_int64
+F.Any["load"] = _load_any
+
+F.String["save"] = _save_string
+F.Bool["save"] = _save_bool
+F.V3["save"] = _save_v3
+F.Byte["save"] = _save_byte
+F.Double["save"] = _save_double
+F.Int["save"] = _save_int
+F.Int64["save"] = _save_int64
+F.Any["save"] = _save_any
+
+
+F.new(
+    "Challenge",
+    F.struct(
+        [
+            {"signature": F.array(16, F.Byte)},
+            {"issued": F.Int64},
+            {"difficulty": F.Byte},
+            {"K00": F.Int},
+            {"K01": F.Int},
+            {"K10": F.Int},
+            {"K11": F.Int},
+        ]
+    ),
+)
+
+F.new(
+    "Solution",
+    F.struct(
+        [
+            {"x": F.Int},
+            {"y": F.Int},
+        ]
+    ),
+)
+
+__all__ = ["F", "RefType"]

opalib-0.3.0/src/ieee754.py

@@ -0,0 +1,25 @@
+"""ieee754 - IEEE 754 double conversion helpers."""
+
+import struct
+from typing import Union
+
+
+def _to_bytes(value: Union[str, bytes]) -> bytes:
+    if isinstance(value, str):
+        return value.encode("latin1")
+    return value
+
+
+def bin2double(value: Union[str, bytes]) -> float:
+    """Convert an 8-byte sequence to a double-precision float."""
+    raw = _to_bytes(value)
+    if len(raw) != 8:
+        raise ValueError("bin2double requires exactly 8 bytes")
+    return struct.unpack("<d", raw)[0]
+
+
+def double2bin(value: float) -> bytes:
+    """Convert a double-precision float to an 8-byte sequence."""
+    return struct.pack("<d", value)
+
+__all__ = ["bin2double", "double2bin"]

opalib-0.3.0/src/libdeflate.py

@@ -0,0 +1,59 @@
+"""libdeflate - minimal DEFLATE wrappers for opalib."""
+
+import zlib
+from typing import Any, Dict, Optional, Union
+
+
+def _to_bytes(value: Union[str, bytes]) -> bytes:
+    if isinstance(value, str):
+        return value.encode("latin1")
+    return value
+
+
+class LibDeflateClass:
+    """Minimal wrapper around Python's zlib for raw DEFLATE data."""
+
+    def CompressDeflate(
+        self,
+        data: Union[str, bytes],
+        configs: Optional[Dict[str, Any]] = None,
+    ) -> bytes:
+        """Compress raw data using DEFLATE with no zlib header."""
+        bytes_data = _to_bytes(data)
+        level = 9
+        if configs is not None and isinstance(configs, dict):
+            if "level" in configs:
+                level = int(configs["level"])
+
+        compressor = zlib.compressobj(level, zlib.DEFLATED, -zlib.MAX_WBITS)
+        return compressor.compress(bytes_data) + compressor.flush()
+
+    def DecompressDeflate(self, data: Union[str, bytes]) -> bytes:
+        """Decompress raw DEFLATE bytes."""
+        bytes_data = _to_bytes(data)
+        decompressor = zlib.decompressobj(-zlib.MAX_WBITS)
+        return decompressor.decompress(bytes_data) + decompressor.flush()
+
+    def CompressZlib(
+        self,
+        data: Union[str, bytes],
+        configs: Optional[Dict[str, Any]] = None,
+    ) -> bytes:
+        """Compress data using zlib wrapper format."""
+        bytes_data = _to_bytes(data)
+        level = 9
+        if configs is not None and isinstance(configs, dict):
+            if "level" in configs:
+                level = int(configs["level"])
+
+        return zlib.compress(bytes_data, level)
+
+    def DecompressZlib(self, data: Union[str, bytes]) -> bytes:
+        """Decompress zlib-wrapped compressed data."""
+        bytes_data = _to_bytes(data)
+        return zlib.decompress(bytes_data)
+
+
+LibDeflate = LibDeflateClass()
+
+__all__ = ["LibDeflate"]

{opalib-0.2.0 → opalib-0.3.0}/src/opalib.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: opalib
-Version: 0.2.0
+Version: 0.3.0
 Summary: A library to do multiple things
 Author-email: Donovan <donovandelisle7@gmail.com>
 Requires-Python: >=3.8
@@ -10,3 +10,8 @@ Dynamic: license-file
 
 # opalib
 A library to do multiple things
+
+## New modules
+
+- `src/physics.py`: gravity, force, kinetic energy, potential energy, and projectile motion helpers.
+- `src/units.py`: length unit conversions including `studs`, meters, feet, and custom units.

opalib-0.3.0/src/opalib.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+pyproject.toml
+src/__init__.py
+src/enum_extender.py
+src/format.py
+src/ieee754.py
+src/libdeflate.py
+src/physics.py
+src/units.py
+src/util.py
+src/web.py
+src/opalib.egg-info/PKG-INFO
+src/opalib.egg-info/SOURCES.txt
+src/opalib.egg-info/dependency_links.txt
+src/opalib.egg-info/top_level.txt
+src/tests/enum_test.py
+src/tests/format_test.py
+src/tests/ieee754_test.py
+src/tests/libdeflate_test.py
+src/tests/physics_test.py
+src/tests/units_test.py
+src/tests/util_test.py
+src/tests/web_test.py

opalib-0.3.0/src/opalib.egg-info/top_level.txt

@@ -0,0 +1,10 @@
+__init__
+enum_extender
+format
+ieee754
+libdeflate
+physics
+tests
+units
+util
+web

opalib-0.3.0/src/physics.py

@@ -0,0 +1,61 @@
+"""opalib.physics - simple physics helpers for motion and gravity calculations."""
+
+from math import radians, sin, sqrt
+from typing import Dict
+
+GRAVITY_EARTH = 9.80665
+GRAVITY_MOON = 1.62
+GRAVITY_MARS = 3.71
+
+__all__ = [
+    "GRAVITY_EARTH",
+    "GRAVITY_MOON",
+    "GRAVITY_MARS",
+    "force",
+    "kinetic_energy",
+    "potential_energy",
+    "fall_time",
+    "projectile_max_height",
+    "projectile_range",
+    "projectile_time_of_flight",
+]
+
+
+def force(mass: float, acceleration: float) -> float:
+    """Calculate force from mass and acceleration (F = m * a)."""
+    return mass * acceleration
+
+
+def kinetic_energy(mass: float, velocity: float) -> float:
+    """Calculate kinetic energy in joules (1/2 m v^2)."""
+    return 0.5 * mass * velocity * velocity
+
+
+def potential_energy(mass: float, height: float, gravity: float = GRAVITY_EARTH) -> float:
+    """Calculate gravitational potential energy in joules (m * g * h)."""
+    return mass * gravity * height
+
+
+def fall_time(height: float, gravity: float = GRAVITY_EARTH) -> float:
+    """Estimate free-fall time from a height using t = sqrt(2h/g)."""
+    if height < 0:
+        raise ValueError("Height must be non-negative")
+    return sqrt(2 * height / gravity)
+
+
+def projectile_range(velocity: float, angle_deg: float, gravity: float = GRAVITY_EARTH) -> float:
+    """Compute the horizontal range of a projectile launched at an angle."""
+    angle_rad = radians(angle_deg)
+    return (velocity * velocity * sin(2 * angle_rad)) / gravity
+
+
+def projectile_max_height(velocity: float, angle_deg: float, gravity: float = GRAVITY_EARTH) -> float:
+    """Compute the maximum height reached by a projectile."""
+    angle_rad = radians(angle_deg)
+    return (velocity * velocity * sin(angle_rad) ** 2) / (2 * gravity)
+
+
+def projectile_time_of_flight(velocity: float, angle_deg: float, gravity: float = GRAVITY_EARTH) -> float:
+    """Compute the total flight time for a projectile."""
+    angle_rad = radians(angle_deg)
+    return (2 * velocity * sin(angle_rad)) / gravity

opalib-0.3.0/src/tests/enum_test.py

@@ -0,0 +1,4 @@
+from .. import Enums
+
+Enums.new("HTTPMethod", ["GET", "POST", "PUT", "DELETE"])
+print(Enums.HTTPMethod.GET)

opalib-0.3.0/src/tests/format_test.py

@@ -0,0 +1,22 @@
+"""Tests for the format module."""
+
+import unittest
+from src import format, util
+
+
+class TestFormat(unittest.TestCase):
+    def test_bool_save_load(self):
+        data = []
+        format.F.Bool["save"](data, True)
+        result, _ = util.read_a(b"".join(data), 0)
+        self.assertTrue(result)
+
+    def test_string_save_and_read(self):
+        data = []
+        format.F.String["save"](data, "hello")
+        result, _ = util.read_s(b"".join(data), 0)
+        self.assertEqual(result, "hello")
+
+    def test_challenge_format_defined(self):
+        self.assertTrue(hasattr(format.F, "Challenge"))
+        self.assertTrue(isinstance(format.F.Challenge, dict))

opalib-0.3.0/src/tests/ieee754_test.py

@@ -0,0 +1,15 @@
+"""Tests for the ieee754 module."""
+
+import unittest
+from src import ieee754
+
+
+class TestIEEE754(unittest.TestCase):
+    def test_double_roundtrip(self):
+        value = 3.141592653589793
+        binary = ieee754.double2bin(value)
+        self.assertEqual(ieee754.bin2double(binary), value)
+
+    def test_bin2double_requires_eight_bytes(self):
+        with self.assertRaises(ValueError):
+            ieee754.bin2double(b"123")

opalib-0.3.0/src/tests/libdeflate_test.py

@@ -0,0 +1,19 @@
+"""Tests for the libdeflate module."""
+
+import unittest
+from src import LibDeflate
+
+
+class TestLibDeflate(unittest.TestCase):
+    def test_deflate_roundtrip(self):
+        payload = b"hello world\x00\x00"
+        compressed = LibDeflate.CompressDeflate(payload, {"level": 9})
+        decompressed = LibDeflate.DecompressDeflate(compressed)
+
+        self.assertEqual(decompressed, payload)
+
+    def test_zlib_roundtrip(self):
+        payload = b"hello zlib"
+        compressed = LibDeflate.CompressZlib(payload)
+        decompressed = LibDeflate.DecompressZlib(compressed)
+        self.assertEqual(decompressed, payload)

opalib-0.3.0/src/tests/physics_test.py

@@ -0,0 +1,43 @@
+"""Unit tests for opalib.physics."""
+
+import unittest
+from src import (
+    force,
+    kinetic_energy,
+    potential_energy,
+    fall_time,
+    projectile_range,
+    projectile_max_height,
+    projectile_time_of_flight,
+    GRAVITY_EARTH,
+)
+
+
+class TestPhysics(unittest.TestCase):
+    def test_force(self):
+        self.assertEqual(force(10, 9.8), 98.0)
+
+    def test_kinetic_energy(self):
+        self.assertEqual(kinetic_energy(2, 3), 9.0)
+
+    def test_potential_energy(self):
+        self.assertEqual(potential_energy(1, 2, gravity=10), 20)
+
+    def test_fall_time(self):
+        self.assertAlmostEqual(fall_time(4, gravity=GRAVITY_EARTH), 0.9035, places=4)
+
+    def test_projectile_range(self):
+        result = projectile_range(10, 45, gravity=GRAVITY_EARTH)
+        self.assertAlmostEqual(result, (10 * 10 * 1.0) / GRAVITY_EARTH, places=4)
+
+    def test_projectile_max_height(self):
+        result = projectile_max_height(10, 45, gravity=GRAVITY_EARTH)
+        self.assertAlmostEqual(result, (10 * 10 * 0.5) / (2 * GRAVITY_EARTH), places=4)
+
+    def test_projectile_time_of_flight(self):
+        result = projectile_time_of_flight(10, 45, gravity=GRAVITY_EARTH)
+        self.assertAlmostEqual(result, (2 * 10 * 0.70710678) / GRAVITY_EARTH, places=4)
+
+    def test_fall_time_negative_height(self):
+        with self.assertRaises(ValueError):
+            fall_time(-1)

opalib-0.3.0/src/tests/units_test.py

@@ -0,0 +1,24 @@
+"""Unit tests for opalib.units."""
+
+import unittest
+from src import convert, STUD_TO_METER, list_units, register_unit
+
+
+class TestUnits(unittest.TestCase):
+    def test_convert_studs_to_meters(self):
+        self.assertAlmostEqual(convert(1, "studs", "meters"), STUD_TO_METER)
+
+    def test_convert_meters_to_studs(self):
+        self.assertAlmostEqual(convert(0.28, "meters", "studs"), 1.0, places=6)
+
+    def test_convert_feet_to_studs(self):
+        self.assertAlmostEqual(convert(1, "feet", "studs"), 0.3048 / STUD_TO_METER, places=6)
+
+    def test_register_custom_unit(self):
+        register_unit("test-unit", 2.5)
+        self.assertAlmostEqual(convert(2, "test-unit", "meters"), 5.0)
+        self.assertIn("test-unit", list_units())
+
+    def test_unsupported_unit(self):
+        with self.assertRaises(ValueError):
+            convert(1, "unknown", "meters")

opalib-0.3.0/src/tests/util_test.py

@@ -0,0 +1,37 @@
+"""Tests for the util module."""
+
+import unittest
+from src import util
+
+
+class TestUtil(unittest.TestCase):
+    def test_mod1(self):
+        self.assertEqual(util.mod1_dec(1, 5), 4)
+        self.assertEqual(util.mod1_inc(4, 5), 5)
+
+    def test_validate_bool(self):
+        self.assertTrue(util.validate_bool("t"))
+        self.assertFalse(util.validate_bool("false"))
+        self.assertIsNone(util.validate_bool("maybe"))
+
+    def test_b2i_and_b2i64(self):
+        self.assertEqual(util.b2i(b"\x01\x00\x00\x00"), 1)
+        self.assertEqual(util.b2i64(b"\x01\x00\x00\x00\x00\x00\x00\x00"), 1)
+
+    def test_vector_roundtrip(self):
+        vec = util.Vector3(1.0, 2.0, 3.0)
+        data = util.v2b(vec)
+        result, _ = util.read_v(data, 0)
+        self.assertEqual(result, vec)
+
+    def test_encode_decode_zeros(self):
+        payload = b"\x00\x00ABC\xff"
+        encoded = util.encode_zeros(payload)
+        decoded = util.decode_zeros(encoded)
+        self.assertEqual(decoded, payload)
+
+    def test_encode_decode_with_deflate(self):
+        payload = b"test payload\x00\x00"
+        encoded = util.encode(payload)
+        decoded = util.decode(encoded)
+        self.assertEqual(decoded, payload)

opalib-0.3.0/src/units.py

@@ -0,0 +1,72 @@
+"""opalib.units - unit conversion helpers for length and custom measures."""
+
+from typing import Dict
+
+STUD_TO_METER = 0.28
+"""Conversion factor from studs to meters."""
+
+_UNIT_FACTORS: Dict[str, float] = {
+    "meter": 1.0,
+    "meters": 1.0,
+    "m": 1.0,
+    "stud": STUD_TO_METER,
+    "studs": STUD_TO_METER,
+    "st": STUD_TO_METER,
+    "foot": 0.3048,
+    "feet": 0.3048,
+    "ft": 0.3048,
+    "inch": 0.0254,
+    "inches": 0.0254,
+    "in": 0.0254,
+    "kilometer": 1000.0,
+    "kilometers": 1000.0,
+    "km": 1000.0,
+}
+
+__all__ = [
+    "STUD_TO_METER",
+    "to_meters",
+    "from_meters",
+    "convert",
+    "register_unit",
+    "list_units",
+]
+
+
+def _normalize_unit(unit: str) -> str:
+    return unit.strip().lower()
+
+
+def to_meters(value: float, unit: str) -> float:
+    """Convert a value from a supported unit to meters."""
+    unit_key = _normalize_unit(unit)
+    if unit_key not in _UNIT_FACTORS:
+        raise ValueError(f"Unsupported unit: {unit}")
+    return value * _UNIT_FACTORS[unit_key]
+
+
+def from_meters(value: float, unit: str) -> float:
+    """Convert a value in meters to a supported unit."""
+    unit_key = _normalize_unit(unit)
+    if unit_key not in _UNIT_FACTORS:
+        raise ValueError(f"Unsupported unit: {unit}")
+    return value / _UNIT_FACTORS[unit_key]
+
+
+def convert(value: float, from_unit: str, to_unit: str) -> float:
+    """Convert a value between two supported units."""
+    meters = to_meters(value, from_unit)
+    return from_meters(meters, to_unit)
+
+
+def register_unit(name: str, factor_to_meters: float) -> None:
+    """Register a custom unit conversion factor to meters."""
+    unit_key = _normalize_unit(name)
+    if factor_to_meters <= 0:
+        raise ValueError("Conversion factor must be positive")
+    _UNIT_FACTORS[unit_key] = factor_to_meters
+
+
+def list_units() -> Dict[str, float]:
+    """Return all registered unit conversion factors."""
+    return dict(_UNIT_FACTORS)

opalib-0.3.0/src/util.py

@@ -0,0 +1,469 @@
+"""util - low-level binary and utility helpers converted from util.lua."""
+
+from __future__ import annotations
+
+import math
+import traceback
+from dataclasses import dataclass
+from typing import Any, Callable, Dict, List, Optional, Tuple, Union
+
+from . import ieee754
+from .libdeflate import LibDeflate
+
+
+@dataclass
+class Vector3:
+    X: float
+    Y: float
+    Z: float
+
+
+prec = 1e-3
+prec2 = prec ** 2
+
+_epsilon = 1.0
+while 1.0 + _epsilon != 1.0:
+    _epsilon *= 0.5
+
+e = _epsilon
+
+max_parallel_angle = 1
+mpa_cos = math.cos(max_parallel_angle / 360 * 2 * math.pi)
+
+
+class Context:
+    def __init__(self) -> None:
+        self.stack: List[Any] = []
+        self._attrs: Dict[str, Any] = {}
+
+    def __getitem__(self, key: Union[int, str]) -> Any:
+        if isinstance(key, int):
+            return self.stack[key - 1]
+        return self._attrs[key]
+
+    def __setitem__(self, key: Union[int, str], value: Any) -> None:
+        if isinstance(key, int):
+            index = key - 1
+            if index == len(self.stack):
+                self.stack.append(value)
+            elif 0 <= index < len(self.stack):
+                self.stack[index] = value
+            else:
+                raise IndexError("Context index out of range")
+        else:
+            self._attrs[key] = value
+
+    def __getattr__(self, name: str) -> Any:
+        if name in {"stack", "_attrs"}:
+            raise AttributeError
+        return self._attrs.get(name)
+
+    def __setattr__(self, name: str, value: Any) -> None:
+        if name in {"stack", "_attrs"}:
+            super().__setattr__(name, value)
+        else:
+            self._attrs[name] = value
+
+    def __len__(self) -> int:
+        return len(self.stack)
+
+
+def _to_bytes(value: Union[str, bytes]) -> bytes:
+    if isinstance(value, str):
+        return value.encode("latin1")
+    return value
+
+
+def mod1_dec(x: float, m: float) -> float:
+    return (x - 2) % m + 1
+
+
+def mod1_inc(x: float, m: float) -> float:
+    return x % m + 1
+
+
+def bind(f: Callable[..., Any], obj: Any) -> Callable[..., Any]:
+    def bound(*args: Any, **kwargs: Any) -> Any:
+        return f(obj, *args, **kwargs)
+
+    return bound
+
+
+def union_k(*dicts: Dict[Any, Any]) -> Dict[Any, Any]:
+    result: Dict[Any, Any] = {}
+    for source in dicts:
+        result.update(source)
+    return result
+
+
+def union_i(*iterables: List[Any]) -> List[Any]:
+    result: List[Any] = []
+    for sequence in iterables:
+        result.extend(sequence)
+    return result
+
+
+def validate_bool(txt: str) -> Optional[bool]:
+    lower = txt.lower()
+    if lower in {"true", "t"}:
+        return True
+    if lower in {"false", "f"}:
+        return False
+    return None
+
+
+def get_trace(msg: str) -> str:
+    return f"{msg}; {traceback.format_exc()}"
+
+
+def pcall(f: Callable[..., Any], *args: Any, **kwargs: Any) -> Tuple[bool, Any]:
+    try:
+        return True, f(*args, **kwargs)
+    except Exception as exc:
+        return False, get_trace(str(exc))
+
+
+b2d = ieee754.bin2double
+
+
+def b2i(b: Union[str, bytes]) -> int:
+    raw = _to_bytes(b)
+    return int.from_bytes(raw, byteorder="little", signed=False)
+
+
+def b2i64(b: Union[str, bytes]) -> int:
+    raw = _to_bytes(b)
+    return int.from_bytes(raw, byteorder="little", signed=False)
+
+
+def b2v(b: Union[str, bytes]) -> Vector3:
+    raw = _to_bytes(b)
+    x = b2d(raw[0:8])
+    y = b2d(raw[8:16])
+    z = b2d(raw[16:24])
+    return Vector3(X=x, Y=y, Z=z)
+
+
+def read_i(data: Union[str, bytes], i: int) -> Tuple[int, int]:
+    raw = _to_bytes(data)
+    value = int.from_bytes(raw[i : i + 4], byteorder="little", signed=False)
+    return value, i + 4
+
+
+def read_i64(data: Union[str, bytes], i: int) -> Tuple[int, int]:
+    raw = _to_bytes(data)
+    value = int.from_bytes(raw[i : i + 8], byteorder="little", signed=False)
+    return value, i + 8
+
+
+def read_d(data: Union[str, bytes], i: int) -> Tuple[float, int]:
+    raw = _to_bytes(data)
+    value = b2d(raw[i : i + 8])
+    return value, i + 8
+
+
+def read_v(data: Union[str, bytes], i: int) -> Tuple[Vector3, int]:
+    raw = _to_bytes(data)
+    vector = b2v(raw[i : i + 24])
+    return vector, i + 24
+
+
+def read_t(data: Union[str, bytes], i: int) -> Tuple[int, int]:
+    raw = _to_bytes(data)
+    return raw[i], i + 1
+
+
+def read_s(data: Union[str, bytes], i: int) -> Tuple[str, int]:
+    raw = _to_bytes(data)
+    length, i = read_i(raw, i)
+    value = raw[i : i + length].decode("latin1")
+    return value, i + length
+
+
+def read_a(data: Union[str, bytes], i: int) -> Tuple[Any, int]:
+    raw = _to_bytes(data)
+    ty, i = read_t(raw, i)
+    if ty == 0:
+        return read_s(raw, i)
+    if ty == 1:
+        return read_d(raw, i)
+    raise ValueError(f"Received unknown field type: {ty}")
+
+
+def decode(value: Union[str, bytes]) -> bytes:
+    return LibDeflate.DecompressDeflate(decode_zeros(_to_bytes(value)))
+
+
+def decode_params(data: Union[str, bytes], i: int) -> Tuple[Dict[str, Any], int]:
+    raw = _to_bytes(data)
+    fields: Dict[str, Any] = {}
+    n, i = read_i(raw, i)
+    for _ in range(n):
+        name, i = read_s(raw, i)
+        value, i = read_a(raw, i)
+        fields[name] = value
+    return fields, i
+
+
+def load(
+    data: Union[str, bytes],
+    i: int,
+    format: Optional[Dict[str, Any]],
+    context: Context,
+) -> Tuple[Any, int]:
+    raw = _to_bytes(data)
+    if format is None:
+        return None, i
+
+    class_format = None
+    if isinstance(format, dict) and "format" in format:
+        class_format = format
+        format = format["format"]
+
+    obj: Any = None
+    if isinstance(format, dict) and not format:
+        # format.ID is represented by an empty dictionary in this conversion.
+        obj = len(context) + 1
+    elif isinstance(format, dict) and "type" in format:
+        fmt_type = format["type"]
+        if fmt_type == "compat":
+            obj, i = load(raw, i, format["func"](context), context)
+        elif fmt_type == "ref":
+            id_ = None
+            id_, i = read_i(raw, i)
+            obj = context[format["of"]][id_]
+        elif fmt_type == "konst":
+            if format.get("is_serialized"):
+                obj, i = load(raw, i, format["v_format"], context)
+            else:
+                obj = format["value"]
+        elif fmt_type == "save":
+            obj, i = load(raw, i, format["v_format"], context)
+            context[format["name"]] = obj
+        elif fmt_type == "enable_if":
+            if format["cond"](raw, i, context):
+                obj, i = load(raw, i, format["v_format"], context)
+        elif fmt_type == "union":
+            obj = {}
+            for v_format in format["formats"]:
+                context.obj = obj
+                obj, i = load(raw, i, v_format, context)
+        else:
+            obj = getattr(context, "obj", None)
+            if obj is not None:
+                context.obj = None
+            else:
+                obj = {}
+
+            if format.get("key"):
+                context[format["key"]] = obj
+
+            if fmt_type == "struct":
+                for field in format["fields"]:
+                    for k, v_format in field.items():
+                        obj[k], i = load(raw, i, v_format, context)
+            elif fmt_type == "array":
+                v_format = format["v_format"]
+                arr: List[Any] = []
+                for _ in range(format["len"]):
+                    item, i = load(raw, i, v_format, context)
+                    arr.append(item)
+                obj = arr
+            else:
+                n, i = read_i(raw, i)
+                stack_id = len(context) + 1
+                context[stack_id] = obj
+                if fmt_type == "list":
+                    v_format = format["v_format"]
+                    arr = []
+                    for _ in range(n):
+                        item, i = load(raw, i, v_format, context)
+                        arr.append(item)
+                    obj = arr
+                elif fmt_type == "map":
+                    v_format_k = format["k_format"]
+                    v_format_v = format["v_format"]
+                    for _ in range(n):
+                        key, i = load(raw, i, v_format_k, context)
+                        if key is not None:
+                            value, i = load(raw, i, v_format_v, context)
+                            obj[key] = value
+                context[stack_id] = None
+
+    if class_format is not None and isinstance(class_format, dict) and class_format.get("MT"):
+        # Python does not support Lua metatables directly. Skip this behavior.
+        pass
+
+    if isinstance(format, dict) and format.get("load"):
+        obj, i = format["load"](raw, i)
+
+    return obj, i
+
+
+def a(data: List[bytes], value: bytes) -> None:
+    data.append(value)
+    if hasattr(data, "size"):
+        data.size += len(value)
+
+
+def i2b(x: int) -> bytes:
+    return x.to_bytes(4, byteorder="little", signed=False)
+
+
+def i642b(x: int) -> bytes:
+    return x.to_bytes(8, byteorder="little", signed=False)
+
+
+def v2b(v: Vector3) -> bytes:
+    return d2b(v.X) + d2b(v.Y) + d2b(v.Z)
+
+
+def s2b(s: str) -> bytes:
+    encoded = s.encode("latin1")
+    return i2b(len(encoded)) + encoded
+
+
+def a2b(v: Any) -> bytes:
+    if isinstance(v, str):
+        return b"\x00" + s2b(v)
+    if isinstance(v, (int, float)):
+        return b"\x01" + d2b(float(v))
+    raise TypeError("Unsupported value type for a2b")
+
+
+def encode(value: Union[str, bytes]) -> bytes:
+    return encode_zeros(LibDeflate.CompressDeflate(_to_bytes(value), {"level": 9}))
+
+special = bytes([255])
+null = bytes([0])
+
+
+def encode_zeros(value: Union[str, bytes]) -> bytes:
+    raw = _to_bytes(value)
+    result: List[bytes] = []
+    i = 0
+    n = len(raw)
+    while i < n:
+        b = raw[i]
+        if b == 0:
+            m = 1
+            while i + 1 < n and m < 254 and raw[i + 1] == 0:
+                m += 1
+                i += 1
+            result.append(special)
+            result.append(bytes([m]))
+        elif b == 255:
+            result.append(special)
+            result.append(special)
+        else:
+            result.append(bytes([b]))
+        i += 1
+    return b"".join(result)
+
+
+def decode_zeros(value: Union[str, bytes]) -> bytes:
+    raw = _to_bytes(value)
+    result: List[bytes] = []
+    i = 0
+    n = len(raw)
+    while i < n:
+        b = raw[i]
+        if b == 255:
+            i += 1
+            b2 = raw[i]
+            if b2 == 255:
+                result.append(special)
+            else:
+                result.extend([null] * b2)
+        else:
+            result.append(bytes([b]))
+        i += 1
+    return b"".join(result)
+
+
+def save(data: List[bytes], obj: Any, format: Optional[Dict[str, Any]], context: Context) -> None:
+    if not format:
+        return
+
+    if isinstance(format, dict) and "format" in format:
+        format = format["format"]
+
+    if isinstance(format, dict) and "type" in format:
+        fmt_type = format["type"]
+        if fmt_type == "compat":
+            save(data, obj, format["func"](context), context)
+        elif fmt_type == "ref":
+            a(data, i2b(obj.id))
+        elif fmt_type == "konst":
+            if format.get("is_serialized"):
+                save(data, format["value"], format["v_format"], context)
+        elif fmt_type == "save":
+            save(data, obj, format["v_format"], context)
+            if format["v_format"].get("type") == "konst":
+                context[format["name"]] = format["v_format"]["value"]
+            else:
+                context[format["name"]] = obj
+        elif fmt_type == "enable_if":
+            save(data, obj, format["v_format"], context)
+        elif fmt_type == "union":
+            for v_format in format["formats"]:
+                save(data, obj, v_format, context)
+        elif fmt_type == "struct":
+            for field in format["fields"]:
+                for _, v_format in field.items():
+                    save(data, obj.get(next(iter(field.keys())), None), v_format, context)
+        elif fmt_type == "array":
+            for value in obj:
+                save(data, value, format["v_format"], context)
+        elif fmt_type == "list":
+            a(data, i2b(len(obj)))
+            for value in obj:
+                save(data, value, format["v_format"], context)
+        elif fmt_type == "map":
+            a(data, i2b(len(obj)))
+            for key, value in obj.items():
+                save(data, key, format["k_format"], context)
+                save(data, value, format["v_format"], context)
+        else:
+            raise ValueError(f"Unknown format type: {fmt_type}")
+
+    if isinstance(format, dict) and format.get("save"):
+        format["save"](data, obj)
+
+
+__all__ = [
+    "Vector3",
+    "Context",
+    "mod1_dec",
+    "mod1_inc",
+    "bind",
+    "union_k",
+    "union_i",
+    "validate_bool",
+    "get_trace",
+    "pcall",
+    "b2d",
+    "b2i",
+    "b2i64",
+    "b2v",
+    "read_i",
+    "read_i64",
+    "read_d",
+    "read_v",
+    "read_t",
+    "read_s",
+    "read_a",
+    "decode",
+    "decode_params",
+    "load",
+    "a",
+    "i2b",
+    "i642b",
+    "v2b",
+    "s2b",
+    "a2b",
+    "encode",
+    "encode_zeros",
+    "decode_zeros",
+    "save",
+]

opalib-0.2.0/README.md

@@ -1,2 +0,0 @@
-# opalib
-A library to do multiple things

opalib-0.2.0/src/opalib.egg-info/SOURCES.txt

@@ -1,12 +0,0 @@
-LICENSE
-README.md
-pyproject.toml
-src/__init__.py
-src/enum_extender.py
-src/web.py
-src/opalib.egg-info/PKG-INFO
-src/opalib.egg-info/SOURCES.txt
-src/opalib.egg-info/dependency_links.txt
-src/opalib.egg-info/top_level.txt
-src/tests/enum_test.py
-src/tests/web_test.py

opalib-0.2.0/src/opalib.egg-info/top_level.txt

@@ -1,4 +0,0 @@
-__init__
-enum_extender
-tests
-web

opalib-0.2.0/src/tests/enum_test.py

@@ -1,4 +0,0 @@
-from ..enum_extender import Enums
-
-Enums.new("HTTPMethod", ["GET", "POST", "PUT", "DELETE"])
-print(Enums.HTTPMethod.GET)