pywhales 0.2.1__tar.gz

pywhales-0.2.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Gabriel de Marmiesse de Lussan
+
+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.

pywhales-0.2.1/MANIFEST.in

@@ -0,0 +1,3 @@
+global-include *.txt
+global-include *.md
+global-include *.typed

pywhales-0.2.1/PKG-INFO

@@ -0,0 +1,206 @@
+Metadata-Version: 2.4
+Name: pywhales
+Version: 0.2.1
+Summary: A Docker client for Python, designed to be fun and intuitive!
+License-Expression: MIT
+Project-URL: Source, https://github.com/MaraClaw/PyWhales
+Project-URL: Documentation, https://github.com/MaraClaw/PyWhales
+Project-URL: Bug Tracker, https://github.com/MaraClaw/PyWhales/issues
+Requires-Python: >=3.14.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pydantic>=2.14.1
+Requires-Dist: typing_extensions>=4.16.0
+Requires-Dist: boto3>=1.43.118
+Requires-Dist: s3transfer>=0.19.3
+Dynamic: license-file
+
+# PyWhales
+
+------------------------------------------------------------------------
+
+[![Run tests](https://github.com/MaraClaw/PyWhales/actions/workflows/python-package.yml/badge.svg)](https://github.com/MaraClaw/PyWhales/actions/workflows/python-package.yml)
+[![Code style: Ruff](https://img.shields.io/badge/code%20style-Ruff-261230.svg)](https://docs.astral.sh/ruff/)
+[![Types: ty](https://img.shields.io/badge/types-ty-261230.svg)](https://docs.astral.sh/ty/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/MaraClaw/PyWhales/blob/HEAD/LICENSE)
+
+------------------------------------------------------------------------
+The Docker and its composer client for Python, designed to be fun and intuitive!
+
+Works on Linux, macOS and Windows, for Python 3.14.8 and above.
+
+* [Documentation](https://github.com/MaraClaw/PyWhales/tree/HEAD/docs)
+* [GitHub repository](https://github.com/MaraClaw/PyWhales)
+
+------------------------------------------------------------------------
+
+## How to install?
+
+```bash
+uv pip install pywhales
+```
+
+See [the Docker CLI guide](https://github.com/MaraClaw/PyWhales/blob/HEAD/docs/template/docker_client.md#the-docker-cli)
+for instructions on installing Docker.
+
+## Some cool examples
+
+Start by doing
+
+```python
+from pywhales import docker
+```
+
+and then:
+
+* `docker run hello-world` -> `docker.run("hello-world")`
+* `docker pull ubuntu` -> `docker.pull("ubuntu")`
+* `docker build ./` -> `docker.build("./")`
+* `docker compose up my_service` -> `docker.compose.up(["my_service"])`
+* `docker image ls` -> `docker.image.list()`
+* `docker ps` -> `docker.ps()`
+* `docker cp` -> `docker.copy()`
+
+```python
+>>> from pywhales import docker
+
+>>> output = docker.run("hello-world")
+>>> print(output)
+
+Hello from Docker!
+This message shows that your installation appears to be working correctly.
+
+...
+```
+
+```python
+>>> from pywhales import docker
+>>> my_image = docker.build(".", tags="some_name")  # uses Buildx/buildkit by default
+[+] Building 1.6s (17/17) FINISHED
+...
+```
+
+## Some more `docker.run()` advanced examples with postgres
+
+```bash
+docker run --name some-postgres -e POSTGRES_PASSWORD=mysecretpassword -d postgres
+```
+
+becomes
+
+```python
+from pywhales import docker
+
+docker.run(
+    "postgres:9.6",
+    name="some-postgres",
+    envs={"POSTGRES_PASSWORD": "mysecretpassword"},
+    detach=True,
+)
+print(docker.ps())
+# [pywhales.Container(id='f5fb939c409d', name='some-postgres')]
+```
+
+-----
+
+```bash
+docker run -it --rm --network some-network postgres psql -h some-postgres -U postgres
+```
+
+becomes
+
+```python
+from pywhales import docker
+
+# since it's interactive, you'll be dropped into the psql shell. The python code
+# will continue only after you exit the shell.
+docker.run(
+    "postgres:9.6",
+    ["psql", "-h", "some-postgres", "-U", "postgres"],
+    networks=["some-network"],
+    interactive=True,
+    tty=True,
+    remove=True,
+)
+```
+
+----------
+
+```bash
+docker run -d --name some-postgres -e POSTGRES_PASSWORD=mysecretpassword -e PGDATA=/var/lib/postgresql/data/pgdata -v /custom/mount:/var/lib/postgresql/data -v myvolume:/tmp/myvolume postgres -c shared_buffers=256MB -c max_connections=200
+```
+
+becomes
+
+```python
+from pywhales import docker
+
+docker.run(
+    "postgres:9.6",
+    ["-c", "shared_buffers=256MB", "-c", "max_connections=200"],
+    name="some-postgres",
+    envs={
+        "POSTGRES_PASSWORD": "mysecretpassword",
+        "PGDATA": "/var/lib/postgresql/data/pgdata",
+    },
+    volumes=[
+        ("/custom/mount", "/var/lib/postgresql/data"),
+        ("myvolume", "/tmp/myvolume"),
+    ],
+    detach=True,
+)
+```
+
+
+Any Docker object can be used as a context manager to ensure it's removed even if an exception occurs:
+
+```python
+from pywhales import docker
+
+with docker.volume.create("random_name") as some_volume:
+    docker.run(
+        "postgres:9.6",
+        ["-c", "shared_buffers=256MB", "-c", "max_connections=200"],
+        name="some-postgres",
+        envs={
+            "POSTGRES_PASSWORD": "mysecretpassword",
+            "PGDATA": "/var/lib/postgresql/data/pgdata",
+        },
+        volumes=[
+            (some_volume, "/var/lib/postgresql/data"),
+            ("myvolume", "/tmp/myvolume"),
+        ],
+        detach=True,
+    )
+    # so some stuff here
+
+# here we are out of the context manager, so the volume has been removed, even if there was an exception.
+```
+
+## Main features
+
+* 1 to 1 mapping between the CLI interface and the Python API. No need to look in the docs
+what is the name of the function/argument you need.
+* Support for the latest Docker features:
+[Docker buildx/buildkit](https://github.com/docker/buildx),
+`docker run --gpu=all ...`
+* Support for Docker stack, services and Swarm (same API as the command line).
+* Progress bars and progressive outputs when pulling, pushing, loading, building...
+* Support for some other CLI commands that are not in [Docker-py](https://docker-py.readthedocs.io/en/stable/):
+`docker cp`, `docker run --cpus ...` and more.
+* Nice SSH support for remote daemons.
+* Docker object as Python objects: Container, Images, Volumes, Services... and their
+attributes are updated in real-time!
+* Each Docker object can be used as a context manager. When getting out of the
+context, the Docker object is removed automatically, even if an exception occurs.
+* A fully typed API (ty and IDE-friendly) compatible with `pathlib` and `os.path`
+* All Docker objects and the Docker client are safe to use with multithreading and multiprocessing.
+* Display the commands called and the environment variables used by setting `PYDOCKER_DEBUG=1`.
+  The legacy `PYTHON_ON_WHALES_DEBUG` variable is a fallback only when `PYDOCKER_DEBUG` is unset.
+  Setting `PYDOCKER_DEBUG=0` or leaving its value explicitly empty disables debug output even if the legacy variable is set.
+
+## What about the license?
+
+It's a MIT license, so quite permissive.
+
+The license can be found [in the git repository](https://github.com/MaraClaw/PyWhales/blob/HEAD/LICENSE).

pywhales-0.2.1/README.md

@@ -0,0 +1,189 @@
+# PyWhales
+
+------------------------------------------------------------------------
+
+[![Run tests](https://github.com/MaraClaw/PyWhales/actions/workflows/python-package.yml/badge.svg)](https://github.com/MaraClaw/PyWhales/actions/workflows/python-package.yml)
+[![Code style: Ruff](https://img.shields.io/badge/code%20style-Ruff-261230.svg)](https://docs.astral.sh/ruff/)
+[![Types: ty](https://img.shields.io/badge/types-ty-261230.svg)](https://docs.astral.sh/ty/)
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/MaraClaw/PyWhales/blob/HEAD/LICENSE)
+
+------------------------------------------------------------------------
+The Docker and its composer client for Python, designed to be fun and intuitive!
+
+Works on Linux, macOS and Windows, for Python 3.14.8 and above.
+
+* [Documentation](https://github.com/MaraClaw/PyWhales/tree/HEAD/docs)
+* [GitHub repository](https://github.com/MaraClaw/PyWhales)
+
+------------------------------------------------------------------------
+
+## How to install?
+
+```bash
+uv pip install pywhales
+```
+
+See [the Docker CLI guide](https://github.com/MaraClaw/PyWhales/blob/HEAD/docs/template/docker_client.md#the-docker-cli)
+for instructions on installing Docker.
+
+## Some cool examples
+
+Start by doing
+
+```python
+from pywhales import docker
+```
+
+and then:
+
+* `docker run hello-world` -> `docker.run("hello-world")`
+* `docker pull ubuntu` -> `docker.pull("ubuntu")`
+* `docker build ./` -> `docker.build("./")`
+* `docker compose up my_service` -> `docker.compose.up(["my_service"])`
+* `docker image ls` -> `docker.image.list()`
+* `docker ps` -> `docker.ps()`
+* `docker cp` -> `docker.copy()`
+
+```python
+>>> from pywhales import docker
+
+>>> output = docker.run("hello-world")
+>>> print(output)
+
+Hello from Docker!
+This message shows that your installation appears to be working correctly.
+
+...
+```
+
+```python
+>>> from pywhales import docker
+>>> my_image = docker.build(".", tags="some_name")  # uses Buildx/buildkit by default
+[+] Building 1.6s (17/17) FINISHED
+...
+```
+
+## Some more `docker.run()` advanced examples with postgres
+
+```bash
+docker run --name some-postgres -e POSTGRES_PASSWORD=mysecretpassword -d postgres
+```
+
+becomes
+
+```python
+from pywhales import docker
+
+docker.run(
+    "postgres:9.6",
+    name="some-postgres",
+    envs={"POSTGRES_PASSWORD": "mysecretpassword"},
+    detach=True,
+)
+print(docker.ps())
+# [pywhales.Container(id='f5fb939c409d', name='some-postgres')]
+```
+
+-----
+
+```bash
+docker run -it --rm --network some-network postgres psql -h some-postgres -U postgres
+```
+
+becomes
+
+```python
+from pywhales import docker
+
+# since it's interactive, you'll be dropped into the psql shell. The python code
+# will continue only after you exit the shell.
+docker.run(
+    "postgres:9.6",
+    ["psql", "-h", "some-postgres", "-U", "postgres"],
+    networks=["some-network"],
+    interactive=True,
+    tty=True,
+    remove=True,
+)
+```
+
+----------
+
+```bash
+docker run -d --name some-postgres -e POSTGRES_PASSWORD=mysecretpassword -e PGDATA=/var/lib/postgresql/data/pgdata -v /custom/mount:/var/lib/postgresql/data -v myvolume:/tmp/myvolume postgres -c shared_buffers=256MB -c max_connections=200
+```
+
+becomes
+
+```python
+from pywhales import docker
+
+docker.run(
+    "postgres:9.6",
+    ["-c", "shared_buffers=256MB", "-c", "max_connections=200"],
+    name="some-postgres",
+    envs={
+        "POSTGRES_PASSWORD": "mysecretpassword",
+        "PGDATA": "/var/lib/postgresql/data/pgdata",
+    },
+    volumes=[
+        ("/custom/mount", "/var/lib/postgresql/data"),
+        ("myvolume", "/tmp/myvolume"),
+    ],
+    detach=True,
+)
+```
+
+
+Any Docker object can be used as a context manager to ensure it's removed even if an exception occurs:
+
+```python
+from pywhales import docker
+
+with docker.volume.create("random_name") as some_volume:
+    docker.run(
+        "postgres:9.6",
+        ["-c", "shared_buffers=256MB", "-c", "max_connections=200"],
+        name="some-postgres",
+        envs={
+            "POSTGRES_PASSWORD": "mysecretpassword",
+            "PGDATA": "/var/lib/postgresql/data/pgdata",
+        },
+        volumes=[
+            (some_volume, "/var/lib/postgresql/data"),
+            ("myvolume", "/tmp/myvolume"),
+        ],
+        detach=True,
+    )
+    # so some stuff here
+
+# here we are out of the context manager, so the volume has been removed, even if there was an exception.
+```
+
+## Main features
+
+* 1 to 1 mapping between the CLI interface and the Python API. No need to look in the docs
+what is the name of the function/argument you need.
+* Support for the latest Docker features:
+[Docker buildx/buildkit](https://github.com/docker/buildx),
+`docker run --gpu=all ...`
+* Support for Docker stack, services and Swarm (same API as the command line).
+* Progress bars and progressive outputs when pulling, pushing, loading, building...
+* Support for some other CLI commands that are not in [Docker-py](https://docker-py.readthedocs.io/en/stable/):
+`docker cp`, `docker run --cpus ...` and more.
+* Nice SSH support for remote daemons.
+* Docker object as Python objects: Container, Images, Volumes, Services... and their
+attributes are updated in real-time!
+* Each Docker object can be used as a context manager. When getting out of the
+context, the Docker object is removed automatically, even if an exception occurs.
+* A fully typed API (ty and IDE-friendly) compatible with `pathlib` and `os.path`
+* All Docker objects and the Docker client are safe to use with multithreading and multiprocessing.
+* Display the commands called and the environment variables used by setting `PYDOCKER_DEBUG=1`.
+  The legacy `PYTHON_ON_WHALES_DEBUG` variable is a fallback only when `PYDOCKER_DEBUG` is unset.
+  Setting `PYDOCKER_DEBUG=0` or leaving its value explicitly empty disables debug output even if the legacy variable is set.
+
+## What about the license?
+
+It's a MIT license, so quite permissive.
+
+The license can be found [in the git repository](https://github.com/MaraClaw/PyWhales/blob/HEAD/LICENSE).

pywhales-0.2.1/docs/requirements.txt

@@ -0,0 +1,11 @@
+astunparse==1.6.3
+griffe==1.2.0
+markdown==3.7
+markupsafe==2.1.5
+mkdocs==1.6.1
+mkdocs-autorefs==1.1.0
+mkdocs-get-deps==0.2.0
+mkdocs-material==9.5.34
+mkdocstrings==0.25.2
+mkdocstrings-python==1.10.9
+pymdown-extensions==10.9

pywhales-0.2.1/docs/template/docker_client.md

@@ -0,0 +1,116 @@
+# The Docker client object
+
+
+{{autogenerated}}
+
+## Sub-commands
+
+* [`docker.buildx`](sub-commands/buildx.md)
+* [`docker.compose`](sub-commands/compose.md)
+* [`docker.config`](sub-commands/config.md)
+* [`docker.container`](sub-commands/container.md)
+* [`docker.context`](sub-commands/context.md)
+* [`docker.image`](sub-commands/image.md)
+* [`docker.manifest`](sub-commands/manifest.md)
+* [`docker.network`](sub-commands/network.md)
+* [`docker.node`](sub-commands/node.md)
+* [`docker.secret`](sub-commands/secret.md)
+* [`docker.service`](sub-commands/service.md)
+* [`docker.stack`](sub-commands/stack.md)
+* [`docker.swarm`](sub-commands/swarm.md)
+* [`docker.system`](sub-commands/system.md)
+* [`docker.trust`](sub-commands/trust.md)
+* [`docker.volume`](sub-commands/volume.md)
+
+
+## Other commands
+
+They're actually aliases
+
+* [`docker.attach`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.attach)
+* [`docker.build`](sub-commands/buildx.md#pywhales.components.buildx.cli_wrapper.BuildxCLI.build)
+* [`docker.commit`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.commit)
+* [`docker.copy`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.copy)
+* [`docker.create`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.create)
+* [`docker.diff`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.diff)
+* [`docker.execute`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.execute)
+* [`docker.export`](sub-commands/container.md#pywhales.components.image.cli_wrapper.ImageCLI.export)
+* [`docker.images`](sub-commands/image.md#pywhales.components.image.cli_wrapper.ImageCLI.list)
+* [`docker.import_`](sub-commands/image.md#pywhales.components.image.cli_wrapper.ImageCLI.import_)
+* [`docker.info`](sub-commands/system.md#pywhales.components.system.cli_wrapper.SystemCLI.info)
+* [`docker.kill`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.kill)
+* [`docker.load`](sub-commands/image.md#pywhales.components.image.cli_wrapper.ImageCLI.load)
+* [`docker.logs`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.logs)
+* [`docker.pause`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.pause)
+* [`docker.ps`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.list)
+* [`docker.pull`](sub-commands/image.md#pywhales.components.image.cli_wrapper.ImageCLI.pull)
+* [`docker.push`](sub-commands/image.md#pywhales.components.image.cli_wrapper.ImageCLI.push)
+* [`docker.rename`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.rename)
+* [`docker.restart`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.rename)
+* [`docker.remove`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.rename)
+* [`docker.run`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.rename)
+* [`docker.save`](sub-commands/image.md#pywhales.components.image.cli_wrapper.ImageCLI.save)
+* [`docker.start`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.start)
+* [`docker.stats`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.stats)
+* [`docker.stop`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.stop)
+* [`docker.tag`](sub-commands/image.md#pywhales.components.image.cli_wrapper.ImageCLI.tag)
+* [`docker.top`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.top)
+* [`docker.unpause`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.unpause)
+* [`docker.update`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.update)
+* [`docker.wait`](sub-commands/container.md#pywhales.components.container.cli_wrapper.ContainerCLI.wait)
+
+
+## About multithreading and multiprocessing
+
+Behind the scenes, pywhales calls the Docker command line interface with
+subprocess. The pywhales client does not store any intermediate state so it's safe
+to use with multithreading. 
+
+The Docker objects store some intermediate states (the attributes 
+that you would normally get with `docker ... inspect`but no logic in 
+the codebase depends on those attributes. They're just here so that users can look at them. 
+So you can share them between process/threads and pickle containers, images, networks...
+
+The Docker daemon works with its own objects internally and handles concurrent and conflicting requests. 
+For example, if you create two containers with the same name from different threads, only one will 
+succeed. If you pull the same docker image from multiple processes/threads, the Docker daemon will 
+only pull the image and layers once.
+
+Just be careful with some scenario similar to this one
+
+```
+Thread 1: my_container = docker.run(..., detach=True)
+...
+# my_container finishes
+...
+Thread 2: docker.container.prune()
+...
+Thread 1: docker.logs(my_container)  # will fail because the container was removed by thread 2
+```
+
+In the end, unless you use this type of logic in your code, 
+pywhales is safe to use with multithreading and multiprocessing.
+
+
+## The Docker CLI
+
+pywhales needs the Docker CLI to work (unlike docker-py).
+Most of the time, users already have the CLI installed on their machines. It's possible to 
+verify that the CLI is there by doing `docker --help` in the command line.
+
+Sometimes, the CLI might not be available on the system, it can happen if you want to control
+Docker from within a container with `-v /var/run/docker.sock:/var/run/docker.sock`, or if you
+want to connect to a remote daemon with the `host` argument.
+
+Instructions for installing Docker can be found at <https://docs.docker.com/engine/install/>.
+Note that if connecting to Docker remotely then a local Docker daemon (`dockerd`) is not needed.
+
+Previously, when using python-on-whales, the Docker CLI was downloaded automatically, but
+this functionality was removed under <https://github.com/gabrieldemarmiesse/python-on-whales/pull/633>.
+
+
+### Handling an unavailable client
+
+Trying to use pywhales when it cannot find a Docker client binary
+will trigger a `pywhales.ClientNotFoundError`. You can use a try-except around
+a first `docker.ps()` call to handle the case when pywhales won't work.

pywhales-0.2.1/docs/template/index.md

@@ -0,0 +1 @@
+--8<-- "README.md"

pywhales-0.2.1/docs/template/objects/builders.md

@@ -0,0 +1,41 @@
+# Docker builders
+
+The Buildx builders objects.
+
+Don't use the constructor directly. Instead use 
+```python
+from pywhales import docker
+
+my_builder = docker.buildx.inspect("my-builder")
+
+# or
+
+my_builder = docker.buildx.create()
+```
+For type hints, use this
+
+```python
+from pywhales import Builder
+```
+
+## Attributes
+
+The attributes are the same as with the command line:
+`docker buildx inspect ...`
+
+Only a few are available at the moment
+```
+In [1]: from pywhales import docker
+
+In [2]: my_builder = docker.buildx.create()
+
+In [4]: def super_print(obj):
+   ...:     print(f"type={type(obj)}, value={obj}")
+   ...:
+
+@INSERT_GENERATED_CODE@
+```
+
+## Methods
+
+{{autogenerated}}

pywhales-0.2.1/docs/template/objects/configs.md

@@ -0,0 +1,51 @@
+# Docker configs
+
+Configs objects present in Swarm mode
+
+Don't use the constructor directly. Instead use 
+```python
+from pywhales import docker
+
+my_config = docker.config.inspect("my-config-name")
+
+# or
+
+my_config = docker.config.create("my_config_name", "my_config_file")
+```
+For type hints, use this
+
+```python
+from pywhales import Config
+
+
+def print_config_labels(config: Config):
+    print(config.spec.labels)
+```
+
+
+## Attributes
+
+The attributes are the same as with the command line:
+`docker config inspect ...`
+
+To get a complete description of those attributes, you 
+can take a look at the [daemon api reference page](https://docs.docker.com/engine/api/v1.40/#operation/ConfigInspect) 
+and click on "200 No error".
+
+An example is worth many lines of descriptions.
+
+```
+In [1]: from pywhales import docker
+
+In [2]: config = docker.config.create("my_config", "./config_file.cfg", labels=dict(hello="world"))
+
+In [3]: def super_print(obj):
+   ...:     print(f"type={type(obj)}, value={obj}")
+   ...:
+
+@INSERT_GENERATED_CODE@
+```
+
+## Methods
+
+{{autogenerated}}