p4async 0.1.1__py3-none-any.whl

p4async/__init__.py

@@ -0,0 +1,160 @@
+import asyncio
+import threading
+from typing import Any, Callable, Set, Type, Awaitable, Optional, Union
+import P4
+
+
+class P4Async(P4.P4):
+    """
+    An async extension to P4.P4.
+    This class is a placeholder for future async methods.
+    """
+
+    # Methods that are simply wrapped to a thread for async execution.  These are methods
+    # that do not use `self.run` for execution.
+    simple_wrap_methods: Set[str] = {
+        "connect",
+        "disconnect",
+        "run_tickets",
+    }
+
+    # Methods that are wrapped by adding `with_async=True` to the underlying
+    # call to 'self.run', leaving other processing to happen in the current Task.
+    run_wrap_methods: Set[str] = {
+        "run_submit",
+        "run_shelve",
+        "delete_shelve",
+        "run_login",
+        "run_password",
+        "run_filelog",
+        "run_print",
+        "run_resolve",
+    }
+
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super().__init__(*args, **kwargs)
+        # A lock to synchronize access to the P4 adapter.
+        # The P4 adapter can only have one operation executing at a time.
+        self.lock = threading.Lock()
+
+    async def execute(
+        self, func: Callable[..., Any], *args: Any, **kwargs: Any
+    ) -> Any:
+        """
+        Default method to run a synchronous Perforce command.
+        Override this method for customized thread scheduling.
+        """
+
+        def helper():
+            # Ensure thread safety: the P4 adapter can only have one operation at a time.
+            with self.lock:
+                return func(*args, **kwargs)
+
+        loop = asyncio.get_running_loop()
+        return await loop.run_in_executor(None, helper)
+
+    def run(
+        self, *args: Any, with_async: bool = False, **kwargs: Any
+    ) -> Union[Any, Awaitable[Any]]:
+        """
+        Run a Perforce command.
+
+        If `with_async` is True, the command will return an awaitable that can be awaited
+        to execute the command asynchronously. If `with_async` is False, the command will
+        execute directly in the current thread.
+        """
+        if with_async:
+            # return an awaitable
+            return self.execute(self.sync_run, *args, **kwargs)
+        else:
+            # execute directly
+            return self.sync_run(*args, **kwargs)
+
+    def sync_run(self, *args: Any, **kwargs: Any) -> Any:
+        """
+        Run a Perforce command.
+        
+        A hook to call the original synchronous `run` method.  Child classes who want to wrap
+        extra functionality to the underlying `run` method can override this method.
+        It will be called on a worker thread as appropriate.
+        """
+        return super().run(*args, **kwargs)
+
+    async def arun(self, *args: Any, **kwargs: Any) -> Any:
+        """
+        Asynchronous  version of the `run` method.
+        """
+        return await self.execute(self.sync_run, *args, **kwargs)
+
+    def __getattr__(self, name: str) -> Any:
+        if name.startswith("arun_"):
+            cmd = name[len("arun_") :]
+            return lambda *args, **kargs: self.arun(cmd, *args, **kargs)
+        elif name.startswith("adelete_"):
+            cmd = name[len("adelete_") :]
+            return lambda *args, **kargs: self.arun(cmd, "-d", *args, **kargs)
+        elif name.startswith("afetch_"):
+            cmd = name[len("afetch_") :]
+            return lambda *args, **kargs: self.__afetch(cmd, *args, **kargs)
+        elif name.startswith("asave_"):
+            cmd = name[len("asave_") :]
+            return lambda *args, **kargs: self.__asave(cmd, *args, **kargs)
+        elif name.startswith("aiterate_"):
+            cmd = name[len("aiterate_") :]
+            return lambda *args, **kargs: self.__aiterate(cmd, *args, **kargs)
+        if name.startswith("a") and name[1:] in self.simple_wrap_methods:
+            method = name[1:]
+            return lambda *args, **kwargs: self.execute(
+                getattr(self, method), *args, **kwargs
+            )
+        elif name.startswith("a") and name[1:] in self.run_wrap_methods:
+            method = name[1:]
+            return lambda *args, **kwargs: getattr(self, method)(
+                *args, with_async=True, **kwargs
+            )
+        return super().__getattr__(name)
+
+    async def __afetch(self, cmd: str, *args: Any, **kargs: Any) -> Any:
+        """
+        Handle async versions of fetch commands.
+        """
+        result = await self.arun(cmd, "-o", *args, **kargs)
+        for r in result:
+            if isinstance(r, tuple) or isinstance(r, dict):
+                return r
+        return result[0]
+
+    async def __aiterate(self, cmd: str, *args: Any, **kargs: Any):
+        """
+        Handle async versions of iterate commands.
+        """
+        if cmd not in self.specfields:
+            raise Exception("Unknown spec list command: %s", cmd)
+
+        specs = await self.arun(cmd, *args, **kargs)
+        spec = self.specfields[cmd][0]
+        field = self.specfields[cmd][1]
+        for spec in specs:
+            yield await self.arun(spec, "-o", spec[field])[0]
+
+    async def __asave(self, cmd: str, *args: Any, **kargs: Any) -> Any:
+        self.input = args[0]
+        return await self.arun(cmd, "-i", args[1:], **kargs)
+
+    async def __aenter__(self) -> "P4Async":
+        """
+        Asynchronous context manager enter method.
+        """
+        return self
+
+    async def __aexit__(
+        self,
+        exc_type: Optional[Type[BaseException]],
+        exc_val: Optional[BaseException],
+        exc_tb: Optional[Any],
+    ) -> None:
+        """
+        Asynchronous context manager exit method.
+        """
+        if self.connected():
+            await self.adisconnect()

p4async-0.1.1.dist-info/METADATA

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: p4async
+Version: 0.1.1
+Summary: An async extension to p4python
+Project-URL: Homepage, https://github.com/kristjanvalur/p4async
+Project-URL: Issues, https://github.com/kristjanvalue/p4async/issues
+Author-email: Kristján Valur Jónsson <sweskman@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.11
+Requires-Dist: p4python>=2020.1.0
+Description-Content-Type: text/markdown
+
+
+# p4async
+
+An extension to the [p4python](https://pypi.org/project/p4python/) module, adding async functionality to Perforce.
+
+## Setup
+
+Use your favorite package manager to install the module into your project
+
+- `pip install p4async`
+- `uv add p4async`
+
+## Usage
+
+```python
+from p4async import P4Async
+p4a = P4Async()
+await p4a.aconnect()
+```
+
+All relevant Perforce commands have async counterparts prefixed with `a`.
+For example: `aconnect()`, `arun()`, `arun_clients()`, `afetch_change()`, etc.
+
+Commands are executed with a lock on a worker thread. The way this is done can be
+customized via subclassing.
+
+## Development
+
+- Use [uv](https://docs.astral.sh/uv/) for dependency management and virtual environments.
+
+## License
+
+MIT

p4async-0.1.1.dist-info/RECORD

@@ -0,0 +1,6 @@
+p4async/__init__.py,sha256=NrnLHuSf90EoL4paHqjqFZrZZEURAz6znAB_y-ZJDDI,5686
+p4async/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+p4async-0.1.1.dist-info/METADATA,sha256=74c6rninQ1vb20mG9rLb7sVPCLrYaALOWFHqISrZiYs,1260
+p4async-0.1.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+p4async-0.1.1.dist-info/licenses/LICENSE,sha256=CcIqC-yRYOROxhEDJw060FuEARhYnwacb-bvbIkz_Lk,1073
+p4async-0.1.1.dist-info/RECORD,,

p4async-0.1.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

p4async-0.1.1.dist-info/licenses/LICENSE

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