miniasyncio 0.0.1__tar.gz

miniasyncio-0.0.1/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2018 The Python Packaging Authority
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

miniasyncio-0.0.1/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: miniasyncio
+Version: 0.0.1
+Summary: A small async package
+Author: Benjamin
+Author-email: Benjamin <author@example.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Dist: build>=1.5.0
+Requires-Python: >=3.13
+Project-URL: Homepage, https://github.com/pypa/sampleproject
+Project-URL: Issues, https://github.com/pypa/sampleproject/issues
+Description-Content-Type: text/markdown
+

miniasyncio-0.0.1/pyproject.toml

@@ -0,0 +1,31 @@
+[project]
+name = "miniasyncio"
+version = "0.0.1"
+authors = [
+  { name="Benjamin", email="author@example.com" },
+]
+description = "A small async package"
+readme = "README.md"
+requires-python = ">=3.13"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Operating System :: OS Independent",
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+dependencies = [
+    "build>=1.5.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/pypa/sampleproject"
+Issues = "https://github.com/pypa/sampleproject/issues"
+
+[build-system]
+requires = ["uv_build >= 0.11.7, <0.12.0"]
+build-backend = "uv_build"
+
+[dependency-groups]
+dev = [
+    "pytest>=9.1.1",
+]

miniasyncio-0.0.1/src/miniasyncio/__init__.py

@@ -0,0 +1,47 @@
+from collections.abc import Awaitable, Callable, Generator
+from functools import wraps
+import time
+from typing import Any, override
+
+from .common import Coroutine, EventLoop, FutureState
+
+EL = EventLoop()
+
+def run(coro):
+    EL.create_task(coro)
+    EL.run_loop()
+
+@wraps(EventLoop.run_loop)
+def run_loop():
+    EL.run_loop()
+
+@wraps(EventLoop.create_task)
+def create_task(coroutine):
+    EL.create_task(coroutine)
+
+class gather(Awaitable[Any]):
+    def __init__(self, *coros):
+        self.gathered_tasks = EL.create_tasks(*coros)
+
+    @override
+    def __await__(self):
+        while not all([task.state == FutureState.FINISHED for task in self.gathered_tasks]):
+            yield
+        return [task.result for task in self.gathered_tasks]
+
+
+
+def __async__[Y, S, R](gen_func: Callable[..., Generator[Y, S, R]]) -> Callable[..., Coroutine[Y, S, R]]:
+    def coroutine_factory(*args: Any, **kwargs: Any) -> Coroutine[Y, S, R]:
+        return Coroutine(gen_func, *args, **kwargs)
+    return coroutine_factory
+
+class sleep:
+    def __init__(self, seconds: float):
+        self._start: float = time.monotonic()
+        self._expected_end: float = self._start + seconds
+
+    def __await__(self) -> Generator[None, None, float]:
+        while time.monotonic() < self._expected_end:
+            yield
+        return time.monotonic() - self._start

miniasyncio-0.0.1/src/miniasyncio/common.py

@@ -0,0 +1,88 @@
+from collections.abc import Generator
+from enum import auto, Enum
+from typing import Any, Callable, override
+from .linkedlist import CircularDoubleLL
+import inspect
+
+class FutureState(Enum):
+    PENDING = auto()
+    CANCELED = auto()
+    FINISHED = auto()
+
+class Future:
+    """ Resolves sometime in the future """
+    def __init__(self):
+        self._result: Any|None = None
+        self.state: FutureState = FutureState.PENDING
+
+    @property
+    def result(self):
+        return self._result
+
+    @result.setter
+    def result(self, result: Any):
+        self._result = result
+        self.state = FutureState.FINISHED
+
+class Task[Y,S,R](Future):
+    def __init__(self, coroutine: Coroutine[Y,S,R]):
+        super().__init__()
+        self.coroutine: Coroutine[Y,S,R] = coroutine
+
+    @override
+    def __str__(self):
+        return f"{self.state}{self.result}{self.coroutine}"
+
+class TaskQueue(CircularDoubleLL[Task[Any, Any, Any]]):
+    def __init__(self):
+        super().__init__()
+
+    def enqueue(self, task: Task[Any, Any, Any]):
+        self.add(task)
+
+    def dequeue(self):
+        it = iter(self)
+        return next(it)
+
+class Coroutine[Y, S, R]:
+    """ Awaitable object """
+    def __init__(self, gen_func: Callable[..., Generator[Y, S, R]], *args: Any, **kwargs: Any) -> None:
+        if not inspect.isgeneratorfunction(gen_func):
+            raise Exception("Expect a generator function.")
+
+        self.generator: Generator[Y, S, R] = gen_func(*args, **kwargs)
+
+    def __await__(self) -> Generator[Y, S, R]:
+        """ Should return a generator object """
+        return self.generator
+
+class EventLoop:
+    """Main orchestrator"""
+    unique_instance: EventLoop|None = None
+
+    def __init__(self):
+        if self.unique_instance is not None:
+            return self.unique_instance
+
+        self.taskQueue: TaskQueue = TaskQueue()
+
+    def run_loop(self):
+        """ Runs until loop is empty """
+        for task in self.taskQueue.iter_forever():
+
+            try:
+                task.coroutine.__await__().send(None)
+            except StopIteration as e:
+                task.state = FutureState.FINISHED
+                task.result = e.value
+                self.taskQueue.delete(task)
+
+    def create_task(self, coroutine: Coroutine[Any, Any, Any]):
+        """ Wraps a Coroutine in a task and adds it to the event loop. """
+        task = Task(coroutine)
+        self.taskQueue.add(task)
+        return task
+
+    def create_tasks(self, *coros: Coroutine[Any, Any, Any]) -> list[Task[Any, Any, Any]]:
+        tasks = [self.create_task(coro) for coro in coros]
+        return tasks

miniasyncio-0.0.1/src/miniasyncio/linkedlist.py

@@ -0,0 +1,103 @@
+from collections import defaultdict
+from collections.abc import Generator
+from typing import override
+
+
+class ListNode[NodeType]:
+    def __init__(self, val: NodeType):
+        self.val: NodeType = val
+        self.next: ListNode[NodeType] = self
+        self.prev: ListNode[NodeType] = self
+
+    @override
+    def __str__(self):
+        return f"[{self.val}]"
+
+
+class CircularDoubleLL[NodeType]:
+    def __init__(self):
+        self._head: ListNode[NodeType]|None = None
+        self._count: int = 0
+        self._node_table: dict[NodeType,list[ListNode[NodeType]]] = defaultdict(list)
+
+    def add(self, val: ListNode[NodeType]|NodeType):
+        if isinstance(val, ListNode):
+            newNode: ListNode[NodeType] = val
+        else:
+            newNode = ListNode(val)
+
+        if self._head is None:
+            self._head = newNode
+            newNode.next = newNode
+            newNode.prev = newNode
+        else:
+            newNode.next = self._head
+            newNode.prev = self._head.prev
+            newNode.prev.next = newNode
+            newNode.next.prev = newNode
+            self._head = newNode.next
+        self._count += 1
+        self._node_table[newNode.val].append(newNode)
+
+    def _delete(self, val: ListNode[NodeType]|NodeType):
+        node: ListNode[NodeType] 
+        if isinstance(val, ListNode):
+            node = val
+        else:
+            if val not in self._node_table or len(self._node_table[val]) == 0:
+                raise KeyError
+            node = self._node_table[val].pop()
+
+        node.prev.next = node.next
+        node.next.prev = node.prev
+        if self._head is not None and self._head == node:
+            self._head = self._head.next
+        self._count -= 1
+        if self._count == 0:
+            self._head = None
+        # no more refs to node? => garbage collected
+
+    def delete(self, val: list[ListNode[NodeType]|NodeType]|ListNode[NodeType]|NodeType):
+        if isinstance(val, list):
+            errors = []
+            for item in val:
+                try:
+                    self._delete(item)
+                except Exception as e:
+                    errors.append(e)
+
+            for e in errors:
+                raise e
+        else:
+            self._delete(val)
+
+    def __iter__(self):
+        if self._head is None:
+            return None
+
+        current_node: ListNode[NodeType] = self._head
+        yield current_node
+
+        while current_node.next != self._head:
+            current_node = current_node.next
+            yield current_node
+
+    def iter_forever(self) -> Generator[NodeType, None, None]:
+        if self._head is None:
+            return None
+
+        current_node: ListNode[NodeType] = self._head
+        while self._count > 0:
+            yield current_node.val
+            current_node = current_node.next
+
+    def __len__(self):
+        return self._count
+
+    @override
+    def __str__(self):
+        out = "LinkedList: "
+        for node in self:
+            out += f'- {str(node)} -'
+        return out
+