cinderx 2026.1.16.2__cp314-cp314-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

__static__/enum.py

@@ -0,0 +1,160 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+from __future__ import annotations
+
+import inspect
+from typing import Iterable, Mapping, Sequence, SupportsIndex, Type
+
+
+def eq_method(self: Enum, other: Enum) -> bool:
+    return self.value == other or (
+        getattr(other, "value", None) is not None and self.value == other.value
+    )
+
+
+def hash_method(self: Enum) -> int:
+    return hash(self.value)
+
+
+TYPE_NEW: object = type.__new__
+SENTINEL = object()
+
+
+class EnumMeta(type):
+    @staticmethod
+    def is_hashable(obj: object) -> bool:
+        try:
+            hash(obj)
+            return True
+        except TypeError:
+            return False
+
+    def __new__(
+        metacls,
+        classname: str,
+        parents: tuple[Type[object], ...],
+        dct: Mapping[str, object],
+    ) -> type[Enum]:
+        attributes = {}
+        members = {}
+
+        for name, value in dct.items():
+            if (
+                name.startswith("_")
+                or inspect.isroutine(value)
+                or inspect.isdatadescriptor(value)
+            ):
+                attributes[name] = value
+            else:
+                members[name] = value
+
+        attributes.update({"__members__": {}, "__reversed_map__": {}})
+        if len(members) != len(
+            {members[k] for k in members if EnumMeta.is_hashable(members[k])}
+        ):
+            attributes["__eq__"] = eq_method
+            attributes["__hash__"] = hash_method
+
+        klass = super().__new__(metacls, classname, parents, attributes)
+
+        for name, value in members.items():
+            option = klass(name=name, value=value)
+            # pyre-ignore[16]: __members__ is dynamically defined
+            klass.__members__[name] = option
+            if EnumMeta.is_hashable(option):
+                # pyre-ignore[16]: __reversed_map__ is dynamically defined
+                klass.__reversed_map__[option] = option
+            if EnumMeta.is_hashable(value):
+                klass.__reversed_map__[value] = option
+            setattr(klass, name, option)
+        return klass
+
+    def __len__(cls) -> int:
+        # pyre-ignore[16]: __members__ is dynamically defined
+        return len(cls.__members__)
+
+    def __getitem__(cls, attribute: str) -> Enum:
+        # pyre-ignore[16]: __members__ is dynamically defined
+        return cls.__members__[attribute]
+
+    def __iter__(cls) -> Iterable[Enum]:
+        # pyre-ignore[16]: __members__ is dynamically defined
+        return iter(cls.__members__.values())
+
+    def __call__(cls, *args: object, **kwargs: object) -> Enum:
+        if len(args) == 1:
+            attribute = args[0]
+            # pyre-ignore[6]: expected str, got object
+            return cls._get_by_value(attribute)
+
+        name = kwargs["name"]
+        value = kwargs["value"]
+        # pyre-ignore[20]: __new__ expects dct
+        # pyre-ignore[9]:declared to have type Enum but is used as Type[Enum]
+        instance: Enum = cls.__new__(cls, value)
+        instance.name = name
+        instance.value = value
+        return instance
+
+    def _get_by_value(cls, value: str) -> Enum:
+        # pyre-ignore[16]: __reversed_map__ is dynamically defined
+        res = cls.__reversed_map__.get(value, SENTINEL)
+        if res is not SENTINEL:
+            return res
+
+        raise ValueError(
+            f"Enum type {cls.__name__} has no attribute with value {value!r}"
+        )
+
+
+class Enum(metaclass=EnumMeta):
+    def __init__(self, value: object) -> None:
+        self.value = value
+        self.name: object = None
+
+    def __dir__(self) -> Sequence[str]:
+        return ["name", "value"]
+
+    def __str__(self) -> str:
+        return f"{type(self).__name__}.{self.name}"
+
+    def __repr__(self) -> str:
+        return f"<{type(self).__name__}.{self.name}: {self.value}>"
+
+    def __reduce_ex__(self, proto: SupportsIndex) -> tuple[type[object], tuple[object]]:
+        return self.__class__, (self.value,)
+
+
+class IntEnum(Enum, int):
+    pass
+
+
+class StringEnumMeta(EnumMeta):
+    """Like the regular EnumMeta, but parses string/binary inputs to __call__
+    as text (to match text literals used in StringEnum)."""
+
+    def _get_by_value(cls, value: str | bytes) -> StringEnum:
+        # pyre-ignore[7]: Expected StringEnum, got Enum
+        return super()._get_by_value(
+            value.decode("utf-8") if isinstance(value, bytes) else value
+        )
+
+
+class StringEnum(Enum, str, metaclass=StringEnumMeta):
+    def __str__(self) -> str:
+        return f"{self.value}"
+
+
+def unique(enumeration: type[Enum]) -> type[Enum]:
+    """
+    Class decorator for enumerations ensuring unique member values
+    """
+    duplicates = []
+    # pyre-ignore[16]: __members__ is dynamically defined
+    for name, member in enumeration.__members__.items():
+        if name != member.name:
+            duplicates.append((name, member.name))
+    if duplicates:
+        raise ValueError(f"duplicate values found in {enumeration!r}")
+    return enumeration

__static__/native_utils.py

@@ -0,0 +1,77 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+from __future__ import annotations
+
+import ctypes
+
+from cinderx.static import (
+    resolve_primitive_descr,
+    TYPED_BOOL,
+    TYPED_CHAR,
+    TYPED_INT16,
+    TYPED_INT32,
+    TYPED_INT64,
+    TYPED_INT8,
+    TYPED_UINT16,
+    TYPED_UINT32,
+    TYPED_UINT64,
+    TYPED_UINT8,
+)
+
+_static_to_ctype: dict[int, object] = {
+    TYPED_BOOL: ctypes.c_bool,
+    TYPED_CHAR: ctypes.c_char,
+    # TASK(T130985738): Add support for doubles
+    # TYPED_DOUBLE: ctypes.c_double,
+    TYPED_INT8: ctypes.c_int8,
+    TYPED_INT16: ctypes.c_int16,
+    TYPED_INT32: ctypes.c_int32,
+    TYPED_INT64: ctypes.c_int64,
+    TYPED_UINT8: ctypes.c_uint8,
+    TYPED_UINT16: ctypes.c_uint16,
+    TYPED_UINT32: ctypes.c_uint32,
+    TYPED_UINT64: ctypes.c_uint64,
+}
+
+
+def _create_args(
+    signature: tuple[tuple[str, ...], ...], args: tuple[object]
+) -> list[object]:
+    arg_descrs = signature[:-1]
+
+    n = len(arg_descrs)
+    if n != len(args):
+        raise RuntimeError(f"invoke_native: {n} args required, got {len(args)}")
+
+    call_args = []
+    for i in range(n):
+        descr = arg_descrs[i]
+        arg = args[i]
+        primitive_type = resolve_primitive_descr(descr)
+        try:
+            ctypes_type = _static_to_ctype[primitive_type]
+        except KeyError as e:
+            raise RuntimeError(f"Unsupported primitive type: {descr}") from e
+        else:
+            # pyre-ignore[29]: object is not callable
+            call_args.append(ctypes_type(arg))
+    return call_args
+
+
+def invoke_native(
+    libname: str,
+    symbol: str,
+    signature: tuple[tuple[str, ...], ...],
+    args: tuple[object],
+) -> int:
+    # This is basically just a `dlopen()` under the hood
+    lib = ctypes.CDLL(libname)
+
+    # Python wrapper over `dlsym`
+    fn = getattr(lib, symbol)
+
+    call_args = _create_args(signature, args)
+
+    res = fn(*call_args)
+    return res

__static__/type_code.py

@@ -0,0 +1,48 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+# pyre-strict
+
+TYPED_INT8 = 0
+TYPED_INT16 = 0
+TYPED_INT32 = 0
+TYPED_INT64 = 0
+TYPED_UINT8 = 0
+TYPED_UINT16 = 0
+TYPED_UINT32 = 0
+TYPED_UINT64 = 0
+TYPED_INT_64BIT = 0
+TYPED_DOUBLE = 0
+TYPED_SINGLE = 0
+TYPED_BOOL = 0
+TYPED_CHAR = 0
+TYPED_OBJECT = 0
+
+try:
+    from cinderx.static import (  # noqa: F401
+        set_type_code,
+        TYPED_BOOL,
+        TYPED_CHAR,
+        TYPED_DOUBLE,
+        TYPED_INT16,
+        TYPED_INT32,
+        TYPED_INT64,
+        TYPED_INT8,
+        TYPED_INT_64BIT,
+        TYPED_OBJECT,
+        TYPED_SINGLE,
+        TYPED_UINT16,
+        TYPED_UINT32,
+        TYPED_UINT64,
+        TYPED_UINT8,
+    )
+except ImportError:
+
+    def set_type_code(func: object, code: object) -> None:
+        pass
+
+
+def type_code(code: int) -> object:
+    def inner(func: object) -> object:
+        set_type_code(func, code)
+        return func
+
+    return inner

__strict__/__init__.py

@@ -0,0 +1,39 @@
+# Copyright (c) Meta Platforms, Inc. and affiliates.
+
+# pyre-strict
+
+try:
+    from cinderx.compiler.strict.runtime import (
+        _mark_cached_property,
+        extra_slot,
+        freeze_type,
+        loose_slots,
+        mutable,
+        set_freeze_enabled,
+        strict_slots,
+    )
+except ImportError:
+
+    def _mark_cached_property(o: object) -> object:
+        return o
+
+    def extra_slot(cls: object, o: object) -> object:
+        return cls
+
+    def freeze_type(o: object) -> object:
+        return o
+
+    def loose_slots(o: object) -> object:
+        return o
+
+    def mutable(o: object) -> object:
+        return o
+
+    def set_freeze_enabled(o: object) -> object:
+        return o
+
+    def strict_slots(o: object) -> object:
+        return o
+
+
+allow_side_effects = object()