| Name | dent JSON |
| Version |
1.0.0
JSON |
| download |
| home_page | None |
| Summary | Enter interactive shells in Docker containers and manage persistent containers |
| upload_time | 2024-08-29 15:09:37 |
| maintainer | None |
| docs_url | None |
| author | None |
| requires_python | >=3.8 |
| license | None |
| keywords |
|
| VCS |
 |
| bugtrack_url |
|
| requirements |
No requirements were recorded.
|
| Travis-CI |
No Travis.
|
| coveralls test coverage |
No coveralls.
|
`dent`: Create and Enter Docker Containers
==========================================
`dent` ("Docker ENTer") starts a new process (by default an
interactive command line) in a Docker container, creating the
container and even an image if necessary.
One use of this is simply to start one or more command lines (or run
commands) in an existing container or a new container based on an
arbitrary image. This can be used to debug an application running in a
container or explore the contents of a container or image.
Another use is to create and start containers designed to be
persistent (kept and reused for some time) and used for interactive
work at a shell prompt as a regular (non-root) user. Containers like
this are useful for:
- Development and testing of techniques, scripts and applications
under different Linux distributions and versions.
- Testing system setup and other sysadmin tools.
- Providing a safe environment for sharing terminals with [tmate] or
similar programs, where you don't want others to have access to
files in your account, SSH keys in agents, and possibly root access
to your host.
Images and containers are created as necessary. When `dent` creates a
new image from a base image it will add:
- A Unix account with the current user's UID and login name.
- A few important basic packages and some configuration for
interactive use (see below).
- The latest updates for of all packages.
Images created by `dent` include only a minimal set of the most
essential packages (UTF-8 locales, sudo, etc.), those without which
it's fairly inconvenient to install further packages or do very basic
work. If you frequently need more than this, you should use other
systems for further configuring hosts. (`dent` is of course excellent
help with testing these.)
Use of Docker
-------------
This script calls the `docker` command (which must be in the path) for
all communications with the Docker daemon. Security-minded admins will
not put users into the `docker` group (because this is a less-obvious
way of [giving them full root access][root] on the Docker host) but
instead make users' access explicit by allowing them to `sudo` to
root. `dent` handles this by running `sudo docker` instead of `docker`
if it detects that the current user doesn't have access to the Docker
daemon's socket.
`dent` uses the `docker` command for all interaction with the Docker
daemon. Certain operations are more easily done with the Python Docker
API, but others are not and adding a dependency on the [Docker SDK for
Python][py-docker] only to write significantly more code didn't seem
worthwhile.
Installation
------------
`dent` is can be installed from [PyPI][pi-dent], or intalled or cloned from
[GitHub][gh-dent].
Basic install:
pip install dent
dent --help
Using [pactivate]'s `pae`:
pae -c dent dent
pae dent --help
Using [pipx]:
pipx run dent --help
From GitHub:
pip install dent@git+https://github.com/cynic-net/dent@refs/heads/dev/cjs/24h05/pypi-package
dent --help
Operation Overview
------------------
The end result achieved by `dent` is to run a command (by default, a
login shell) as a new process in a running container. There are
several other things that must have already been done before this can
happen; these dependencies are described here in reverse order. `dent`
does not know or care whether dependent steps (e.g., ensuring a
container or image exists) were done by itself or via other means such
as manual `docker` commands run by the user.
1. __Entering a Running Container__
`dent CNAME` will confirm there is a running container named
_CNAME_ and execute `docker exec -it CNAME bash -l` or similar,
starting a new process inside the container. Separating container
startup (`docker run`) from running further commands in the
container using `docker exec` simplifies running multiple commands
in the container at the same time.
Dent changes `docker exec`'s detach key sequence (which you normally
would not use when using dent) from the default of `ctrl-p,ctrl-q` to
`ctrl-@,ctrl-d`. This avoids the annoying "hold" of `ctrl-p` until
another character is typed. This currently cannot be overridden.
2. __Starting the Container__
If container _CNAME_ exists but is not running, it must be started
before `docker exec` can be used. This is done by running `docker
start CNAME`, which restarts it with the command originally
supplied to `docker run`. This command must keep the container
running as long as you want to run commands in it with `docker
exec`. The container creation logic below handles this;
user-created containers must ensure that their command doesn't exit
immediately.
3. __Creating the Container__
If no container _CNAME_ exists, it must be created with `docker
run`. To do this, either an existing image name must be supplied
with `-i IMAGE` or a base image from which to build an image (if
not already built) must be supplied with `-B BASE_IMAGE`. See below
for more on this.
The command run in the container will be `/bin/sleep $((2^30))`; this
will leave the container "running" but doing nothing. (Any work done
in the container is done by commands run in part 1 above.)
Note that the configuration of a container (initial command, bind
mounts, etc.) is fixed when the container is created; if the container
is stopped or exits and it later restarted with `docker start CNAME`,
the configuration will be that set up with the original `docker run`.
Thus, any `-B`/`--base-image` and `-r`/`--run-opts` command line options
can have effect only at container creation time.
4. __Creating the Image__
The name of the image is specified with `-i IMAGE`; if that is not
supplied a default name and tag is generated based on the base
image name given to `-B BASE_IMAGE` and the login name of the user
running `dent`. (The image tag may be overridden with `-t TAG`.) If
an image with that name does not exist, one will be built with a
configuration designed for interactive use as the user running `dent`.
If the given image does exist, the `-R` or `--force-rebuild` flag can
be used to untag that image and do a full image build, ignoring any
cached layers. The previous image will remain as an unnamed image if
any containers exist that were created from it; that image can be
removed with `docker image prune` after removing those containers.
For the full details of how `dent` builds and sets up the image,
see the `DOCKERFILE` and the setup script `SETUP_IMAGE` in the
`dent` source code. Here we briefly describe its general function.
1. __Package setup.__ The base image is assumed to have `apt` or `yum`
available and be configured to connect to a source of packages
commonly used in interactive sessions. This is tested on some
common versions of Debian, Ubuntu, CentOS, and Fedora.
- Install git and etckeeper (on systems with apt).
- Update the package database
- Install a minimal set of packages for interactive use: sudo,
curl, vim, git, etc.
2. __User setup.__ A user will be created (using `useradd`) with the same
name, uid and groups as the user running `dent`. Sudo will be
configured to let this user sudo to root without using a password.
The image's default user and working directory will be configured
to this user and her home directory.
`dent` is not designed to be able to build the above image from any
type of base image. If you have a base image that doesn't work with
the setup script, it's probably best just to build by hand an
appropriate image for creating containers and use it with the `-i
IMAGE` option. (Ideas for making the setup script more general are
welcome.)
Usage
-----
This section may not be entirely clear if you've not read the
"Operation Overview" section above.
#### Arguments
* `dent [options] CONTAINER_NAME [--] [COMMAND [arg ...]]`
Runs the given _COMMAND_ in container _CONTAINER_NAME_ using `docker
exec -it CONTAINER_NAME` or similar. If you supply any _arg_ values
that start with a hyphen, ensure you use the `--` after the container
name to avoid these being parsed as options to `dent`.
_CONTAINER_NAME_ is a container name or ID. An existing container with
that name will always be used if present (it will be started if it's
stopped), otherwise it's the name of the container to be created. If
you share the host with other users, you may want to adopt a container
naming convention to avoid name collisions. `dent` currently provides
no support for this; it uses the container name exactly as specified.
The default _COMMAND_ is `bash -l` to give an interactive login shell.
Curently _COMMAND_ is always run directly, without a login
environment. To run a single command in your login environment (e.g.,
to use a shell alias) use `-- bash -lc 'cmd arg ...'`.
The user and initial working directory within the container will be
the same as specified by the `docker run` command; this is specified
by the image if `dent` created the container. There is currently no
way to override this.
Notes on `docker exec` options:
- The `-t` option (allocate a pseudo-TTY) will be used only if stdin
is a terminal. There is currently no way to override this.
- The `-i` option (keep stdin open when detached) is always used;
there seems to be no reason ever not to use it because `dent`
currently does not support `-d` (detached mode).
#### Options
No container command is run if either of the following two options are
given:
* `-h`, `--help`: Ignore all other arguments and print a usage
summary.
* `-L`, `--list-base-images`: List base images `dent` knows it can use
to create working interactive images. For somewhat silly reasons,
this still requires a _CNAME_ argument, which is ignored.
The following options control the behaviour of `dent`:
* `-q, --quiet`: Do not print informational lines indicating what Docker
image and container actions (remove/build/create) are being taken and use
`docker build --quiet` when building an image.
* `-n, --dry-run`: For commands that would change or execute Docker images
or containers (including `rmi`, `build`, `run` and `exec`), just print
the command to stderr. (Unless you use `-q`, the usual user-oriented
messages about actions to be taken will still appear on stdout.) Build
configuration is still created, so `--keep-tmpdir` still works. As well
as testing, this can also be useful to customize image and container
creation by printing the command that would be executed and then
executing it by hand with different options.
The following options control which image is used and building of the
image:
* `-i IMAGE, --image IMAGE`: Name of image from which the container
will be created, if necessary. Has a default value only if `-b` is
specified.
* `-t TAG, --tag TAG`: Tag for image if `-i` is not specified. (With
`-i`, specify the tag with the image name in `name:tag` format.) The
default tag used by `-B` is the user's login name.
* `-B BASE_IMAGE`, `--base-image BASE_IMAGE`: Base image from which to
build container image if container image (default name or specified
with `-i`) does not exist.
* `-R, --force-rebuild`: When building an image, ignore any existing
layers that would be considered "cached" and reused, rebuilding
every layer in the `Dockerfile` from scratch. (I.e., use `docker
build --no-cache`.)
The following optons control container creation:
* `-r RUN_OPT`, `--run-opt RUN_OPT`: Add options to pass to `docker run` at
container creation. These are _not_ split the way the shell does, so
`-r "-e FOO=bar"` will not work; it will pass `-e FOO=bar` as a single
argument rather than two arguments to `docker run`. Instead, use
`-r -e=FOO=bar`.
Note also that `-r` can be used _only_ when `dent` is creating a new
container. If it finds an existing container that it would use, it
will generate an error explaining that the `-r` option would have
no effect.
The following options are used mainly for development and debugging:
* `--tmpdir TMPDIR`: The directory to use for the Docker build context
when building an image. Default is a `mkdtmp` name under `/tmp`.
* `--keep-tmpdir`: If a new image is built from a base image, do not
remove the temporary directory containing the `Dockerfile` and the
build context. The name of the directory is printed in a message at
the start of the build. (This message is not suppressed by `-q`.)
<!-------------------------------------------------------------------->
[tmate]: https://tmate.io/
[py-docker]: https://pypi.org/project/docker/
[root]: https://github.com/0cjs/sedoc/blob/master/docker/security.md#leveraging-docker-for-root-access
[gh-dent]: https://github.com/cynic-net/dent
[pactivate]: https://github.com/cynic-net/pactivate
[pi-dent]: https://pypi.org/project/dent
[pipx]: https://pipx.pypa.io/
Raw data
{
"_id": null,
"home_page": null,
"name": "dent",
"maintainer": null,
"docs_url": null,
"requires_python": ">=3.8",
"maintainer_email": null,
"keywords": null,
"author": null,
"author_email": "\"Curt J. Sampson\" <cjs@cynic.net>, Nishant Rodrigues <nishantjr@gmail.com>",
"download_url": "https://files.pythonhosted.org/packages/f3/9d/1ac24cb11584a03ed466828dbb82159ceb6295de838e55b369ac3739fd9d/dent-1.0.0.tar.gz",
"platform": null,
"description": "`dent`: Create and Enter Docker Containers\n==========================================\n\n`dent` (\"Docker ENTer\") starts a new process (by default an\ninteractive command line) in a Docker container, creating the\ncontainer and even an image if necessary.\n\nOne use of this is simply to start one or more command lines (or run\ncommands) in an existing container or a new container based on an\narbitrary image. This can be used to debug an application running in a\ncontainer or explore the contents of a container or image.\n\nAnother use is to create and start containers designed to be\npersistent (kept and reused for some time) and used for interactive\nwork at a shell prompt as a regular (non-root) user. Containers like\nthis are useful for:\n- Development and testing of techniques, scripts and applications\n under different Linux distributions and versions.\n- Testing system setup and other sysadmin tools.\n- Providing a safe environment for sharing terminals with [tmate] or\n similar programs, where you don't want others to have access to\n files in your account, SSH keys in agents, and possibly root access\n to your host.\n\nImages and containers are created as necessary. When `dent` creates a\nnew image from a base image it will add:\n- A Unix account with the current user's UID and login name.\n- A few important basic packages and some configuration for\n interactive use (see below).\n- The latest updates for of all packages.\n\nImages created by `dent` include only a minimal set of the most\nessential packages (UTF-8 locales, sudo, etc.), those without which\nit's fairly inconvenient to install further packages or do very basic\nwork. If you frequently need more than this, you should use other\nsystems for further configuring hosts. (`dent` is of course excellent\nhelp with testing these.)\n\n\nUse of Docker\n-------------\n\nThis script calls the `docker` command (which must be in the path) for\nall communications with the Docker daemon. Security-minded admins will\nnot put users into the `docker` group (because this is a less-obvious\nway of [giving them full root access][root] on the Docker host) but\ninstead make users' access explicit by allowing them to `sudo` to\nroot. `dent` handles this by running `sudo docker` instead of `docker`\nif it detects that the current user doesn't have access to the Docker\ndaemon's socket.\n\n`dent` uses the `docker` command for all interaction with the Docker\ndaemon. Certain operations are more easily done with the Python Docker\nAPI, but others are not and adding a dependency on the [Docker SDK for\nPython][py-docker] only to write significantly more code didn't seem\nworthwhile.\n\n\nInstallation\n------------\n\n`dent` is can be installed from [PyPI][pi-dent], or intalled or cloned from\n[GitHub][gh-dent].\n\nBasic install:\n\n pip install dent\n dent --help\n\nUsing [pactivate]'s `pae`:\n\n pae -c dent dent\n pae dent --help\n\nUsing [pipx]:\n\n pipx run dent --help\n\nFrom GitHub:\n\n pip install dent@git+https://github.com/cynic-net/dent@refs/heads/dev/cjs/24h05/pypi-package\n dent --help\n\n\nOperation Overview\n------------------\n\nThe end result achieved by `dent` is to run a command (by default, a\nlogin shell) as a new process in a running container. There are\nseveral other things that must have already been done before this can\nhappen; these dependencies are described here in reverse order. `dent`\ndoes not know or care whether dependent steps (e.g., ensuring a\ncontainer or image exists) were done by itself or via other means such\nas manual `docker` commands run by the user.\n\n1. __Entering a Running Container__\n\n `dent CNAME` will confirm there is a running container named\n _CNAME_ and execute `docker exec -it CNAME bash -l` or similar,\n starting a new process inside the container. Separating container\n startup (`docker run`) from running further commands in the\n container using `docker exec` simplifies running multiple commands\n in the container at the same time.\n\n Dent changes `docker exec`'s detach key sequence (which you normally\n would not use when using dent) from the default of `ctrl-p,ctrl-q` to\n `ctrl-@,ctrl-d`. This avoids the annoying \"hold\" of `ctrl-p` until\n another character is typed. This currently cannot be overridden.\n\n2. __Starting the Container__\n\n If container _CNAME_ exists but is not running, it must be started\n before `docker exec` can be used. This is done by running `docker\n start CNAME`, which restarts it with the command originally\n supplied to `docker run`. This command must keep the container\n running as long as you want to run commands in it with `docker\n exec`. The container creation logic below handles this;\n user-created containers must ensure that their command doesn't exit\n immediately.\n\n3. __Creating the Container__\n\n If no container _CNAME_ exists, it must be created with `docker\n run`. To do this, either an existing image name must be supplied\n with `-i IMAGE` or a base image from which to build an image (if\n not already built) must be supplied with `-B BASE_IMAGE`. See below\n for more on this.\n\n The command run in the container will be `/bin/sleep $((2^30))`; this\n will leave the container \"running\" but doing nothing. (Any work done\n in the container is done by commands run in part 1 above.)\n\n Note that the configuration of a container (initial command, bind\n mounts, etc.) is fixed when the container is created; if the container\n is stopped or exits and it later restarted with `docker start CNAME`,\n the configuration will be that set up with the original `docker run`.\n Thus, any `-B`/`--base-image` and `-r`/`--run-opts` command line options\n can have effect only at container creation time.\n\n4. __Creating the Image__\n\n The name of the image is specified with `-i IMAGE`; if that is not\n supplied a default name and tag is generated based on the base\n image name given to `-B BASE_IMAGE` and the login name of the user\n running `dent`. (The image tag may be overridden with `-t TAG`.) If\n an image with that name does not exist, one will be built with a\n configuration designed for interactive use as the user running `dent`.\n\n If the given image does exist, the `-R` or `--force-rebuild` flag can\n be used to untag that image and do a full image build, ignoring any\n cached layers. The previous image will remain as an unnamed image if\n any containers exist that were created from it; that image can be\n removed with `docker image prune` after removing those containers.\n\n For the full details of how `dent` builds and sets up the image,\n see the `DOCKERFILE` and the setup script `SETUP_IMAGE` in the\n `dent` source code. Here we briefly describe its general function.\n\n 1. __Package setup.__ The base image is assumed to have `apt` or `yum`\n available and be configured to connect to a source of packages\n commonly used in interactive sessions. This is tested on some\n common versions of Debian, Ubuntu, CentOS, and Fedora.\n - Install git and etckeeper (on systems with apt).\n - Update the package database\n - Install a minimal set of packages for interactive use: sudo,\n curl, vim, git, etc.\n\n 2. __User setup.__ A user will be created (using `useradd`) with the same\n name, uid and groups as the user running `dent`. Sudo will be\n configured to let this user sudo to root without using a password.\n The image's default user and working directory will be configured\n to this user and her home directory.\n\n `dent` is not designed to be able to build the above image from any\n type of base image. If you have a base image that doesn't work with\n the setup script, it's probably best just to build by hand an\n appropriate image for creating containers and use it with the `-i\n IMAGE` option. (Ideas for making the setup script more general are\n welcome.)\n\n\nUsage\n-----\n\nThis section may not be entirely clear if you've not read the\n\"Operation Overview\" section above.\n\n#### Arguments\n\n* `dent [options] CONTAINER_NAME [--] [COMMAND [arg ...]]`\n\nRuns the given _COMMAND_ in container _CONTAINER_NAME_ using `docker\nexec -it CONTAINER_NAME` or similar. If you supply any _arg_ values\nthat start with a hyphen, ensure you use the `--` after the container\nname to avoid these being parsed as options to `dent`.\n\n_CONTAINER_NAME_ is a container name or ID. An existing container with\nthat name will always be used if present (it will be started if it's\nstopped), otherwise it's the name of the container to be created. If\nyou share the host with other users, you may want to adopt a container\nnaming convention to avoid name collisions. `dent` currently provides\nno support for this; it uses the container name exactly as specified.\n\nThe default _COMMAND_ is `bash -l` to give an interactive login shell.\nCurently _COMMAND_ is always run directly, without a login\nenvironment. To run a single command in your login environment (e.g.,\nto use a shell alias) use `-- bash -lc 'cmd arg ...'`.\n\nThe user and initial working directory within the container will be\nthe same as specified by the `docker run` command; this is specified\nby the image if `dent` created the container. There is currently no\nway to override this.\n\nNotes on `docker exec` options:\n- The `-t` option (allocate a pseudo-TTY) will be used only if stdin\n is a terminal. There is currently no way to override this.\n- The `-i` option (keep stdin open when detached) is always used;\n there seems to be no reason ever not to use it because `dent`\n currently does not support `-d` (detached mode).\n\n#### Options\n\nNo container command is run if either of the following two options are\ngiven:\n* `-h`, `--help`: Ignore all other arguments and print a usage\n summary.\n* `-L`, `--list-base-images`: List base images `dent` knows it can use\n to create working interactive images. For somewhat silly reasons,\n this still requires a _CNAME_ argument, which is ignored.\n\nThe following options control the behaviour of `dent`:\n* `-q, --quiet`: Do not print informational lines indicating what Docker\n image and container actions (remove/build/create) are being taken and use\n `docker build --quiet` when building an image.\n* `-n, --dry-run`: For commands that would change or execute Docker images\n or containers (including `rmi`, `build`, `run` and `exec`), just print\n the command to stderr. (Unless you use `-q`, the usual user-oriented\n messages about actions to be taken will still appear on stdout.) Build\n configuration is still created, so `--keep-tmpdir` still works. As well\n as testing, this can also be useful to customize image and container\n creation by printing the command that would be executed and then\n executing it by hand with different options.\n\nThe following options control which image is used and building of the\nimage:\n* `-i IMAGE, --image IMAGE`: Name of image from which the container\n will be created, if necessary. Has a default value only if `-b` is\n specified.\n* `-t TAG, --tag TAG`: Tag for image if `-i` is not specified. (With\n `-i`, specify the tag with the image name in `name:tag` format.) The\n default tag used by `-B` is the user's login name.\n* `-B BASE_IMAGE`, `--base-image BASE_IMAGE`: Base image from which to\n build container image if container image (default name or specified\n with `-i`) does not exist.\n* `-R, --force-rebuild`: When building an image, ignore any existing\n layers that would be considered \"cached\" and reused, rebuilding\n every layer in the `Dockerfile` from scratch. (I.e., use `docker\n build --no-cache`.)\n\nThe following optons control container creation:\n* `-r RUN_OPT`, `--run-opt RUN_OPT`: Add options to pass to `docker run` at\n container creation. These are _not_ split the way the shell does, so\n `-r \"-e FOO=bar\"` will not work; it will pass `-e FOO=bar` as a single\n argument rather than two arguments to `docker run`. Instead, use\n `-r -e=FOO=bar`.\n\n Note also that `-r` can be used _only_ when `dent` is creating a new\n container. If it finds an existing container that it would use, it\n will generate an error explaining that the `-r` option would have\n no effect.\n\nThe following options are used mainly for development and debugging:\n* `--tmpdir TMPDIR`: The directory to use for the Docker build context\n when building an image. Default is a `mkdtmp` name under `/tmp`.\n* `--keep-tmpdir`: If a new image is built from a base image, do not\n remove the temporary directory containing the `Dockerfile` and the\n build context. The name of the directory is printed in a message at\n the start of the build. (This message is not suppressed by `-q`.)\n\n\n\n<!-------------------------------------------------------------------->\n[tmate]: https://tmate.io/\n\n[py-docker]: https://pypi.org/project/docker/\n[root]: https://github.com/0cjs/sedoc/blob/master/docker/security.md#leveraging-docker-for-root-access\n\n[gh-dent]: https://github.com/cynic-net/dent\n[pactivate]: https://github.com/cynic-net/pactivate\n[pi-dent]: https://pypi.org/project/dent\n[pipx]: https://pipx.pypa.io/\n",
"bugtrack_url": null,
"license": null,
"summary": "Enter interactive shells in Docker containers and manage persistent containers",
"version": "1.0.0",
"project_urls": {
"homepage": "https://github.com/cynic-net/dent",
"source": "https://github.com/cynic-net/dent",
"tracker": "https://github.com/cynic-net/dent/issues"
},
"split_keywords": [],
"urls": [
{
"comment_text": "",
"digests": {
"blake2b_256": "161a12b138e24118dc47f7425f6144ce3e296e1fa29d50332893719779c701d2",
"md5": "c450371195532a5b0a6fab40e996068d",
"sha256": "59148e451605894269c7545c36c727f06e2e61fa44b8be9a76b0e180cd17992c"
},
"downloads": -1,
"filename": "dent-1.0.0-py3-none-any.whl",
"has_sig": false,
"md5_digest": "c450371195532a5b0a6fab40e996068d",
"packagetype": "bdist_wheel",
"python_version": "py3",
"requires_python": ">=3.8",
"size": 17211,
"upload_time": "2024-08-29T15:09:35",
"upload_time_iso_8601": "2024-08-29T15:09:35.165211Z",
"url": "https://files.pythonhosted.org/packages/16/1a/12b138e24118dc47f7425f6144ce3e296e1fa29d50332893719779c701d2/dent-1.0.0-py3-none-any.whl",
"yanked": false,
"yanked_reason": null
},
{
"comment_text": "",
"digests": {
"blake2b_256": "f39d1ac24cb11584a03ed466828dbb82159ceb6295de838e55b369ac3739fd9d",
"md5": "6e2b31197758f025201c73edc004cb92",
"sha256": "371790236f1bdb840203eb22df4139e6bfe43029f82995038ab0bc4d9fbe7b90"
},
"downloads": -1,
"filename": "dent-1.0.0.tar.gz",
"has_sig": false,
"md5_digest": "6e2b31197758f025201c73edc004cb92",
"packagetype": "sdist",
"python_version": "source",
"requires_python": ">=3.8",
"size": 16900,
"upload_time": "2024-08-29T15:09:37",
"upload_time_iso_8601": "2024-08-29T15:09:37.254041Z",
"url": "https://files.pythonhosted.org/packages/f3/9d/1ac24cb11584a03ed466828dbb82159ceb6295de838e55b369ac3739fd9d/dent-1.0.0.tar.gz",
"yanked": false,
"yanked_reason": null
}
],
"upload_time": "2024-08-29 15:09:37",
"github": true,
"gitlab": false,
"bitbucket": false,
"codeberg": false,
"github_user": "cynic-net",
"github_project": "dent",
"travis_ci": false,
"coveralls": false,
"github_actions": false,
"requirements": [],
"lcname": "dent"
}
