xasyncio 0.2.5__tar.gz

xasyncio-0.2.5/.github/workflows/release.yml

@@ -0,0 +1,77 @@
+name: Publish Python 🐍 distribution 📦 to PyPI and TestPyPI
+
+on: push
+
+jobs:
+  test:
+    name: Run tests 🧪
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: Install pytest
+        run: >-
+          python3 -m
+          pip install
+          pytest
+          --user
+      - name: Install a dev package
+        run: pip install -e .
+      - name: Run tests
+        run: pytest
+
+  build:
+    name: Build distribution 📦
+    runs-on: ubuntu-latest
+    needs: test
+
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          persist-credentials: false
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.x"
+      - name: Install pypa/build
+        run: >-
+          python3 -m
+          pip install
+          build
+          --user
+      - name: Build a binary wheel and a source tarball
+        run: python3 -m build
+      - name: Store the distribution packages
+        uses: actions/upload-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+
+  publish-to-pypi:
+    name: >-
+      Publish Python 🐍 distribution 📦 to PyPI
+    if: startsWith(github.ref, 'refs/tags/')  # only publish to PyPI on tag pushes
+    needs:
+      - build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/p/xasyncio
+    permissions:
+      id-token: write  # IMPORTANT: mandatory for trusted publishing
+
+    steps:
+      - name: Download all the dists
+        uses: actions/download-artifact@v4
+        with:
+          name: python-package-distributions
+          path: dist/
+      - name: Publish distribution 📦 to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+

xasyncio-0.2.5/.gitignore

@@ -0,0 +1,160 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/

xasyncio-0.2.5/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Yisu Peng
+
+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.

xasyncio-0.2.5/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: xasyncio
+Version: 0.2.5
+Summary: A package to simiplify multithreaded asyncio event loops
+Project-URL: Homepage, https://github.com/shawn-peng/xasyncio
+Project-URL: Bug Tracker, https://github.com/shawn-peng/xasyncio/issues
+Author-email: Yisu Peng <yisupeng@gmail.com>
+License-File: LICENSE
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.7

xasyncio-0.2.5/pyproject.toml

@@ -0,0 +1,36 @@
+[build-system]
+requires = ["hatchling", "hatch-vcs"]
+build-backend = "hatchling.build"
+
+[tool.hatch.version]
+source = "vcs"
+
+[tool.hatch.build]
+exclude = [
+    "/tests",
+]
+
+[project]
+dynamic = ["version"]
+name = "xasyncio"
+authors = [
+    { name="Yisu Peng", email="yisupeng@gmail.com" },
+]
+description = "A package to simiplify multithreaded asyncio event loops"
+#readme = "README.md"
+requires-python = ">=3.7"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+dependencies = [
+]
+
+[project.urls]
+"Homepage" = "https://github.com/shawn-peng/xasyncio"
+"Bug Tracker" = "https://github.com/shawn-peng/xasyncio/issues"
+
+#[tool.hatch.build.targets.wheel]
+#packages = ["src/asyncio-utils"]
+

xasyncio-0.2.5/src/xasyncio/__init__.py

@@ -0,0 +1,264 @@
+import asyncio
+import dataclasses
+import logging
+import threading
+import traceback
+
+from typing import *
+
+
+class ThreadingError(Exception):
+    pass
+
+
+def handle_result(future):
+    try:
+        # This will trigger the exception if the coroutine failed
+        future.result()
+    except Exception:
+        logging.exception("Exception caught in background thread safe task:")
+
+
+@dataclasses.dataclass
+class AsyncThreadBase:
+    # def call_async(self, func, *args):
+    #     raise NotImplementedError
+    #
+    # def call_sync(self, func, *args):
+    #     raise NotImplementedError
+    #
+    # def sync_coroutine(self, coro, timeout=None):
+    #     raise NotImplementedError
+    #
+    # def ensure_coroutine(self, coro):
+    #     raise NotImplementedError
+    #
+    # async def await_coroutine(self, coro):
+    #     raise NotImplementedError
+    #
+    # def stop(self):
+    #     raise NotImplementedError
+    name: str = ''
+    loop: asyncio.AbstractEventLoop | None = None
+    events: dict = dataclasses.field(default_factory=dict)
+    events_out_thread: dict = dataclasses.field(default_factory=dict)
+
+    def _stop_self(self):
+        """this function must be called with this thread"""
+        if self.stopped:
+            return
+        self.loop.stop()
+        self.stopped = True
+
+    async def stop(self):
+        """thread safe stop function"""
+        # Called in other thread
+
+        # thread = threading.current_thread()
+        # if thread == self.thread:
+        #     print('calling from the loop thread')
+        # else:
+        #     print('calling from another loop')
+        print(f'Threaded loop {self.name} stopping')
+        await self.call_sync(self._stop_self)
+
+    def _mark_running(self, running=True):
+        # if running:
+        #     print('mark running')
+        # else:
+        #     print('mark stopped')
+        self.stopped = not running
+
+    def create_out_thread_event(self, name):
+        self.events_out_thread[name] = threading.Event()
+
+    def wait_out_thread_event(self, name):
+        self.events_out_thread[name].wait()
+
+    def notify_out_thread_event(self, name):
+        # print('notify event', name)
+        self.events_out_thread[name].set()
+
+    def create_event(self, name):
+        self.events[name] = threading.Event()
+
+    def notify(self, event_name):
+        self.events[event_name].set()
+
+    def wait(self, event_name):
+        self.events[event_name].wait()
+
+    # def call_blocking(self, func, *args):
+    # def call_sync(self, func, *args):
+    #     # other thread will be blocked and could result in deadlocks
+    #     pass
+
+    async def call_sync(self, func, *args):
+        # Called in other thread
+        # blocking_call_w_loop(self.loop, func, *args)
+        finish_event = asyncio.Event()
+        caller_loop = asyncio.get_event_loop()
+
+        def _set_finish_event():
+            caller_loop.call_soon_threadsafe(lambda: finish_event.set())
+
+        def _helper():
+            # in self thread
+            try:
+                func(*args)
+                _set_finish_event()
+            except Exception as e:
+                nonlocal exception
+                traceback.print_exc()
+                exception = e
+                _set_finish_event()
+
+        exception = None
+
+        def _ex_handler(e):
+            nonlocal exception
+            exception = e
+            raise exception
+
+        self.loop.set_exception_handler(_ex_handler)
+
+        self.loop.call_soon_threadsafe(_helper)
+        await finish_event.wait()
+        if exception:
+            raise exception
+
+    def call_async(self, func, *args):
+        self.loop.call_soon_threadsafe(func, *args)
+
+    # def _sync_coro(self, coro):
+    #     if threading.current_thread() != self.thread:
+    #         raise ThreadingError('Invalid thread: this function must be called in the loop thread')
+
+    def sync_coroutine(self, coro, timeout=None):
+        """may from another thread"""
+        return asyncio.run_coroutine_threadsafe(coro, self.loop).result(timeout)
+
+    def ensure_coroutine(self, coro):
+        future = asyncio.run_coroutine_threadsafe(coro, self.loop)
+        future.add_done_callback(handle_result)
+        return future
+
+    async def run_coroutine(self, coro):
+        return await asyncio.wrap_future(asyncio.run_coroutine_threadsafe(coro, self.loop))
+
+    def blocking_call_w_loop(self, loop, func, *args):
+        pass
+
+    # def sync_coroutine_deadlock(self, coro, timeout=None):
+    #     finish_event = threading.Event()
+    #
+    #     async def _helper():
+    #         try:
+    #             await coro
+    #         except Exception as e:
+    #             traceback.print_exc()
+    #
+    #         finish_event.set()
+    #
+    #     self.loop.call_soon_threadsafe(self.loop.create_task, _helper())
+    #     finish_event.wait()
+
+
+class AsyncThread(threading.Thread, AsyncThreadBase):
+    """Class for a new thread"""
+
+    def __init__(self, name):
+        # super(AsyncThread, self).__init__()
+        threading.Thread.__init__(self)
+        AsyncThreadBase.__init__(self)
+        self.name = name
+        self.events = {}
+        self.events_out_thread = {}
+        self.loop: asyncio.BaseEventLoop | None = None
+        self.stopped = True
+        self.create_out_thread_event('loop_started')
+        self.start()
+        self.wait_out_thread_event('loop_started')
+        logging.debug('AsyncThread init finished and running')
+
+    def __repr__(self):
+        return f'<AsyncThread {self.name}>'
+
+    async def stop(self):
+        # Called in other thread
+        await super().stop()
+        res = self.join(1)
+        print(res)
+
+    def run(self):
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+
+        # Need to call this in the loop, mainly because need to make sure the loop is running
+        # debugging version
+        # self.loop.call_soon_threadsafe(
+        #     lambda: (
+        #         print('notifying loop started'),
+        #         self._mark_running(),
+        #         print(self.stopped),
+        #         self.notify_out_thread_event('loop_started')))
+
+        # self.loop.call_soon_threadsafe(
+        # self.loop.call_soon(
+        #     lambda: (
+        #         self._mark_running(), self.notify_out_thread_event('loop_started')
+        #     )
+        # )
+
+        async def _notify_running():
+            logging.debug('notify running')
+            self._mark_running()
+            self.notify_out_thread_event('loop_started')
+
+        asyncio.ensure_future(_notify_running())
+
+        logging.info('running loop')
+        self.loop.run_forever()
+        print(f'Loop ({self.name}) finished')
+
+    def __hash__(self):
+        return 0
+
+    def __eq__(self, other):
+        return self is other
+
+
+class AsyncedThread(AsyncThreadBase):
+    """Class for converting an existing thread"""
+
+    def __init__(self, name, thread):
+        self.thread = thread
+        self.loop = asyncio.get_event_loop()
+        assert self.loop.is_running()  # we require the loop already running
+        self.name = name
+        self.events = {}
+        self.events_out_thread = {}
+        self.stopped = True
+
+
+class ThreadSafeEvent(asyncio.Event):
+    def set(self):
+        self._loop.call_soon_threadsafe(super().set)
+
+    def clear(self):
+        self._loop.call_soon_threadsafe(super().clear)
+
+
+class ThreadSafeSemaphore(asyncio.Semaphore):
+    pass
+
+
+async def cross_thread_call(loop: asyncio.BaseEventLoop, func, *args):
+    done = ThreadSafeEvent()
+
+    def _helper():
+        func(*args)
+        done.set()
+
+    loop.call_soon_threadsafe(_helper)
+    await done.wait()