ybox 0.9.8__py3-none-any.whl

ybox-0.9.8.dist-info/METADATA

@@ -0,0 +1,533 @@
+Metadata-Version: 2.2
+Name: ybox
+Version: 0.9.8
+Summary: Securely run Linux distribution inside a container
+Author-email: Sumedh Wale <sumwale@yahoo.com>, Vishal Rao <vishalrao@gmail.com>
+License: Copyright (c) 2024-2025 Sumedh Wale and contributors
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/sumwale/ybox
+Project-URL: Issues, https://github.com/sumwale/ybox/issues
+Keywords: Linux in container,toolbox
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+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
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: packaging
+Requires-Dist: simple-term-menu
+Requires-Dist: tabulate>=0.9.0
+
+## Introduction
+
+Create and manage podman/docker containers hosting different Linux
+distribution images. Manage their packages and applications directly
+from your host machine and easily configure the containers with
+simple INI files. It allows for set up of various aspects of
+the container including support for X11, Wayland, audio, video acceleration,
+NVIDIA, dbus among others. It also allows controlling various parameters
+of the container including directories to be shared, logging etc.
+
+Special emphasis is given on security where users can choose to lock down
+or open up the container as required with reasonable defaults out of the
+box. There is no sharing of HOME or no privileged mode container.
+
+Expected usage is for users to group similar applications in a container
+and separate out containers depending on different needs like higher/lower
+security, features off to minimum required for those set of applications.
+
+
+## Features
+
+- simple creation of podman or docker containers hosting Linux distributions (Arch Linux, Ubuntu
+  and Debian supported currently) using `ybox-create` with interactive menus
+- special emphasis on security to lock down applications as much as possible to avoid
+  "malicious" apps, backdoors etc., from affecting your main work space, so you can play/test
+  software/games/... to your heart's content in these containers
+- pre-built profiles for common uses, so you can just run `ybox-create`, select profile and
+  be done with it; or advanced users can micro-customize a profile ini file as required
+- allow for sharing root directories (like /usr, /etc) among various containers to reduce
+  disk and memory usage (default behaviour in the shipped profiles)
+- simple specification to list configuration files that you want to share with the containers
+  in readonly mode (e.g. the basic.ini lists .bashrc, .vimrc etc.)
+- completely isolated home directories in the containers, but you can still precisely control
+  which directories to mount for sharing between the host and guests
+- a high level generic package manager `ybox-pkg` with simple install/uninstall/... commands
+  that uses the distribution package manager for the operation, creates wrapper desktop and
+  executable files to invoke the container's executables, allows specifying additional
+  optional dependencies you need with an application, and so on
+- specify startup applications to run in a container if required (TBD)
+
+If you create an Arch Linux based container (which probably hosts the largest repository of Linux
+applications with its AUR), then you will have its applications to run in the host OS.
+So, for example, if you want to run the latest and greatest Intellij IDEA community, all you need
+to do is:
+
+```sh
+# create an Arch Linux based container
+ybox-create arch
+# then select an appropriate built-in profile e.g. "dev.ini" from the menu
+
+# then install the Arch package in the container
+ybox-pkg install intellij-idea-community-edition
+```
+
+This will automatically create a wrapper desktop file that launches from the container, so
+you can simply launch it from your desktop environment's applications as usual.
+
+In this way this acts as a complete replacement of flatpak/snap while being able to choose
+from way bigger software repositories, and with applications configured the way they are
+supposed to be in the original Linux distribution (which is only Arch Linux for now).
+The big difference being that these are just containers where you can open a shell
+(using `ybox-cmd`) and learn/play as required, or micro-configure stuff. The shell will
+behave quite like a full Linux installation apart from missing system-level stuff like systemd.
+
+
+## Installation
+
+If you have cloned the repository, then no further installation is required to run the utilities
+in `src` directory which can be done directly off the repository. In the near future this will
+also be published on `pypi.org`, so you will be able to install with `pip install --user ybox`.
+
+As of now the following is required:
+
+- clone the repo: `git clone https://github.com/sumwale/ybox.git`
+- rootless podman or docker
+  * for podman this needs installation of `podman` and `slirp4netns`/`passt` packages,
+    then setup /etc/subuid and /etc/subgid as noted here:
+    [/etc/subuid and /etc/subgid configuration](https://github.com/containers/podman/blob/main/docs/tutorials/rootless_tutorial.md#etcsubuid-and-etcsubgid-configuration)
+    (many distributions like ubuntu will set up subuid/subgid for current user automatically)
+  * for docker follow the instructions in the official [docs](https://docs.docker.com/engine/security/rootless/)
+- python version 3.9 or higher -- all fairly recent Linux distributions should satisfy this
+  but still confirm with `python3 --version`
+- install [simple-term-menu](https://pypi.org/project/simple-term-menu/),
+  [tabulate](https://pypi.org/project/tabulate/) and
+  [packaging](https://pypi.org/project/packaging/),  either from your distribution
+  repository, if available, else: `pip install --user simple-term-menu packaging tabulate`
+  (obviously you will need `pip` itself to be installed which should be in your
+   distribution repositories e.g. ubuntu/debian have it as `python3-pip`)
+
+In the future, installer will take care of setting all of these up.
+
+Now you can simply go to the repository and run the `ybox-create` and other utilities from
+the `src` directory of the repository checkout. For convenience, you can symlink these to
+your `~/.local/bin` directory which should be in PATH in modern Linux distributions:
+
+```sh
+ln -s <full path of checkout ybox directory>/src/ybox-* ~/.local/bin/
+```
+
+All the `ybox-*` utilities will show detailed help with the `-h`/`--help` option.
+
+
+## Usage
+
+The basic workflow consists of setting up one or more containers, installing/removing/...
+packages in those containers and opening a shell into a container for more "direct" usage.
+
+You can also destroy the containers, list them, see their logs, or restart them using
+convenient utilities.
+
+All the commands support podman or docker configured in rootless mode. When using docker, its
+`dockerd` daemon needs to be running in background as the current user, while for podman
+there is no such requirement. Additionally podman will run applications in the container using
+the same user/group as the current user on the host, while docker needs to use the root user in
+the container due to missing support of `--userns=keep-id` option.
+
+Consequently podman is the recommended container manager for ybox containers. Its rootless mode
+also works out of the box in most modern linux distributions, unlike docker that needs some
+configuration to setup its user-mode rootless daemon.
+
+The commands search for `/usr/bin/podman` followed by `/usr/bin/docker` for the container manager
+executable. This can be overridden using the `YBOX_CONTAINER_MANAGER` environment variable
+to point to the full path of the podman or docker executable.
+
+### Create a new ybox container
+
+```sh
+ybox-create
+```
+
+This will allow choosing from supported distributions, then from the available profiles.
+You can start with the Arch Linux distribution and `apps.ini` profile to try it out. The container
+will have a name like `ybox-<distribution>_<profile>` by default like `ybox-arch_apps` for the
+`apps.ini` profile using Arch Linux distribution.
+
+The `$HOME` directory of the container can be found in `~/.local/share/ybox/<container>/home`
+e.g. `~/.local/share/ybox/ybox-arch_apps/home` for the above example.
+
+When shared root directory is enabled (which is the default in the shipped profiles), then
+it uses the common distribution path in `~/.local/share/ybox/SHARED_ROOTS/<distribution>`
+by default i.e. `~/.local/share/ybox/SHARED_ROOTS/arch` for the Arch Linux guests.
+
+For more advanced usage, you can copy from the available profiles in `src/ybox/conf/profiles`
+into `~/.config/ybox/profiles`, then edit as required. The `basic.ini` profile lists
+all the available options with detailed comments.
+
+Note that when using podman, the container will use the same user/group as the current user
+on the host, while if docker is being used then the container will use the root user.
+This is because of missing support for `--userns=keep-id` in docker that allows mapping the
+host user to the same user in the container when using podman. This means that if some application
+does not run properly as root, then you cannot run it when using docker unless you explicitly
+`sudo/su` to the host user in the container command. However, running as host user when running
+rootless docker will map to a different user ID in the host (as specified in `/etc/subuid` on the
+host) so files shared with the host, including devices like those in `/dev/dri`, will cause
+permission issues that can hinder or break the application.
+
+
+### Package management: install/uninstall/list/search/...
+
+Install a new package with `ybox-pkg` like firefox below:
+
+```sh
+ybox-pkg install firefox
+```
+
+If you have created multiples containers, then this will allow you to choose one among
+them for the installation. After the main package installation, it will also list
+the optional dependencies of the installed package (only till second level) and allow you
+to choose from among them which may add additional features to the package.
+
+The installation will also create wrapper desktop files in `~/.local/share/applications`
+and executables in `~/.local/bin` with man pages linked in `~/.local/share/man` so you can execute
+the newly install application binaries from your desktop environment's application menu and/or
+from command-line having corresponding man pages.
+
+Likewise, you can uninstall all the changes (including the optional packages chosen before):
+
+```sh
+ybox-pkg uninstall firefox
+```
+
+List the explicitly installed packages using `ybox-pkg`:
+
+```sh
+ybox-pkg list
+```
+This will show the chosen dependent packages in addition to the explicitly installed ones.
+
+```sh
+ybox-pkg list -a
+```
+This will list all the distribution packages in the container including those not installed
+by `ybox-pkg` (either installed in the base image, or installed later using the distribution
+    package manager directly) -- combine with `-a` to also list all dependent packages.
+
+```sh
+ybox-pkg list -o
+```
+To show more details of the packages (combine with -a/-o as required):
+```sh
+ybox-pkg list -o
+```
+
+List all the files installed by the package:
+```sh
+ybox-pkg list-files firefox
+```
+
+Search the repositories for packages with names matching search terms:
+
+```sh
+ybox-pkg search intellij
+```
+
+Search the repositories for packages with names or descriptions matching search terms:
+
+```sh
+ybox-pkg search intellij -a
+```
+
+You can also restrict the search to full word matches (can be combined with `-a`):
+
+```sh
+ybox-pkg search intellij -w
+```
+
+Show detailed information for an installed package:
+```sh
+ybox-pkg info firefox
+```
+
+Show detailed information for any package in the available repositories:
+```sh
+ybox-pkg info firefox -a
+```
+
+Clean package cache, temporary downloads etc:
+```sh
+ybox-pkg clean
+```
+
+Mark a package as explicitly installed (also registers with `ybox-pkg` if not present):
+```sh
+ybox-pkg mark firefox -e
+```
+
+Mark a package as a dependency of another (also registers with `ybox-pkg` if not present):
+```sh
+ybox-pkg mark qt5ct -D zoom  # mark qt5ct as an optional dependency of zoom
+```
+
+Repair package installation after a failure or interrupt:
+```sh
+ybox-pkg repair
+```
+
+More extensive repair of package installation including reinstallation of all packages:
+```sh
+ybox-pkg repair --extensive
+```
+
+All the `ybox-pkg` subcommands will show detailed help with `-h/--help` option e.g.
+`ybox-pkg list --help`.
+
+
+### List the available containers
+
+```sh
+ybox-ls
+```
+
+will list the active ybox containers
+
+```sh
+ybox-ls -a
+```
+
+will list all ybox containers including stopped ones
+
+
+### Destroy a container
+
+```sh
+ybox-destroy ybox-arch_apps
+```
+
+Will destroy the `apps` container created in the example before. This does not delete the
+$HOME files, nor does it delete the shared root directory (if enabled). Hence, if you create
+a new container having the same shared root, then it will inherit everything installed
+previously. Likewise, if you create the container with the same profile again, then it
+will also have the $HOME as before if you do not explicitly delete the directories
+in `~/.local/share/ybox`.
+
+
+**NOTE:** an auto-complete file for fish shell has been provided in
+`src/ybox/conf/completions/ybox.fish`, so you can link that to your fish config:
+```sh
+ln -s <full path of checkout ybox directory>/src/ybox/conf/completions/ybox.fish ~/.config/fish/conf.d/
+```
+This will allow auto complete for ybox container names, profiles among others.
+Auto-complete for bash/zsh will be added in the future.
+
+
+### Running a command in a container
+
+The `ybox-cmd` runs `/bin/bash` in the container by default:
+
+```sh
+ybox-cmd ybox-arch_apps
+```
+
+You can run other commands instead of bash shell, but if those commands require options
+starting with a hyphen, then first end the options to `ybox-cmd` with a double hyphen:
+
+```sh
+ybox-cmd ybox-arch_apps -- ls -l
+```
+
+The default profiles also link the .bashrc and starship configuration files from your host
+$HOME directory by default, so you should see the same bash shell configuration as in your
+host. These are linked in read-only mode, so if you want to change these auto-linked
+configuration files inside the container, then you will need to create a copy from the symlink
+first (but then it will lose the link from the host $HOME).
+
+A shell on a container will act like a native Linux distribution environment for most purposes.
+The one prominent missing thing is systemd which is not enabled deliberately since it requires
+highly elevated privileges. It is strongly recommended not to try and somehow enable systemd
+in the containers lest it will bypass most of the security provided by a container environment.
+Instead, you should just start any daemons the normal way as required. You will also need
+to ensure that the daemons don't try and use journald for the logging, rather use the
+normal /var/log based logging. Overall these containers are not meant for running system
+daemons and similar low level utilities which should be the job of your host system.
+
+
+### Show the container logs
+
+```sh
+ybox-logs ybox-arch_apps
+```
+
+Follow the logs like `tail -f`:
+
+```sh
+ybox-logs ybox-arch_apps -f
+```
+
+In the shipped profiles, the container logs go to `~/.local/share/ybox/<container>/logs/`
+directory instead of polluting your journald logs as the podman/docker do by default.
+You can delete old log files there safely if they start taking a lot of disk space.
+
+
+### Restart a container
+
+A container may get stopped after a reboot if systemd/... is not configured to auto-start
+the podman/docker containers. Or you can explicitly stop a container using podman/docker.
+You can check using `ybox-ls -a` and restart a stopped container as below:
+
+```sh
+ybox-control start ybox-arch_apps
+```
+
+The `ybox-control` script also allows for other actions `stop`, `restart` and `status`
+for a ybox container. See the full set of options with `ybox-control -h/--help`.
+
+
+### Auto-starting containers
+
+Containers can be auto-started as per the usual way for rootless podman/docker services.
+This is triggered by systemd on user login which is exactly what we want for ybox
+containers so that the container applications are available on login and are stopped on
+session logout. For docker the following should suffice:
+
+```sh
+systemctl --user enable docker
+```
+
+See [docker docs](https://docs.docker.com/engine/security/rootless/#daemon) for details.
+
+For podman you will need to explicitly generate systemd service file for each container and
+copy to your systemd configuration directory since podman does not use a background daemon.
+For the `ybox-arch_apps` container in the examples before:
+
+```sh
+mkdir -p ~/.config/systemd/user/
+podman generate systemd --name ybox-arch_apps > ~/.config/systemd/user/container-ybox-arch_apps.service
+systemctl --user enable container-ybox-arch_apps.service
+```
+
+
+## Development
+
+Virtual environment setup have been provided for consistent development, test and build
+with multiple python versions. The minimum python version required is 3.9 and tests are
+run against all major python versions higher than that (i.e. 3.10, 3.11, 3.12 and others
+in future).
+
+The setup uses pyenv with venv which can be used for development with IDEA/PyCharm/VSCode
+or in terminal, running tests against all supported python versions using `tox` etc.
+Scripts to set up a pyenv with venv environment have been provided in the `pyenv` directory
+which creates a `venv` environment in `.venv` directory of the checkout.
+
+If you do not have `pyenv` installed and configured, then you can install it using:
+
+```sh
+pyenv/install.sh
+```
+
+**NOTE:** this script will delete any existing `pyenv` artifacts in `$HOME/.pyenv`, so use
+it only if you have never installed `pyenv` before.
+
+The script will try to handle installation of required packages on most modern Linux
+distributions (Ubuntu/Debian, Fedora, Arch Linux, OpenSUSE, homebrew), but if yours is a
+different one, then check [pyenv wiki](https://github.com/pyenv/pyenv/wiki) or your
+distribution docs/forums.
+
+Next you can install the required python versions and venv environment:
+
+```sh
+pyenv/setup-venv.sh
+```
+
+Finally, you can activate it in bash/zsh:
+
+```sh
+source pyenv/activate.sh
+source .venv/bin/activate
+```
+
+Or in fish shell:
+
+```
+source pyenv/activate.fish
+source .venv/bin/activate.fish
+```
+
+**NOTE:** while the pyenv installation and venv set up needs to be done only once, the last
+steps of `source` of the two files will need to be done for every shell. Hence, you can consider
+placing those in your bashrc/zshrc or fish conf.d so that they get applied in every interactive
+shell automatically.
+
+You can open the checkout directory as an existing project in Intellij IDEA/PyCharm and then
+add Python SDK (File -> Project Settings -> Project -> SDK -> Add Python SDK...).
+Choose an existing environment in Virtualenv environment and select the
+`<checkout dir>/.venv/bin/python3` for the interpreter.
+
+For using VSCode, ensure that the python extension from Microsoft and preferably the following
+additional extensions are installed: autopep8, Flake8, isort, audoDocstring and
+Python Environment Manager. The open the checkout directory and you should be good to go.
+
+
+### Notes on writing tests
+
+Tests have been categorized into two:
+- in `tests/unit` directory: these have module/function/class level tests; convention is to
+  use a separate test module for corresponding source module e.g. `test_state.py` for
+  `ybox/state.py` module
+- in `tests/functional` directory: these are end-to-end tests that invoke and check the
+  top-level `ybox-*` utilities
+
+All the existing tests use the `pytest` framework and new ones should do the same.
+After adding new tests to the appropriate test directory run `code-check.sh` and
+`tests-coverage.sh` scripts which should succeed and also see coverage report from latter.
+
+**NOTE:** use mock only if absolutely necessary (e.g. for unexpected error
+conditions that are difficult to simulate in tests or will cause other trouble).
+For example the state database used is sqlite, but that is an internal detail and could
+potentially change so mocking sqlite3 objects in tests for `ybox.state` module is a really
+bad idea and one should just test for public API of `ybox.state`. On the other hand
+checking for exceptions like `KeyboardInterrupt` can use mock since simulating them
+otherwise is error-prone and can cause unwanted side-effects for other tests.
+
+
+### Running the test suite
+
+Once pyenv+venv set up is working, you can run the entire test suite and other checks
+using `tox` in the checkout directory, or `tox -p` for parallel run. It will run with
+all supported python versions (i.e. from 3.9 onwards). Tests are written using the `pytest`
+test framework which will be installed along with other requirements by the `setup-venv.sh`
+script (or you can explicitly use `requirements.txt` and install `tox` separately).
+
+There is also a simple script `tests-coverage.sh` in the top-level directory which can be
+used to run just the tests with the current python version and produce coverage report.
+It accepts a single argument `-f` to run functional tests in addition to the unit tests,
+else only unit tests are run with coverage. Any arguments afterwards are passed as such
+to `pytest`. This will skip other stuff like `pyright`, for example, which is invoked by
+`tox`. The lint and other related tools can be run explicitly using the `code-check.sh`
+script in the top-level directory.
+
+See `tox` and `pytest` documentation for more details like running individual tests.

ybox-0.9.8.dist-info/RECORD

@@ -0,0 +1,76 @@
+ybox/__init__.py,sha256=8FzWRJgA6Vf9G715kHHM9hIALv9DUhgcadJtma5PKvc,96
+ybox/cmd.py,sha256=49a1Oo1YgLbXlHqZ1PL1okKGtxlXya1DClM-uh1TuKI,14213
+ybox/config.py,sha256=bFz6MIVCEbwOjG0m6L5JPngQqta5J9aXU4osKtD2QDE,9632
+ybox/env.py,sha256=vfHuvTOpApR4fLx1vePWRrTYxzo50c-7dFcnm1-vDHo,8738
+ybox/filelock.py,sha256=nWBp3jvbtrNziRzNcWm6FVVA_lhMccLwgLCVT2IDK5c,3185
+ybox/print.py,sha256=hAQjTb6JmtjWh0sF4GdZHcKRph5iMKP5x23s8LE85q4,4343
+ybox/state.py,sha256=ZEJr3Aib2UT1N7JFfQAWWESx5Vd0GtL3srY9T3Iq1mQ,49008
+ybox/util.py,sha256=2kuUsRCzSuoTypRTeyJXZMWh-XZK_P7M_wsGa3LcIng,16454
+ybox/conf/completions/ybox.fish,sha256=n62vAH60G_kGytPmdNPSvHaiu9k87Yg33maoje_pRl8,5851
+ybox/conf/distros/supported.list,sha256=KAN7lbNfbRqF20KqEd0-BzF8U5uPx4n9h0W9zVh9z5o,52
+ybox/conf/distros/arch/add-gpg-key.sh,sha256=kLMCT15hYadjhInYwQiiyF4u6rJl8n4gGfzEKuMKvTg,644
+ybox/conf/distros/arch/distro.ini,sha256=NlCnhU4mmO9nE08BcO7hEQ83osMbHgIhLYybGG5rCNc,11026
+ybox/conf/distros/arch/init-base.sh,sha256=eqdVzrMqP0hP52S_xxYZJ8n1lStlPn-eSP2e4DpHvWc,311
+ybox/conf/distros/arch/init-user.sh,sha256=4PqUP6QsE50SeymCeNv70PcabrTpEvt8UO_0t4pDksw,1106
+ybox/conf/distros/arch/init.sh,sha256=jGyDLo1sKDTjUWWW9XnUDejHKNR2w7dnsYfdzHg5E9Y,3560
+ybox/conf/distros/arch/list_fmt_long.py,sha256=Ws9Mt9CKInxqUSn98P6-Csik2QqEjyBHp5NyUHlbcoU,2825
+ybox/conf/distros/arch/pkgdeps.py,sha256=26s92G99CR-JqVBl8UANASHHHjONRSwzNDxKJyd6Pqo,13998
+ybox/conf/distros/deb-generic/check-package.sh,sha256=bMiOi6Cp_UrtXm_sXOWBq4Xng2EwXYerqBuRLtGYIlo,2621
+ybox/conf/distros/deb-generic/distro.ini,sha256=ZDWJG-cvx1BuI2RwynIvDwxzuzvVaYNv68PD-J57t84,11361
+ybox/conf/distros/deb-generic/fetch-gpg-key-id.sh,sha256=sTsLWILZosYJcGV1u8qBdczQAFBda2Zlsp1xbpy8nzo,836
+ybox/conf/distros/deb-generic/init-base.sh,sha256=rim7UckGos0phyOAiNYbIjOVG9C4gKQSB-YbZcTFIms,191
+ybox/conf/distros/deb-generic/init-user.sh,sha256=RDt9sZuv6cSX1WBaRGcLMq2ZTBhVZmZVWD1t0wjvizU,20
+ybox/conf/distros/deb-generic/init.sh,sha256=KW0a76BJm75VHDaLPCE4MdLThcy__NpE6Z8pLB0Q7IM,5748
+ybox/conf/distros/deb-generic/list_fmt_long.py,sha256=66sOC0Uzv5nuTRaQQ_9R-GFJju4PSPXNlXv_eHmx57k,5701
+ybox/conf/distros/deb-generic/pkgdeps.py,sha256=corAt8k8QMiQwL2zJMsfFhDeyFJKaY53G7v5odqnyZY,10549
+ybox/conf/distros/deb-oldstable/distro.ini,sha256=lr7140ftndEvs3Liavf3hg3v0qHHWAn0RRm_HAQTw8M,1103
+ybox/conf/distros/deb-stable/distro.ini,sha256=xyQ31mLOpj3Z1MK-UYuc_9NfEkb7Gy10MdDKXMgnqDo,1100
+ybox/conf/distros/ubuntu2204/distro.ini,sha256=3Pw1Q30USyKMUcHp_cvlqhwyU0FPo8O2AHWkgd0cdE4,1105
+ybox/conf/distros/ubuntu2404/distro.ini,sha256=ra4_EteDsHrw9UcehP4qLGTn98gAHc4JCb56CDzz1Wo,1102
+ybox/conf/profiles/apps.ini,sha256=9GCZJvdB5yOfx-mXyti3M-YQjeLnugrhOp43sQQvqQ0,1001
+ybox/conf/profiles/basic.ini,sha256=ObEGUmtEm6hABAv9XrDk_Uivv7ib_utcgfxA3qBYNj0,17783
+ybox/conf/profiles/dev.ini,sha256=D0Sj1orfhn7UnTbRJg5FSTn8yXFQ08MdcSXTQq7qPAE,930
+ybox/conf/profiles/games.ini,sha256=FiBILNFOMpjKhrIR9nPbPj9QDUeI5h9wZaNXIb6Z7dc,1792
+ybox/conf/resources/entrypoint-base.sh,sha256=hcW8ZLHM-jlHx7McoKTo8HIFz_VBBPD0I3WqlX7LjHs,4890
+ybox/conf/resources/entrypoint-common.sh,sha256=fMopKBLeGuVV0ukANXh_ZHGTR1yGq108CTN_M2MNPyQ,461
+ybox/conf/resources/entrypoint-cp.sh,sha256=4R1UA2YLcKH_tUcyiioHSJA5B_t7GT1Z9gVFnCMi2a0,813
+ybox/conf/resources/entrypoint-root.sh,sha256=wTn5Sl6Fy8T_zOYgP2IlCHOYYY3Qa07kK-NC7O03OqI,685
+ybox/conf/resources/entrypoint-user.sh,sha256=ypHVX2jCvKTPd-_UzIWgY13n9C1glmDdeHYqh_Ahrbk,637
+ybox/conf/resources/entrypoint.sh,sha256=iatkLEBGoZRNm9idDeIOAiN7enYVIZVedbDgq0KLbtE,8280
+ybox/conf/resources/prime-run,sha256=Yu9VuT1aZ8c36s_pOCnkGYn1aL8K1BONiUUv63cw9P4,347
+ybox/conf/resources/run-in-dir,sha256=Z9xHEUDpOc7h3yCowPeZ47PzzgbTq__9aCO2S9TCqdI,1784
+ybox/conf/resources/run-user-bash-cmd,sha256=DgcBNcxeN6EWVLetGj9ZZtcqwWPJ4jGDPNt3WA_F3fI,337
+ybox/migrate/0.9.0-0.9.7:0.9.8.py,sha256=N7O7HtoMh_l404v2bHG5Od-_4fCDFMUBZ1SeT1P9F4M,1582
+ybox/pkg/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ybox/pkg/clean.py,sha256=t8WlVZHL-6xLnU5E5-L4otAwX-qSz9NQmupVwkGAcJw,1592
+ybox/pkg/info.py,sha256=izuVJNG4PjCqahzO5_tn8GAuGFX-1bf1rT0HbAO5a4c,1982
+ybox/pkg/inst.py,sha256=bADv0lOX3W9rsM98QYWszmCX9fFegsCn0cwpxi2Y0Nc,35574
+ybox/pkg/list.py,sha256=FTDYTkuf4PzB2PhHl4vdGnHILQeR8ZMFHyyp4p7LTXg,10404
+ybox/pkg/mark.py,sha256=cdTOKpo7Vb8j8lM0oZxdvAsJpIktnskyHWd6vEt-pG0,3748
+ybox/pkg/repair.py,sha256=hfJ5ETQVHSHX4F5On-8WLKJvWGFfsRaQkZ5fKyeZKSQ,7798
+ybox/pkg/repo.py,sha256=25gQgGMPeHgX83iqqWXyG6V6rIZ4i_KEnIbNG-CrxTk,13677
+ybox/pkg/search.py,sha256=mOJaQ2Tk-Tr3wSk4jHqCFsEtyEt00J8ULLow-cYa-0E,2903
+ybox/pkg/uninst.py,sha256=ndqZ_WYr9HE5jVL1tQ_tTmSPyTFM6OJRCTLLmG-Qm4w,5338
+ybox/pkg/update.py,sha256=M-1MC8oh-baTHdSPWUUSTU_AhN3eu2nTCSge3bb6GmI,3269
+ybox/run/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ybox/run/cmd.py,sha256=f4-iyS5GTHbz1e3XirVii5XvLnGxQfPjXxZGb37GhzE,2044
+ybox/run/control.py,sha256=PH85xf8ex28x-ojqwTjdIMgg9KH7cJmUwZPoCTblPFI,4192
+ybox/run/create.py,sha256=uy0NAKh5JudzakqBmKFYuedVkEB1cfWl02qD6gO7C6U,62097
+ybox/run/destroy.py,sha256=xwp_JMPPCl6oF1mY3kXTVfk2Nn3sdMA3iIkh00zCKB4,2570
+ybox/run/graphics.py,sha256=635Ry0sXIKCpM14ZPDHsQfw-xHNARbvaaAFNDpx3oo4,18991
+ybox/run/logs.py,sha256=i2q0wLrsUwXYSrzfBADyiYiQ2MymSBn3N4JqPmqq03U,1989
+ybox/run/ls.py,sha256=Mek493Z9GbLZ5o3FytgJSzZ9Z4olhMjz3vOUe_apMOw,2726
+ybox/run/pkg.py,sha256=fYaQwXTUyd8MbZMLoXiogEO6l_i94lCovbarsCReT3I,24947
+ybox/schema/0.9.1-added.sql,sha256=1rGp2DczZmmC_xwjmheeZNPSbDpFzasu6LO3tpTy3zI,1049
+ybox/schema/0.9.6-added.sql,sha256=Qcho6dP5OUpPUW3IBWl_kv88agMPHzueUAKqnZPnt3U,809
+ybox/schema/init.sql,sha256=fei8lPvjb-EIjm5zuA_XkEdjsIE3vtROhgRPt7QMlSs,1599
+ybox/schema/migrate/0.9.0:0.9.1.sql,sha256=e9JGwrjFZXdWKGv2JQZlKcWz8DmOuUARpToSsCyiksQ,1555
+ybox/schema/migrate/0.9.1:0.9.2.sql,sha256=X5J3unDS0eLeVvYKxQgx-iUBoAOk9T2suO34pWlQ-lE,362
+ybox/schema/migrate/0.9.2:0.9.3.sql,sha256=Y7GeBSuEEs7Hs9hh-KYDARgeeMgwQwercvTB5P_-k6I,102
+ybox/schema/migrate/0.9.5:0.9.6.sql,sha256=wqYhmputlUQzBI5zfP7O5kqIFWAbZQ05kolyHK4714A,70
+ybox-0.9.8.dist-info/LICENSE,sha256=7GbFgERMXSwD1VyLA5bo_XHvJipmNEUhDW5Sy51TFeY,1077
+ybox-0.9.8.dist-info/METADATA,sha256=voBq82-8y-GKD1wzYEdXPwTniZlcWDyHVAl3vj8isAg,23050
+ybox-0.9.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+ybox-0.9.8.dist-info/entry_points.txt,sha256=xDlI_84Hl3ytYO_ERyt0rkJ4ioUF8Z1r49Hx1xL28Rk,243
+ybox-0.9.8.dist-info/top_level.txt,sha256=DYX7jvndHcBaJXLJ8vDyKrq0_KWoSeXXFq8r0d5L6Nk,5
+ybox-0.9.8.dist-info/RECORD,,

ybox-0.9.8.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ybox-0.9.8.dist-info/entry_points.txt

@@ -0,0 +1,8 @@
+[console_scripts]
+ybox-cmd = ybox.run.cmd:main
+ybox-control = ybox.run.control:main
+ybox-create = ybox.run.create:main
+ybox-destroy = ybox.run.destroy:main
+ybox-logs = ybox.run.logs:main
+ybox-ls = ybox.run.ls:main
+ybox-pkg = ybox.run.pkg:main

ybox-0.9.8.dist-info/top_level.txt

@@ -0,0 +1 @@
+ybox