| Name | xmanager JSON |
| Version |
0.5.0
JSON |
| download |
| home_page | |
| Summary | A framework for managing machine learning experiments |
| upload_time | 2023-12-18 12:32:58 |
| maintainer | |
| docs_url | None |
| author | DeepMind Technologies Limited |
| requires_python | >=3.10 |
| license | |
| keywords |
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
# XManager: A framework for managing machine learning experiments 🧑🔬
<!-- Note that links in README.md have to be absolute as it also lands on PyPI. -->
XManager is a platform for packaging, running and keeping track of machine
learning experiments. It currently enables one to launch experiments locally or
on [Google Cloud Platform (GCP)](https://cloud.google.com/). Interaction with
experiments is done via XManager's APIs through Python *launch scripts*. Check
out
[these slides](https://storage.googleapis.com/gresearch/xmanager/deepmind_xmanager_slides.pdf)
for a more detailed introduction.
To get started, install [XManager](#install-xmanager), its
[prerequisites](#prerequisites) if needed and follow [the
tutorial](#writing-xmanager-launch-scripts) or a codelab
([Colab Notebook](https://colab.research.google.com/github/deepmind/xmanager/blob/master/colab_codelab.ipynb) / [Jupyter Notebook](https://github.com/deepmind/xmanager/blob/main/jupyter_codelab.ipynb))
to create and run a launch script.
See
[CONTRIBUTING.md](https://github.com/deepmind/xmanager/blob/main/CONTRIBUTING.md)
for guidance on contributions.
## Install XManager
```bash
pip install git+https://github.com/deepmind/xmanager.git
```
Or, alternatively, [a PyPI project](https://pypi.org/project/xmanager/) is also
available.
```bash
pip install xmanager
```
On Debian-based systems, XManager and all its dependencies can be installed and
set up by cloning this repository and then running
```sh
cd xmanager/setup_scripts && chmod +x setup_all.sh && . ./setup_all.sh
```
## Prerequisites
The codebase assumes Python 3.9+.
### Install Docker (optional)
If you use `xmanager.xm.PythonDocker` to run XManager experiments,
you need to install Docker.
1. Follow [the steps](https://docs.docker.com/engine/install/#supported-platforms)
to install Docker.
2. And if you are a Linux user, follow [the steps](https://docs.docker.com/engine/install/linux-postinstall/)
to enable sudoless Docker.
### Install Bazel (optional)
If you use `xmanager.xm_local.BazelContainer` or `xmanager.xm_local.BazelBinary`
to run XManager experiments, you need to install Bazel.
1. Follow [the steps](https://docs.bazel.build/versions/master/install.html) to
install Bazel.
### Create a GCP project (optional)
If you use `xm_local.Vertex` ([Vertex AI](https://cloud.google.com/vertex-ai))
to run XManager experiments, you need to have a GCP project in order to be able
to access Vertex AI to run jobs.
1. [Create](https://console.cloud.google.com/) a GCP project.
2. [Install](https://cloud.google.com/sdk/docs/install) `gcloud`.
3. Associate your Google Account (Gmail account) with your GCP project by
running:
```bash
export GCP_PROJECT=<GCP PROJECT ID>
gcloud auth login
gcloud auth application-default login
gcloud config set project $GCP_PROJECT
```
4. Set up `gcloud` to work with Docker by running:
```bash
gcloud auth configure-docker
```
5. Enable Google Cloud Platform APIs.
* [Enable](https://console.cloud.google.com/apis/library/iam.googleapis.com)
IAM.
* [Enable](https://console.cloud.google.com/apis/library/aiplatform.googleapis.com)
the 'Cloud AI Platfrom'.
* [Enable](https://console.cloud.google.com/apis/library/containerregistry.googleapis.com)
the 'Container Registry'.
6. Create a staging bucket in us-central1 if you do not already have one. This
bucket should be used to save experiment artifacts like TensorFlow log files,
which can be read by TensorBoard. This bucket may also be used to stage files
to build your Docker image if you build your images remotely.
```bash
export GOOGLE_CLOUD_BUCKET_NAME=<GOOGLE_CLOUD_BUCKET_NAME>
gsutil mb -l us-central1 gs://$GOOGLE_CLOUD_BUCKET_NAME
```
Add `GOOGLE_CLOUD_BUCKET_NAME` to the environment variables or your .bashrc:
```bash
export GOOGLE_CLOUD_BUCKET_NAME=<GOOGLE_CLOUD_BUCKET_NAME>
```
## Writing XManager launch scripts
<details>
<summary>
A snippet for the impatient 🙂
</summary>
```python
# Contains core primitives and APIs.
from xmanager import xm
# Implementation of those core concepts for what we call 'the local backend',
# which means all executables are sent for execution from this machine,
# independently of whether they are actually executed on our machine or on GCP.
from xmanager import xm_local
#
# Creates an experiment context and saves its metadata to the database, which we
# can reuse later via `xm_local.list_experiments`, for example. Note that
# `experiment` has tracking properties such as `id`.
with xm_local.create_experiment(experiment_title='cifar10') as experiment:
# Packaging prepares a given *executable spec* for running with a concrete
# *executor spec*: depending on the combination, that may involve building
# steps and / or copying the results somewhere. For example, a
# `xm.python_container` designed to run on `Kubernetes` will be built via
#`docker build`, and the new image will be uploaded to the container registry.
# But for our simple case where we have a prebuilt Linux binary designed to
# run locally only some validations are performed -- for example, that the
# file exists.
#
# `executable` contains all the necessary information needed to launch the
# packaged blob via `.add`, see below.
[executable] = experiment.package([
xm.binary(
# What we are going to run.
path='/home/user/project/a.out',
# Where we are going to run it.
executor_spec=xm_local.Local.Spec(),
)
])
#
# Let's find out which `batch_size` is best -- presumably our jobs write the
# results somewhere.
for batch_size in [64, 1024]:
# `add` creates a new *experiment unit*, which is usually a collection of
# semantically united jobs, and sends them for execution. To pass an actual
# collection one may want to use `JobGroup`s (more about it later in the
# documentation), but for our purposes we are going to pass just one job.
experiment.add(xm.Job(
# The `a.out` we packaged earlier.
executable=executable,
# We are using the default settings here, but executors have plenty of
# arguments available to control execution.
executor=xm_local.Local(),
# Time to pass the batch size as a command-line argument!
args={'batch_size': batch_size},
# We can also pass environment variables.
env_vars={'HEAPPROFILE': '/tmp/a_out.hprof'},
))
#
# The context will wait for locally run things (but not for remote things such
# as jobs sent to GCP, although they can be explicitly awaited via
# `wait_for_completion`).
```
</details>
The basic structure of an XManager launch script can be summarized by these
steps:
1. Create an experiment and acquire its context.
```python
from xmanager import xm
from xmanager import xm_local
with xm_local.create_experiment(experiment_title='cifar10') as experiment:
```
2. Define specifications of executables you want to run.
```python
spec = xm.PythonContainer(
path='/path/to/python/folder',
entrypoint=xm.ModuleName('cifar10'),
)
```
3. Package your executables.
```python
[executable] = experiment.package([
xm.Packageable(
executable_spec=spec,
executor_spec=xm_local.Vertex.Spec(),
),
])
```
4. Define your hyperparameters.
```python
import itertools
batch_sizes = [64, 1024]
learning_rates = [0.1, 0.001]
trials = list(
dict([('batch_size', bs), ('learning_rate', lr)])
for (bs, lr) in itertools.product(batch_sizes, learning_rates)
)
```
5. Define resource requirements for each job.
```python
requirements = xm.JobRequirements(T4=1)
```
6. For each trial, add a job / job groups to launch them.
```python
for hyperparameters in trials:
experiment.add(xm.Job(
executable=executable,
executor=xm_local.Vertex(requirements=requirements),
args=hyperparameters,
))
```
Now we should be ready [to run](#run-xmanager) the launch script.
To learn more about different *executables* and *executors* follow
['Components'](#components).
## Run XManager
```bash
xmanager launch ./xmanager/examples/cifar10_tensorflow/launcher.py
```
In order to run multi-job experiments, the `--xm_wrap_late_bindings` flag might
be required:
```bash
xmanager launch ./xmanager/examples/cifar10_tensorflow/launcher.py -- --xm_wrap_late_bindings
```
<!-- TODO: Elaborate on why that is necessary. -->
## Components
### Executable specifications
XManager executable specifications define what should be packaged in the form of
binaries, source files, and other input dependencies required for job execution.
Executable specifications are reusable and generally platform-independent.
See
[executable_specs.md](https://github.com/deepmind/xmanager/blob/main/docs/executable_specs.md)
for details on each executable specification.
| Name | Description |
| --- | --- |
| `xmanager.xm.Container` | A pre-built `.tar` image. |
| `xmanager.xm.BazelContainer` | A [Bazel](https://bazel.build/) target producing a `.tar` image. |
| `xmanager.xm.Binary` | A pre-built binary. |
| `xmanager.xm.BazelBinary` | A [Bazel](https://bazel.build/) target producing a self-contained binary. |
| `xmanager.xm.PythonContainer` | A directory with Python modules to be packaged as a Docker container. |
### Executors
XManager executors define a platform where the job runs and resource
requirements for the job.
Each executor also has a specification which describes how an executable
specification should be prepared and packaged.
See
[executors.md](https://github.com/deepmind/xmanager/blob/main/docs/executors.md)
for details on each executor.
| Name | Description |
| --- | --- |
| `xmanager.xm_local.Local` | Runs a binary or a container locally. |
| `xmanager.xm_local.Vertex` | Runs a container on [Vertex AI](#create-a-gcp-project-(optional)). |
| `xmanager.xm_local.Kubernetes` | Runs a container on Kubernetes. |
### Job / JobGroup
A `Job` represents a single executable on a particular executor, while a
`JobGroup` unites a group of `Job`s providing a gang scheduling concept:
`Job`s inside them are scheduled / descheduled simultaneously. Same `Job`
and `JobGroup` instances can be `add`ed multiple times.
#### Job
A Job accepts an executable and an executor along with hyperparameters which can
either be command-line arguments or environment variables.
Command-line arguments can be passed in list form, `[arg1, arg2, arg3]`:
```bash
binary arg1 arg2 arg3
```
They can also be passed in dictionary form, `{key1: value1, key2: value2}`:
```bash
binary --key1=value1 --key2=value2
```
Environment variables are always passed in `Dict[str, str]` form:
```bash
export KEY=VALUE
```
Jobs are defined like this:
```python
[executable] = xm.Package(...)
executor = xm_local.Vertex(...)
xm.Job(
executable=executable,
executor=executor,
args={
'batch_size': 64,
},
env_vars={
'NCCL_DEBUG': 'INFO',
},
)
```
#### JobGroup
A JobGroup accepts jobs in a kwargs form. The keyword can be any valid Python
identifier. For example, you can call your jobs 'agent' and 'observer'.
```python
agent_job = xm.Job(...)
observer_job = xm.Job(...)
xm.JobGroup(agent=agent_job, observer=observer_job)
```
Raw data
{
"_id": null,
"home_page": "",
"name": "xmanager",
"maintainer": "",
"docs_url": null,
"requires_python": ">=3.10",
"maintainer_email": "",
"keywords": "",
"author": "DeepMind Technologies Limited",
"author_email": "",
"download_url": "https://files.pythonhosted.org/packages/a0/ad/50c70ec1d22727d15a098e7fadb2f0031830009a63af956b03a5b05df864/xmanager-0.5.0.tar.gz",
"platform": null,
"description": "# XManager: A framework for managing machine learning experiments \ud83e\uddd1\u200d\ud83d\udd2c\n\n<!-- Note that links in README.md have to be absolute as it also lands on PyPI. -->\n\nXManager is a platform for packaging, running and keeping track of machine\nlearning experiments. It currently enables one to launch experiments locally or\non [Google Cloud Platform (GCP)](https://cloud.google.com/). Interaction with\nexperiments is done via XManager's APIs through Python *launch scripts*. Check\nout\n[these slides](https://storage.googleapis.com/gresearch/xmanager/deepmind_xmanager_slides.pdf)\nfor a more detailed introduction.\n\n\nTo get started, install [XManager](#install-xmanager), its\n[prerequisites](#prerequisites) if needed and follow [the\ntutorial](#writing-xmanager-launch-scripts) or a codelab\n([Colab Notebook](https://colab.research.google.com/github/deepmind/xmanager/blob/master/colab_codelab.ipynb) / [Jupyter Notebook](https://github.com/deepmind/xmanager/blob/main/jupyter_codelab.ipynb))\nto create and run a launch script.\n\nSee\n[CONTRIBUTING.md](https://github.com/deepmind/xmanager/blob/main/CONTRIBUTING.md)\nfor guidance on contributions.\n\n## Install XManager\n\n```bash\npip install git+https://github.com/deepmind/xmanager.git\n```\n\nOr, alternatively, [a PyPI project](https://pypi.org/project/xmanager/) is also\navailable.\n\n```bash\npip install xmanager\n```\n\nOn Debian-based systems, XManager and all its dependencies can be installed and\nset up by cloning this repository and then running\n\n```sh\ncd xmanager/setup_scripts && chmod +x setup_all.sh && . ./setup_all.sh\n```\n\n## Prerequisites\n\nThe codebase assumes Python 3.9+.\n\n### Install Docker (optional)\n\nIf you use `xmanager.xm.PythonDocker` to run XManager experiments,\nyou need to install Docker.\n\n1. Follow [the steps](https://docs.docker.com/engine/install/#supported-platforms)\n to install Docker.\n\n2. And if you are a Linux user, follow [the steps](https://docs.docker.com/engine/install/linux-postinstall/)\n to enable sudoless Docker.\n\n### Install Bazel (optional)\n\nIf you use `xmanager.xm_local.BazelContainer` or `xmanager.xm_local.BazelBinary`\nto run XManager experiments, you need to install Bazel.\n\n1. Follow [the steps](https://docs.bazel.build/versions/master/install.html) to\n install Bazel.\n\n### Create a GCP project (optional)\n\nIf you use `xm_local.Vertex` ([Vertex AI](https://cloud.google.com/vertex-ai))\nto run XManager experiments, you need to have a GCP project in order to be able\nto access Vertex AI to run jobs.\n\n1. [Create](https://console.cloud.google.com/) a GCP project.\n\n2. [Install](https://cloud.google.com/sdk/docs/install) `gcloud`.\n\n3. Associate your Google Account (Gmail account) with your GCP project by\n running:\n\n ```bash\n export GCP_PROJECT=<GCP PROJECT ID>\n gcloud auth login\n gcloud auth application-default login\n gcloud config set project $GCP_PROJECT\n ```\n\n4. Set up `gcloud` to work with Docker by running:\n\n ```bash\n gcloud auth configure-docker\n ```\n\n5. Enable Google Cloud Platform APIs.\n\n * [Enable](https://console.cloud.google.com/apis/library/iam.googleapis.com)\n IAM.\n\n * [Enable](https://console.cloud.google.com/apis/library/aiplatform.googleapis.com)\n the 'Cloud AI Platfrom'.\n\n * [Enable](https://console.cloud.google.com/apis/library/containerregistry.googleapis.com)\n the 'Container Registry'.\n\n6. Create a staging bucket in us-central1 if you do not already have one. This\n bucket should be used to save experiment artifacts like TensorFlow log files,\n which can be read by TensorBoard. This bucket may also be used to stage files\n to build your Docker image if you build your images remotely.\n\n ```bash\n export GOOGLE_CLOUD_BUCKET_NAME=<GOOGLE_CLOUD_BUCKET_NAME>\n gsutil mb -l us-central1 gs://$GOOGLE_CLOUD_BUCKET_NAME\n ```\n\n Add `GOOGLE_CLOUD_BUCKET_NAME` to the environment variables or your .bashrc:\n\n ```bash\n export GOOGLE_CLOUD_BUCKET_NAME=<GOOGLE_CLOUD_BUCKET_NAME>\n ```\n\n## Writing XManager launch scripts\n\n<details>\n <summary>\n A snippet for the impatient \ud83d\ude42\n </summary>\n\n```python\n# Contains core primitives and APIs.\nfrom xmanager import xm\n# Implementation of those core concepts for what we call 'the local backend',\n# which means all executables are sent for execution from this machine,\n# independently of whether they are actually executed on our machine or on GCP.\nfrom xmanager import xm_local\n#\n# Creates an experiment context and saves its metadata to the database, which we\n# can reuse later via `xm_local.list_experiments`, for example. Note that\n# `experiment` has tracking properties such as `id`.\nwith xm_local.create_experiment(experiment_title='cifar10') as experiment:\n # Packaging prepares a given *executable spec* for running with a concrete\n # *executor spec*: depending on the combination, that may involve building\n # steps and / or copying the results somewhere. For example, a\n # `xm.python_container` designed to run on `Kubernetes` will be built via\n #`docker build`, and the new image will be uploaded to the container registry.\n # But for our simple case where we have a prebuilt Linux binary designed to\n # run locally only some validations are performed -- for example, that the\n # file exists.\n #\n # `executable` contains all the necessary information needed to launch the\n # packaged blob via `.add`, see below.\n [executable] = experiment.package([\n xm.binary(\n # What we are going to run.\n path='/home/user/project/a.out',\n # Where we are going to run it.\n executor_spec=xm_local.Local.Spec(),\n )\n ])\n #\n # Let's find out which `batch_size` is best -- presumably our jobs write the\n # results somewhere.\n for batch_size in [64, 1024]:\n # `add` creates a new *experiment unit*, which is usually a collection of\n # semantically united jobs, and sends them for execution. To pass an actual\n # collection one may want to use `JobGroup`s (more about it later in the\n # documentation), but for our purposes we are going to pass just one job.\n experiment.add(xm.Job(\n # The `a.out` we packaged earlier.\n executable=executable,\n # We are using the default settings here, but executors have plenty of\n # arguments available to control execution.\n executor=xm_local.Local(),\n # Time to pass the batch size as a command-line argument!\n args={'batch_size': batch_size},\n # We can also pass environment variables.\n env_vars={'HEAPPROFILE': '/tmp/a_out.hprof'},\n ))\n #\n # The context will wait for locally run things (but not for remote things such\n # as jobs sent to GCP, although they can be explicitly awaited via\n # `wait_for_completion`).\n```\n\n</details>\n\nThe basic structure of an XManager launch script can be summarized by these\nsteps:\n\n1. Create an experiment and acquire its context.\n\n ```python\n from xmanager import xm\n from xmanager import xm_local\n\n with xm_local.create_experiment(experiment_title='cifar10') as experiment:\n ```\n\n2. Define specifications of executables you want to run.\n\n ```python\n spec = xm.PythonContainer(\n path='/path/to/python/folder',\n entrypoint=xm.ModuleName('cifar10'),\n )\n ```\n\n3. Package your executables.\n\n ```python\n [executable] = experiment.package([\n xm.Packageable(\n executable_spec=spec,\n executor_spec=xm_local.Vertex.Spec(),\n ),\n ])\n ```\n\n4. Define your hyperparameters.\n\n ```python\n import itertools\n\n batch_sizes = [64, 1024]\n learning_rates = [0.1, 0.001]\n trials = list(\n dict([('batch_size', bs), ('learning_rate', lr)])\n for (bs, lr) in itertools.product(batch_sizes, learning_rates)\n )\n ```\n\n5. Define resource requirements for each job.\n\n ```python\n requirements = xm.JobRequirements(T4=1)\n ```\n\n6. For each trial, add a job / job groups to launch them.\n\n ```python\n for hyperparameters in trials:\n experiment.add(xm.Job(\n executable=executable,\n executor=xm_local.Vertex(requirements=requirements),\n args=hyperparameters,\n ))\n ```\n\nNow we should be ready [to run](#run-xmanager) the launch script.\n\nTo learn more about different *executables* and *executors* follow\n['Components'](#components).\n\n## Run XManager\n\n```bash\nxmanager launch ./xmanager/examples/cifar10_tensorflow/launcher.py\n```\n\nIn order to run multi-job experiments, the `--xm_wrap_late_bindings` flag might\nbe required:\n\n```bash\nxmanager launch ./xmanager/examples/cifar10_tensorflow/launcher.py -- --xm_wrap_late_bindings\n```\n\n<!-- TODO: Elaborate on why that is necessary. -->\n\n## Components\n\n### Executable specifications\n\nXManager executable specifications define what should be packaged in the form of\nbinaries, source files, and other input dependencies required for job execution.\nExecutable specifications are reusable and generally platform-independent.\n\nSee\n[executable_specs.md](https://github.com/deepmind/xmanager/blob/main/docs/executable_specs.md)\nfor details on each executable specification.\n\n| Name | Description |\n| --- | --- |\n| `xmanager.xm.Container` | A pre-built `.tar` image. |\n| `xmanager.xm.BazelContainer` | A [Bazel](https://bazel.build/) target producing a `.tar` image. |\n| `xmanager.xm.Binary` | A pre-built binary. |\n| `xmanager.xm.BazelBinary` | A [Bazel](https://bazel.build/) target producing a self-contained binary. |\n| `xmanager.xm.PythonContainer` | A directory with Python modules to be packaged as a Docker container. |\n\n\n### Executors\n\nXManager executors define a platform where the job runs and resource\nrequirements for the job.\n\nEach executor also has a specification which describes how an executable\nspecification should be prepared and packaged.\n\nSee\n[executors.md](https://github.com/deepmind/xmanager/blob/main/docs/executors.md)\nfor details on each executor.\n\n| Name | Description |\n| --- | --- |\n| `xmanager.xm_local.Local` | Runs a binary or a container locally. |\n| `xmanager.xm_local.Vertex` | Runs a container on [Vertex AI](#create-a-gcp-project-(optional)). |\n| `xmanager.xm_local.Kubernetes` | Runs a container on Kubernetes. |\n\n### Job / JobGroup\n\nA `Job` represents a single executable on a particular executor, while a\n`JobGroup` unites a group of `Job`s providing a gang scheduling concept:\n`Job`s inside them are scheduled / descheduled simultaneously. Same `Job`\nand `JobGroup` instances can be `add`ed multiple times.\n\n#### Job\n\nA Job accepts an executable and an executor along with hyperparameters which can\neither be command-line arguments or environment variables.\n\nCommand-line arguments can be passed in list form, `[arg1, arg2, arg3]`:\n\n```bash\nbinary arg1 arg2 arg3\n```\n\nThey can also be passed in dictionary form, `{key1: value1, key2: value2}`:\n\n```bash\nbinary --key1=value1 --key2=value2\n```\n\nEnvironment variables are always passed in `Dict[str, str]` form:\n\n```bash\nexport KEY=VALUE\n```\n\nJobs are defined like this:\n\n```python\n[executable] = xm.Package(...)\n\nexecutor = xm_local.Vertex(...)\n\nxm.Job(\n executable=executable,\n executor=executor,\n args={\n 'batch_size': 64,\n },\n env_vars={\n 'NCCL_DEBUG': 'INFO',\n },\n)\n```\n\n#### JobGroup\n\nA JobGroup accepts jobs in a kwargs form. The keyword can be any valid Python\nidentifier. For example, you can call your jobs 'agent' and 'observer'.\n\n```python\nagent_job = xm.Job(...)\nobserver_job = xm.Job(...)\n\nxm.JobGroup(agent=agent_job, observer=observer_job)\n```\n",
"bugtrack_url": null,
"license": "",
"summary": "A framework for managing machine learning experiments",
"version": "0.5.0",
"project_urls": {
"Homepage": "https://github.com/deepmind/xmanager",
"Issue tracker": "https://github.com/deepmind/xmanager/issues"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "febc02f444f123d0107c48f95ceaacd7445b12979d41f64c0466d481c28cbffb",
"md5": "6921a0679690b3d052de972eaf786572",
"sha256": "9b58daa6918bd332e879d3d2bf64839f99e4131707b3946d1c6b72ee0af022a9"
},
"downloads": -1,
"filename": "xmanager-0.5.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "6921a0679690b3d052de972eaf786572",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.10",
"size": 210771,
"upload_time": "2023-12-18T12:32:56",
"upload_time_iso_8601": "2023-12-18T12:32:56.298020Z",
"url": "https://files.pythonhosted.org/packages/fe/bc/02f444f123d0107c48f95ceaacd7445b12979d41f64c0466d481c28cbffb/xmanager-0.5.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "a0ad50c70ec1d22727d15a098e7fadb2f0031830009a63af956b03a5b05df864",
"md5": "a66822ff8058285c907e3f7be2e1d31f",
"sha256": "9ca14f2614e5d14a425a8b00a474c6a77b522b668b958e9fcf8577a1698ae352"
},
"downloads": -1,
"filename": "xmanager-0.5.0.tar.gz",
"has_sig": false,
"md5_digest": "a66822ff8058285c907e3f7be2e1d31f",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.10",
"size": 151872,
"upload_time": "2023-12-18T12:32:58",
"upload_time_iso_8601": "2023-12-18T12:32:58.543412Z",
"url": "https://files.pythonhosted.org/packages/a0/ad/50c70ec1d22727d15a098e7fadb2f0031830009a63af956b03a5b05df864/xmanager-0.5.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2023-12-18 12:32:58",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "deepmind",
"github_project": "xmanager",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"lcname": "xmanager"
}
