Add pure python fallback implementation

Author: ZipFile

setup.py

@@ -1,14 +1,20 @@
 #!/usr/bin/env python
+import os
+import sys
 import sysconfig
 from typing import Any, Dict, List, Optional, Tuple
 
 from setuptools import Extension, setup
 
+build: bool = os.environ.get("SONYFLAKE_TURBO_BUILD", "1").lower() in ("1", "true")
 options: Dict[str, Any] = {}
 define_macros: List[Tuple[str, Optional[str]]] = []
 py_limited_api: bool = not sysconfig.get_config_var("Py_GIL_DISABLED")
 cflags: List[str] = []
 
+if sys.implementation.name != "cpython":
+    build = False
+
 if sysconfig.get_platform().startswith("win"):
     cflags.append("/utf-8")
     cflags.append("/std:c17")
@@ -24,9 +30,10 @@
     options["bdist_wheel"] = {"py_limited_api": "cp310"}
     define_macros.append(("Py_LIMITED_API", "0x030a00f0"))
 
-setup(
-    options=options,
-    ext_modules=[
+
+setup_kwargs = {
+    "options": options,
+    "ext_modules": [
         Extension(
             "sonyflake_turbo._sonyflake",
             sources=[
@@ -39,4 +46,9 @@
             extra_compile_args=cflags,
         ),
     ],
-)
+}
+
+if not build:
+    setup_kwargs = {}
+
+setup(**setup_kwargs)

src/sonyflake_turbo/__init__.py

@@ -1,27 +1,27 @@
-from typing import (
-    Any,
-    AsyncIterable,
-    AsyncIterator,
-    Awaitable,
-    Callable,
-    ClassVar,
-    Generator,
-    TypeAlias,
-)
-
-from ._sonyflake import (
-    SONYFLAKE_EPOCH,
-    SONYFLAKE_MACHINE_ID_BITS,
-    SONYFLAKE_MACHINE_ID_MAX,
-    SONYFLAKE_MACHINE_ID_OFFSET,
-    SONYFLAKE_SEQUENCE_BITS,
-    SONYFLAKE_SEQUENCE_MAX,
-    SONYFLAKE_TIME_OFFSET,
-    MachineIDLCG,
-    SonyFlake,
-)
-
-AsyncSleep: TypeAlias = Callable[[float], Awaitable[None]]
+try:
+    from ._sonyflake import (
+        SONYFLAKE_EPOCH,
+        SONYFLAKE_MACHINE_ID_BITS,
+        SONYFLAKE_MACHINE_ID_MAX,
+        SONYFLAKE_MACHINE_ID_OFFSET,
+        SONYFLAKE_SEQUENCE_BITS,
+        SONYFLAKE_SEQUENCE_MAX,
+        SONYFLAKE_TIME_OFFSET,
+        MachineIDLCG,
+        SonyFlake,
+    )
+except ImportError:  # pragma: no cover
+    from .pure import (
+        SONYFLAKE_EPOCH,
+        SONYFLAKE_MACHINE_ID_BITS,
+        SONYFLAKE_MACHINE_ID_MAX,
+        SONYFLAKE_MACHINE_ID_OFFSET,
+        SONYFLAKE_SEQUENCE_BITS,
+        SONYFLAKE_SEQUENCE_MAX,
+        SONYFLAKE_TIME_OFFSET,
+        MachineIDLCG,
+        SonyFlake,
+    )
 
 __all__ = [
     "SONYFLAKE_EPOCH",
@@ -37,7 +37,7 @@
 ]
 
 
-class AsyncSonyFlake(Awaitable[int], AsyncIterable[int]):
+class AsyncSonyFlake:
     """Async wrapper for :class:`SonyFlake`.
 
     Usage:
@@ -57,10 +57,9 @@ class AsyncSonyFlake(Awaitable[int], AsyncIterable[int]):
                 break
     """
 
-    __slots__: ClassVar[tuple[str, ...]] = ("sf", "sleep")
-    sleep: AsyncSleep
+    __slots__ = ("sf", "sleep")
 
-    def __init__(self, sf: SonyFlake, sleep: AsyncSleep | None = None) -> None:
+    def __init__(self, sf: SonyFlake, sleep=None):
         """Initialize AsyncSonyFlake ID generator.
 
         Args:
@@ -76,7 +75,7 @@ def __init__(self, sf: SonyFlake, sleep: AsyncSleep | None = None) -> None:
         self.sf = sf
         self.sleep = sleep
 
-    async def __call__(self, n: int) -> list[int]:
+    async def __call__(self, n):
         """Generate multiple SonyFlake IDs at once.
 
         Roughly equivalent to ``[await asf for _ in range(n)]``, but more
@@ -96,7 +95,7 @@ async def __call__(self, n: int) -> list[int]:
 
         return ids
 
-    def __await__(self) -> Generator[Any, Any, int]:
+    def __await__(self):
         """Produce a SonyFlake ID."""
 
         id_, to_sleep = self.sf._raw(None)
@@ -105,12 +104,12 @@ def __await__(self) -> Generator[Any, Any, int]:
 
         return id_
 
-    def __aiter__(self) -> AsyncIterator[int]:
+    def __aiter__(self):
         """Return an infinite SonyFlake ID async iterator."""
 
         return self._gen().__aiter__()
 
-    async def _gen(self) -> AsyncIterator[int]:
+    async def _gen(self):
         """Infinite SonyFlake ID async generator."""
 
         while True:

src/sonyflake_turbo/__init__.pyi

@@ -0,0 +1,64 @@
+from collections.abc import AsyncIterable, AsyncIterator, Awaitable
+from typing import (
+    Any,
+    Callable,
+    ClassVar,
+    Generator,
+    TypeAlias,
+)
+
+from ._sonyflake import (
+    SONYFLAKE_EPOCH,
+    SONYFLAKE_MACHINE_ID_BITS,
+    SONYFLAKE_MACHINE_ID_MAX,
+    SONYFLAKE_MACHINE_ID_OFFSET,
+    SONYFLAKE_SEQUENCE_BITS,
+    SONYFLAKE_SEQUENCE_MAX,
+    SONYFLAKE_TIME_OFFSET,
+    MachineIDLCG,
+    SonyFlake,
+)
+
+__all__ = [
+    "SONYFLAKE_EPOCH",
+    "SONYFLAKE_MACHINE_ID_BITS",
+    "SONYFLAKE_MACHINE_ID_MAX",
+    "SONYFLAKE_MACHINE_ID_OFFSET",
+    "SONYFLAKE_SEQUENCE_BITS",
+    "SONYFLAKE_SEQUENCE_MAX",
+    "SONYFLAKE_TIME_OFFSET",
+    "AsyncSonyFlake",
+    "MachineIDLCG",
+    "SonyFlake",
+]
+
+AsyncSleep: TypeAlias = Callable[[float], Awaitable[None]]
+
+class AsyncSonyFlake(Awaitable[int], AsyncIterable[int]):
+    """Async wrapper for :class:`SonyFlake`.
+
+    Usage:
+
+        .. code-block:: python
+
+            import asyncio
+
+            sf = SonyFlake(0x1337, 0xCAFE, start_time=1749081600)
+            asf = AsyncSonyFlake(sf, asyncio.sleep)
+
+            print(await asf)
+            print(await asf(5))
+
+            async for id_ in asf:
+                print(id_)
+                break
+    """
+
+    __slots__: ClassVar[tuple[str, ...]]
+    sleep: AsyncSleep
+
+    def __init__(self, sf: SonyFlake, sleep: AsyncSleep | None = None) -> None: ...
+    async def __call__(self, n: int) -> list[int]: ...
+    def __await__(self) -> Generator[Any, Any, int]: ...
+    def __aiter__(self) -> AsyncIterator[int]: ...
+    async def _gen(self) -> AsyncIterator[int]: ...