xoscar 0.8.0__cp313-cp313-win_amd64.whl

xoscar/virtualenv/uv.py

@@ -0,0 +1,321 @@
+# Copyright 2022-2025 XProbe Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+import shutil
+import subprocess
+import sys
+import sysconfig
+import tempfile
+from importlib.metadata import distributions
+from pathlib import Path
+from typing import Optional
+
+from packaging.requirements import Requirement
+from packaging.version import Version
+
+from .core import VirtualEnvManager
+from .utils import is_vcs_url, run_subprocess_with_logger
+
+UV_PATH = os.getenv("XOSCAR_UV_PATH")
+SKIP_INSTALLED = bool(int(os.getenv("XOSCAR_VIRTUAL_ENV_SKIP_INSTALLED", "0")))
+logger = logging.getLogger(__name__)
+
+
+def _is_in_pyinstaller():
+    return hasattr(sys, "_MEIPASS")
+
+
+class UVVirtualEnvManager(VirtualEnvManager):
+    def __init__(self, env_path: Path):
+        super().__init__(env_path)
+        self._install_process: Optional[subprocess.Popen] = None
+
+    @classmethod
+    def is_available(cls):
+        if UV_PATH is not None:
+            # user specified uv, just treat it as existed
+            return True
+        return shutil.which("uv") is not None
+
+    @staticmethod
+    def _get_uv_path() -> str:
+        if (uv_path := UV_PATH) is None:
+            try:
+                from uv import find_uv_bin
+
+                uv_path = find_uv_bin()
+            except (ImportError, FileNotFoundError):
+                logger.warning("Fail to find uv bin, use system one")
+                uv_path = "uv"
+        return uv_path
+
+    def exists_env(self) -> bool:
+        """Check if virtual environment already exists."""
+        return self.env_path.exists() and (self.env_path / "pyvenv.cfg").exists()
+
+    def create_env(
+        self, python_path: Path | None = None, exists: str = "ignore"
+    ) -> None:
+        """
+        Create virtual environment.
+
+        Args:
+            python_path: Path to Python interpreter to use
+            exists: How to handle existing environment:
+                - "ignore": Skip creation if environment already exists (default)
+                - "error": Raise error if environment exists
+                - "clear": Remove existing environment and create new one
+        """
+        if self.exists_env():
+            if exists == "error":
+                raise FileExistsError(
+                    f"Virtual environment already exists at {self.env_path}"
+                )
+            elif exists == "ignore":
+                logger.info(
+                    f"Virtual environment already exists at {self.env_path}, skipping creation"
+                )
+                return
+            elif exists == "clear":
+                logger.info(f"Removing existing virtual environment at {self.env_path}")
+                self.remove_env()
+            else:
+                raise ValueError(
+                    f"Invalid exists option: {exists}. Must be one of: error, clear, ignore"
+                )
+
+        uv_path = self._get_uv_path()
+        cmd = [uv_path, "venv", str(self.env_path), "--system-site-packages"]
+
+        if python_path:
+            cmd += ["--python", str(python_path)]
+        elif _is_in_pyinstaller():
+            # in pyinstaller, uv would find the system python
+            # in this case we'd better specify the same python version
+            python_version = f"{sys.version_info.major}.{sys.version_info.minor}.{sys.version_info.micro}"
+            cmd += ["--python", python_version]
+
+        logger.info("Creating virtualenv via command: %s", cmd)
+        subprocess.run(cmd, check=True)
+
+    def _resolve_install_plan(
+        self, specs: list[str], pinned: dict[str, str]
+    ) -> list[str]:
+        """
+        Run uv --dry-run with pinned constraints and return
+        a list like ['package==version', ...].
+        """
+        with tempfile.NamedTemporaryFile("w+", delete=True) as f:
+            for name, ver in pinned.items():
+                f.write(f"{name}=={ver}\n")
+            f.flush()  # make sure content is on disk
+
+            cmd = [
+                self._get_uv_path(),
+                "pip",
+                "install",
+                "-p",
+                str(self.env_path),
+                "--dry-run",
+                "--constraint",
+                f.name,
+                *specs,
+            ]
+            result = subprocess.run(cmd, check=True, text=True, capture_output=True)
+
+        # the temp file is automatically deleted here
+        deps = [
+            f"{m.group(1)}=={m.group(2)}"
+            for line in result.stderr.splitlines()
+            if (m := re.match(r"^\+ (\S+)==(\S+)$", line.strip()))
+        ]
+        return deps
+
+    @staticmethod
+    def _split_specs(
+        specs: list[str], installed: dict[str, str]
+    ) -> tuple[list[str], list[str], dict[str, str]]:
+        """
+        Split the given requirement specs into:
+        - keep： specs that need to be kept, e.g. git+github://xxx
+        - to_resolve: specs that need to be passed to the resolver (unsatisfied ones)
+        - pinned: already satisfied specs, used for constraint to lock their versions
+        """
+        keep: list[str] = []
+        to_resolve: list[str] = []
+        pinned: dict[str, str] = {}
+
+        for spec_str in specs:
+            # skip git+xxx
+            if is_vcs_url(spec_str):
+                keep.append(spec_str)
+                continue
+
+            req = Requirement(spec_str)
+            name = req.name.lower()
+            cur_ver = installed.get(name)
+
+            if cur_ver is None:
+                # Package not installed, needs resolution
+                to_resolve.append(spec_str)
+                continue
+
+            if not req.specifier:
+                # No version constraint, already satisfied
+                pinned[name] = cur_ver
+                continue
+
+            try:
+                if Version(cur_ver) in req.specifier:
+                    # Version satisfies the specifier, pin it
+                    pinned[name] = cur_ver
+                else:
+                    # Version does not satisfy, needs resolution
+                    to_resolve.append(spec_str)
+            except Exception:
+                # Parsing error, be conservative and resolve it
+                to_resolve.append(spec_str)
+
+        return keep, to_resolve, pinned
+
+    def _filter_packages_not_installed(self, packages: list[str]) -> list[str]:
+        """
+        Filter out packages that are already installed with the same version.
+        """
+
+        # all the installed packages in system site packages
+        installed = {
+            dist.metadata["Name"].lower(): dist.version
+            for dist in distributions()
+            if dist.metadata and "Name" in dist.metadata
+        }
+
+        # exclude those packages that satisfied in system site packages
+        keep, to_resolve, pinned = self._split_specs(packages, installed)
+        if not keep and not to_resolve:
+            logger.debug("All requirement specifiers satisfied by system packages.")
+            return []
+
+        if to_resolve:
+            resolved = self._resolve_install_plan(to_resolve, pinned)
+            logger.debug(f"Resolved install list: {resolved}")
+            if not keep and not resolved:
+                # no packages to install
+                return []
+        else:
+            resolved = []
+
+        final = keep.copy()
+        for item in resolved:
+            name, version = item.split("==")
+            key = name.lower()
+            if key not in installed or installed[key] != version:
+                final.append(item)
+        logger.debug(f"Filtered install list: {final}")
+        return final
+
+    def install_packages(self, packages: list[str], **kwargs):
+        """
+        Install packages into the virtual environment using uv.
+        Supports pip-compatible kwargs: index_url, extra_index_url, find_links.
+        """
+        if not packages:
+            return
+
+        packages = self.process_packages(packages)
+        if not packages:
+            return
+
+        log = kwargs.pop("log", False)
+        skip_installed = kwargs.pop("skip_installed", SKIP_INSTALLED)
+        uv_path = self._get_uv_path()
+
+        if skip_installed:
+            packages = self._filter_packages_not_installed(packages)
+            if not packages:
+                logger.info("All required packages are already installed.")
+                return
+
+            cmd = [
+                uv_path,
+                "pip",
+                "install",
+                "-p",
+                str(self.env_path),
+                "--color=always",
+                "--no-deps",
+            ] + packages
+        else:
+            cmd = [
+                uv_path,
+                "pip",
+                "install",
+                "-p",
+                str(self.env_path),
+                "--color=always",
+            ] + packages
+
+        if "index_url" in kwargs and kwargs["index_url"]:
+            cmd += ["-i", kwargs["index_url"]]
+        param_and_option = [
+            ("extra_index_url", "--extra-index-url"),
+            ("find_links", "-f"),
+            ("trusted_host", "--trusted-host"),
+        ]
+        for param, option in param_and_option:
+            if param in kwargs and kwargs[param]:
+                val = kwargs[param]
+                cmd += (
+                    [option, val]
+                    if isinstance(val, str)
+                    else [opt for v in val for opt in (option, v)]
+                )
+
+        if kwargs.get("no_build_isolation", False):
+            cmd += ["--no-build-isolation"]
+
+        logger.info("Installing packages via command: %s", cmd)
+        if not log:
+            self._install_process = process = subprocess.Popen(cmd)
+            returncode = process.wait()
+        else:
+            with run_subprocess_with_logger(cmd) as process:
+                self._install_process = process
+            returncode = process.returncode
+
+        self._install_process = None
+        if returncode != 0:
+            raise subprocess.CalledProcessError(returncode, cmd)
+
+    def cancel_install(self):
+        if self._install_process and self._install_process.poll() is None:
+            self._install_process.terminate()
+            self._install_process.wait()
+
+    def get_python_path(self) -> str | None:
+        if self.env_path.exists():
+            return str(self.env_path.joinpath("bin/python"))
+        return None
+
+    def get_lib_path(self) -> str:
+        return sysconfig.get_path("purelib", vars={"base": str(self.env_path)})
+
+    def remove_env(self):
+        if self.env_path.exists():
+            shutil.rmtree(self.env_path, ignore_errors=True)

xoscar-0.8.0.dist-info/METADATA

@@ -0,0 +1,229 @@
+Metadata-Version: 2.4
+Name: xoscar
+Version: 0.8.0
+Summary: Python actor framework for heterogeneous computing.
+Home-page: http://github.com/xorbitsai/xoscar
+Author: Qin Xuye
+Author-email: qinxuye@xprobe.io
+Maintainer: Qin Xuye
+Maintainer-email: qinxuye@xprobe.io
+License: Apache License 2.0
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Libraries
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.14.0
+Requires-Dist: pandas>=1.0.0
+Requires-Dist: scipy>=1.0.0; sys_platform != "win32" or python_version >= "3.10"
+Requires-Dist: scipy<=1.9.1,>=1.0.0; sys_platform == "win32" and python_version < "3.10"
+Requires-Dist: cloudpickle>=1.5.0
+Requires-Dist: psutil>=5.9.0
+Requires-Dist: tblib>=1.7.0
+Requires-Dist: uvloop>=0.14.0; sys_platform != "win32"
+Requires-Dist: packaging
+Requires-Dist: click
+Provides-Extra: dev
+Requires-Dist: cython>=0.29; extra == "dev"
+Requires-Dist: pytest>=3.5.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.5.0; extra == "dev"
+Requires-Dist: pytest-timeout>=1.2.0; extra == "dev"
+Requires-Dist: pytest-forked>=1.0; extra == "dev"
+Requires-Dist: pytest-asyncio>=0.14.0; extra == "dev"
+Requires-Dist: ipython>=6.5.0; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: pydata-sphinx-theme>=0.3.0; extra == "dev"
+Requires-Dist: sphinx-intl>=0.9.9; extra == "dev"
+Requires-Dist: flake8>=3.8.0; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: uv; extra == "dev"
+Requires-Dist: click; extra == "dev"
+Provides-Extra: doc
+Requires-Dist: ipython>=6.5.0; extra == "doc"
+Requires-Dist: sphinx; extra == "doc"
+Requires-Dist: pydata-sphinx-theme>=0.3.0; extra == "doc"
+Requires-Dist: sphinx-intl>=0.9.9; extra == "doc"
+Provides-Extra: extra
+Requires-Dist: pyarrow>=5.0.0; extra == "extra"
+Provides-Extra: kubernetes
+Requires-Dist: kubernetes>=10.0.0; extra == "kubernetes"
+Provides-Extra: ray
+Requires-Dist: xoscar_ray>=0.0.1; extra == "ray"
+Dynamic: description
+Dynamic: description-content-type
+
+<div align="center">
+  <img width="77%" alt="" src="https://raw.githubusercontent.com/xprobe-inc/xoscar/main/doc/source/_static/Xoscar.svg"><br>
+</div>
+
+# Python actor framework for heterogeneous computing.
+[![PyPI Latest Release](https://img.shields.io/pypi/v/xoscar.svg?style=for-the-badge)](https://pypi.org/project/xoscar/)
+[![Coverage](https://img.shields.io/codecov/c/github/xorbitsai/xoscar?style=for-the-badge)](https://codecov.io/gh/xorbitsai/xoscar)
+[![Build Status](https://img.shields.io/github/actions/workflow/status/xorbitsai/xoscar/python.yaml?branch=main&style=for-the-badge&label=GITHUB%20ACTIONS&logo=github)](https://actions-badge.atrox.dev/xorbitsai/xoscar/goto?ref=main)
+[![License](https://img.shields.io/pypi/l/xoscar.svg?style=for-the-badge)](https://github.com/xorbitsai/xoscar/blob/main/LICENSE)
+
+## What is actor
+Writing parallel and distributed programs is often challenging and requires a lot of time to deal with concurrency
+issues. Actor model provides a high-level, scalable and robust abstraction for building distributed applications. 
+It provides several benefits:
+- Scalability: Actors easily scale across nodes. The asynchronous, non-blocking nature of actors allows them to handle huge volumes of concurrent tasks efficiently.
+- Concurrency: The actor model abstracts over concurrency, allowing developers to avoid raw threads and locks.
+- Modularity: An actor system decomposes naturally into a collection of actors that can be understood independently. Actor logic is encapsulated within the actor itself.
+
+## Why Xoscar
+Xoscar implements the actor model in Python and provides user-friendly APIs that offer significant benefits for building 
+applications on heterogeneous hardware:
+- **Abstraction over low-level communication details**: Xoscar handles all communication between actors transparently,
+whether on CPUs, GPUs, or across nodes. Developers focus on application logic rather than managing hardware resources 
+and optimizing data transfer.
+- **Flexible actor models**: Xoscar supports both stateful and stateless actors. Stateful actors ensure thread safety for 
+concurrent systems while stateless actors can handle massive volumes of concurrent messages. Developers choose the 
+appropriate actor model for their needs.
+- **Batch method**: Xoscar provides a batch interface to significantly improve call efficiency when an actor interface is 
+invoked a large number of times.
+- **Advanced debugging support**: Xoscar can detect potential issues like deadlocks, long-running calls, and performance
+bottlenecks that would otherwise be nearly impossible to troubleshoot in a heterogeneous environment.
+- **Automated recovery**: If an actor fails for any reason, Xoscar will automatically restart it if you want. It can monitor 
+actors and restart them upon failure, enabling fault-tolerant systems.
+
+## Overview
+![architecture.png](doc/source/_static/architecture.png)
+Xoscar allows you to create multiple actor pools on each worker node, typically binding an actor pool to a CPU core or 
+a GPU card. Xoscar provides allocation policies so that whenever an actor is created, it will be instantiated in the
+appropriate pool based on the specified policy.
+
+When actors communicate, Xoscar will choose the optimal communication mechanism based on which pools the actors 
+belong to. This allows Xoscar to optimize communication in heterogeneous environments with multiple processing 
+units and accelerators.
+
+## Where to get it
+
+### PyPI
+Binary installers for the latest released version are available at the [Python
+Package Index (PyPI)](https://pypi.org/project/xoscar).
+
+```shell
+# PyPI
+pip install xoscar
+```
+
+### Build from source
+The source code is currently hosted on GitHub at: https://github.com/xorbitsai/xoscar .
+
+Building from source requires that you have cmake and gcc installed on your system.
+
+- cmake >= 3.11
+- gcc >= 8
+
+```shell
+# If you have never cloned xoscar before
+git clone --recursive https://github.com/xorbitsai/xoscar.git
+cd xoscar/python
+pip install -e .
+
+# If you have already cloned xoscar before
+cd xoscar
+git submodule init
+git submodule update
+cd python && pip install -e .
+```
+
+## APIs
+Here are basic APIs for Xoscar.
+#### Define an actor
+```python
+import xoscar as xo
+
+# stateful actor, for stateless actor, inherit from xo.StatelessActor
+class MyActor(xo.Actor):
+    def __init__(self, *args, **kwargs):
+        pass
+
+    async def __post_create__(self):
+        # called after created
+        pass
+
+    async def __pre_destroy__(self):
+        # called before destroy
+        pass
+
+    def method_a(self, arg_1, arg_2, **kw_1):  # user-defined function
+        pass
+
+    async def method_b(self, arg_1, arg_2, **kw_1):  # user-defined async function
+        pass
+```
+
+#### Create an actor
+```python
+import xoscar as xo
+
+actor_ref = await xo.create_actor(
+    MyActor, 1, 2, a=1, b=2,
+    address='<ip>:<port>', uid='UniqueActorName')
+```
+
+#### Get an actor reference
+```python
+import xoscar as xo
+
+actor_ref = await xo.actor_ref(address, actor_id)
+```
+
+#### Invoke a method
+```python
+# send
+await actor_ref.method_a.send(1, 2, a=1, b=2)
+# equivalent to actor_ref.method_a.send
+await actor_ref.method_a(1, 2, a=1, b=2)
+# tell, it sends a message asynchronously and does not wait for a response.
+await actor_ref.method_a.tell(1, 2, a=1, b=2)
+```
+### Batch method
+Xoscar provides a set of APIs to write batch methods. You can simply add a `@extensible` decorator to your actor method
+and create a batch version. All calls wrapped in a batch will be sent together, reducing possible RPC cost.
+#### Define a batch method
+```python
+import xoscar as xo
+
+class ExampleActor(xo.Actor):
+    @xo.extensible
+    async def batch_method(self, a, b=None):
+        pass
+```
+Xoscar also supports creating a batch version of the method:
+```python
+class ExampleActor(xo.Actor):
+    @xo.extensible
+    async def batch_method(self, a, b=None):
+        raise NotImplementedError  # this will redirect all requests to the batch version
+
+    @batch_method.batch
+    async def batch_method(self, args_list, kwargs_list):
+        results = []
+        for args, kwargs in zip(args_list, kwargs_list):
+            a, b = self.batch_method.bind(*args, **kwargs)
+            # process the request
+            results.append(result)
+        return results  # return a list of results
+```
+In a batch method, users can define how to more efficiently process a batch of requests.
+
+#### Invoke a batch method
+Calling batch methods is easy. You can use `<method_name>.delay` to make a batched call and use `<method_name>.batch` to send them:
+```python
+ref = await xo.actor_ref(uid='ExampleActor', address='127.0.0.1:13425')
+results = await ref.batch_method.batch(
+    ref.batch_method.delay(10, b=20),
+    ref.batch_method.delay(20),
+)
+```
+
+## License
+[Apache 2](LICENSE)

xoscar-0.8.0.dist-info/RECORD

@@ -0,0 +1,94 @@
+xoscar/__init__.py,sha256=lzCXUmkuIjcjkiNQFekysdJR_ZhlbjcfR5ka1bZZNQg,1683
+xoscar/_utils.cp313-win_amd64.pyd,sha256=pQdrnZVhRk71ojJFA0CqYoUNU1UTjNYnsFf0IrEcSkk,108544
+xoscar/_utils.pxd,sha256=rlNbTg5lhXA-jCOLksqF4jhUlNn0xw2jx1HxdLa34pc,1193
+xoscar/_utils.pyx,sha256=TWScgqmJGYzjbWBOShBLkq07ldfYEQ5fw6V4OytX_IA,7626
+xoscar/_version.py,sha256=bsfCVAo_o9LkiP3AjPsP4SRRqhjuS0t4D1WGJPzbdls,24412
+xoscar/api.py,sha256=QQDHn-_FiDExmOxEk8BUnq4Qrx13VX3shSlEEqPQJo0,15175
+xoscar/backend.py,sha256=8G5JwjoOT6Q2slb11eXNApxgcmvNQUCdQzkoIMDwLcQ,1917
+xoscar/batch.py,sha256=Jk5BSpvMFAV9DrRy0a9tgPvIo_dt8cbJReZBL0cnOPc,8128
+xoscar/constants.py,sha256=GJ1KEOxwnqksc9K_GH42TSWpQECeC6ti3KJmE3PUcTw,810
+xoscar/context.cp313-win_amd64.pyd,sha256=m2C98Logzp62_TtOkrje3FfgfAUBQNAanm9zIxC0jsA,153088
+xoscar/context.pxd,sha256=6n6IAbmArSRq8EjcsbS6npW8xP1jI0qOoS1fF0oyj-o,746
+xoscar/context.pyx,sha256=FOJVerGOvxe2USryXEQA0rpaFX_ScxISH6QWKUcahY8,11310
+xoscar/core.cp313-win_amd64.pyd,sha256=RwJwhe5xxjkTzFW-zx_3Gqrmbyv88vYgCyy6afDSESE,313856
+xoscar/core.pxd,sha256=9IZP7dYGfnF1I-obIls8R8b6forxDOPbiM3v5nVslLk,1368
+xoscar/core.pyx,sha256=U6jCZN74MQHi7HkQRaVGm_w5q-FMsw0nnE3aU6533_Q,22756
+xoscar/debug.py,sha256=hrmxIH6zvTKasQo6PUUgXu5mgEsR0g87Fvpw7CoHipg,5257
+xoscar/driver.py,sha256=EjZ7HkdSgwtE9pXGiJXXwgWfxaIn10eZyqKpBhelaoc,1414
+xoscar/errors.py,sha256=hfIAlYuSVfB3dAQYr8hTLAMmfy5en6Y8mihdtw1gTEE,1304
+xoscar/libcpp.pxd,sha256=XGy887HXdRsvF47s-A7PvHX6Gaf15d_azRscWJY0Hc8,1178
+xoscar/nvutils.py,sha256=z6RCVs0sgKFm55TTgAYG3qy5f_AKJzjcH2kcRB-wTJQ,21129
+xoscar/profiling.py,sha256=LUqkj6sSxaFj0ltS7Yk2kFsh5ieHY417xypTYHwQOb4,8275
+xoscar/utils.py,sha256=v2HDyjVe5uiJEtUnzHeOyXCqfLz0k4RRmv0RS8iQlxA,17104
+xoscar/aio/__init__.py,sha256=ZLJlVJJH5EhItKD6tLTBri-4FV4kT1O2qdIfBC-df98,691
+xoscar/aio/base.py,sha256=ytknTCjTjNQbTM7l7QGXqPYYUkD7qq-zVBGVZ34L1Tc,2335
+xoscar/aio/file.py,sha256=x1wrvDgtTFMv-6gjSPpBU26jAO5uEAlXGGnFtx7uevQ,1545
+xoscar/aio/lru.py,sha256=KyUfrmqQ2ZkU07Reih-VvUKP1VOg1jmwprEAcZ8pdNE,6539
+xoscar/aio/parallelism.py,sha256=egpScbxggXzAdc_evLsNmUyHafuxu62JWAYS-2ISSuI,1332
+xoscar/backends/__init__.py,sha256=g9OllTquu9MRB5nySVoyiRv2z-_OSALWrOhwt7L9WXc,657
+xoscar/backends/allocate_strategy.py,sha256=DzvTlixwzTANURI2mDLHm3vcaugSPDxU6UQZb89KH0U,5005
+xoscar/backends/config.py,sha256=86j0g_Xrl8ENPzBWi296yWg9QEcljvdKK-yJbfYTvQ0,5532
+xoscar/backends/context.py,sha256=qWwksx8JxYcKR-LQA3PvXh4ReuuTTEyDaLbjpxGXcTA,16766
+xoscar/backends/core.py,sha256=edlPDR3VH2tBLx3ZmtNktKOTsrG9AUDPW2Y_QRqXiLs,13197
+xoscar/backends/message.cp313-win_amd64.pyd,sha256=e0D-r7gLhXmWE457pwKGgMDb1SL7aMe-4NAhYaGyRm0,249344
+xoscar/backends/message.pyi,sha256=m1PrSLvj-IbrHuVfQGoPDs6prI-GJV1vQJqZ5WdQcY4,6798
+xoscar/backends/message.pyx,sha256=lBEjMJv4VyxmeO9lHXJJazOajbFnTLak4PSBcLoPZvU,20331
+xoscar/backends/pool.py,sha256=vLWEdTYg08nPy0tFf8nBA8gamBh1wSslsYaIsDl7vPU,62313
+xoscar/backends/router.py,sha256=EjfNpQUrhFU15eYe1kRPueziHgI2gfDViUzm7ruvXDE,10817
+xoscar/backends/communication/__init__.py,sha256=i0RWfN_no-xwlzLUl8Av8zZqVWxfgBaT2qbUvOLt37s,1093
+xoscar/backends/communication/base.py,sha256=wmWTeE4lcB_ohqyJJ6MdzMGcrOqy2RSKRp8y-NDuFdY,7736
+xoscar/backends/communication/core.py,sha256=ZM_fU0yokoPzXcJ6j-89llp2r7J9pl3gE5iImn4b4bE,2199
+xoscar/backends/communication/dummy.py,sha256=h04je_WcGCjpjf-vHUsY_Rou_s370pzP1R-Q2yeBaWg,8410
+xoscar/backends/communication/errors.py,sha256=-O6ZaKs6Gz7g_ZnKU2wrz8D9btowqaYuQ9u0zCYSLWo,743
+xoscar/backends/communication/socket.py,sha256=4etCT3bSzCfvXlAsHtkcTLIU4PRdk6FlrjdBABPiTMY,14926
+xoscar/backends/communication/ucx.py,sha256=SQh461aiqdKKZe9fC4sDroFO2FmtQ_vX0oKSQjnqoFA,20498
+xoscar/backends/communication/utils.py,sha256=F-muF5_ow9JzAPAZ3d8XaGDiz3bRZOdWmWBDwQOVLe0,3761
+xoscar/backends/indigen/__init__.py,sha256=Khr2aGbaIw_04NIdY7QNhdljCKbmmzLb4NeAOM3LF8M,701
+xoscar/backends/indigen/__main__.py,sha256=VeHSoiqCRyx9QMFO4Bnsiblhrn63qKY604Fv476ziVk,529
+xoscar/backends/indigen/backend.py,sha256=cCMkZDEKuRQlFb6v79JvWi5lfzsvAafznOeEWlw7CWY,1663
+xoscar/backends/indigen/driver.py,sha256=uLPBAxG7q8ds6yc-baeYUWu_m4K1gST3_BPqkfnlarw,978
+xoscar/backends/indigen/fate_sharing.py,sha256=r1U5hJ1tVOQa-ncCcX731LKbHon1i-WQdxcqwLX5sOQ,8876
+xoscar/backends/indigen/pool.py,sha256=TTMbEZk5snv8ky_YbnxEd3boa3By3yyABBVKXD83HTU,19013
+xoscar/backends/indigen/shared_memory.py,sha256=bfRKIvmtnUmkx9zhgwEMFO-in082Eb-YO2txFeFvhIY,19630
+xoscar/backends/test/__init__.py,sha256=xgE4hbD3g46G1GDJEeozaXIk57XaahmFMNQsnRzRcrs,698
+xoscar/backends/test/backend.py,sha256=Q4C6TFQzZogjugGmPh3QZw4IigL8VGCFOJ5fKkE1Uvk,1301
+xoscar/backends/test/pool.py,sha256=6oxD65EQoZLQ35UA-RecXSX6cpvY0GxjNw6teT0KFyA,8490
+xoscar/collective/__init__.py,sha256=3tTgFXALDbAwmEDtmBX7PN7N6ZrcPFC4evMXMIhBtsg,801
+xoscar/collective/common.py,sha256=9c7xq3IOUvfA0I9GnpalUqXZOzmF6IEILv4zL64BYVE,3663
+xoscar/collective/core.py,sha256=191aPxbUgWpjzrqyozndImDAQhZFmqoQdBkHFLDfXN0,24239
+xoscar/collective/process_group.py,sha256=kTPbrLMJSGhqbiWvTIiz-X3W0rZWd_CFn_zUIlXbOlM,23286
+xoscar/collective/utils.py,sha256=p3WEVtXvnVhkuO5mRgQBhBRFr1dKHcDKMjrbMyuiyfg,1219
+xoscar/collective/uv.dll,sha256=VCSOD5waiq21jwDWVYdNqWrcqhWEV8CkA9eiHJcF8eY,620544
+xoscar/collective/xoscar_pygloo.cp313-win_amd64.pyd,sha256=BY4eMxSLWUY-wgRwMcjcPx7oB8ZJx88ulk9WMJxVBtQ,795136
+xoscar/collective/xoscar_pygloo.pyi,sha256=6KRzElgNBBKWh-VivUw1b5Dolp17MgwA91hQo33EysU,7616
+xoscar/collective/backend/__init__.py,sha256=ddL0XEwB6InL4A6Z6eKsYKoDbMSC9s_mwLBPhOcnDfI,594
+xoscar/collective/backend/nccl_backend.py,sha256=lp05ki_qhfdYEqG8HxG2ZSSfLoLlx1oMY7uwsD5I7-0,6440
+xoscar/metrics/__init__.py,sha256=RjXuuYw4I2YYgD8UY2Z5yCZk0Z56xMJ1n40O80Dtxf8,726
+xoscar/metrics/api.py,sha256=dtJ4QrIqQNXhJedeqOPs4TXKgrRGZFFN50xAd9SCfec,9144
+xoscar/metrics/backends/__init__.py,sha256=ZHepfhCDRuK9yz4pAM7bjpWDvS3Ijp1YgyynoUFLeuU,594
+xoscar/metrics/backends/metric.py,sha256=WdQMtp_x4qasJ3_HLUDaZnoCwYca0mX2QfVrOwHpuDI,4595
+xoscar/metrics/backends/console/__init__.py,sha256=ZHepfhCDRuK9yz4pAM7bjpWDvS3Ijp1YgyynoUFLeuU,594
+xoscar/metrics/backends/console/console_metric.py,sha256=o6uGA65Kp3yvkMSGKrIilD2MAXKih-of1yEnOfE206I,2164
+xoscar/metrics/backends/prometheus/__init__.py,sha256=ZHepfhCDRuK9yz4pAM7bjpWDvS3Ijp1YgyynoUFLeuU,594
+xoscar/metrics/backends/prometheus/prometheus_metric.py,sha256=65hb8O3tmsEJ7jgOrIwl_suj9SE5Tmqcfjuk0urkLvE,2120
+xoscar/serialization/__init__.py,sha256=tS8C49yrW_geWNEsbgW3phK1q4YN1ojI6CN-vroIFYM,876
+xoscar/serialization/aio.py,sha256=7YLXgkWpQ3ANy-TZ1qO8Mt4_J3cZFhFh2FEgUgxMT60,4873
+xoscar/serialization/core.cp313-win_amd64.pyd,sha256=AJc5SB8_fWLSuThIIrT4JTlkkfxmShMUFKpBlfJkcUQ,268800
+xoscar/serialization/core.pxd,sha256=X-47bqBM2Kzw5SkLqICdKD0gU6CpmLsBxC3kfW--wVk,1013
+xoscar/serialization/core.pyi,sha256=Zof9373qy2lmjenSuMznEiTSCNW6WQB7rmSXrRbjUo0,1931
+xoscar/serialization/core.pyx,sha256=ZKexLRnRwZXXn2045kR7xfM_szcoPNrDuouQCWtpFp8,30570
+xoscar/serialization/cuda.py,sha256=Fj4Cpr_YmkGceUCo0mQn8fRvmHP_5WcLdRx6epZ3RC0,3869
+xoscar/serialization/exception.py,sha256=t6yZn_Ate04UE1RbabNh7mu739sdtwarjuPXWhASx7c,1682
+xoscar/serialization/mlx.py,sha256=8QOWlYmS0eFZ1bYweDQzUkSRw5MI0dt118wOGhyGk1s,2185
+xoscar/serialization/numpy.py,sha256=C6WVx-Sdl2OHBAvVY34DFjAKXlekMbpc2ni6bR8wxYo,3001
+xoscar/serialization/pyfury.py,sha256=3ucal29Hr7PX9_1SfB2x43FE2xw_C0rLkVv3foL7qwM,1200
+xoscar/serialization/scipy.py,sha256=9ph-yoRoNiwUZTwQrn35U60VPirWlncXNAg6EXvqMR4,2554
+xoscar/virtualenv/__init__.py,sha256=rhJ7I6x7aXjKOCzSqsKLwqFJMh4YC2sqchEIJNEfI58,1151
+xoscar/virtualenv/core.py,sha256=nRfOcKQbb-4TjtLmeMepFnMPLySJAIFwFJsXvXnNv44,8366
+xoscar/virtualenv/platform.py,sha256=pykIAB8R5uHHQc8igPt-6dHisoVscRKnUcNPrPIFWrY,1597
+xoscar/virtualenv/utils.py,sha256=WzhEnwgGNQV5sRqZrdvCyQPcJqI5V9feBLM_Mr7UD-w,2975
+xoscar/virtualenv/uv.py,sha256=m95UyJ9BnWHqAoRI_yT1PFB11ulr_CS_pBd_gKkOkyU,11412
+xoscar-0.8.0.dist-info/METADATA,sha256=fMDJPYUbqvX4bQEEE4afIuHSk-uXcUYkTeJU6J0ld-A,9469
+xoscar-0.8.0.dist-info/WHEEL,sha256=qV0EIPljj1XC_vuSatRWjn02nZIz3N1t8jsZz7HBr2U,101
+xoscar-0.8.0.dist-info/top_level.txt,sha256=vYlqqY4Nys8Thm1hePIuUv8eQePdULVWMmt7lXtX_ZA,21
+xoscar-0.8.0.dist-info/RECORD,,

xoscar-0.8.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: false
+Tag: cp313-cp313-win_amd64
+

xoscar-0.8.0.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+xoscar
+xoscar_pygloo