ybox 0.9.8__py3-none-any.whl

ybox/conf/distros/deb-generic/distro.ini

@@ -0,0 +1,190 @@
+# Configuration specific to each distribution (INI style file)
+
+# The following environment variables are set when running the init.sh and init-user.sh scripts.
+# The scripts are required to honor the meaning of the corresponding variables as described in
+# their comments.
+#   CONFIGURE_FASTEST_MIRRORS: empty or non-empty corresponding to configure_fastest_mirrors below
+#   REQUIRED_PKGS: packages specified in `packages.required` below
+#   REQUIRED_DEPS: packages specified in `packages.required_deps` below
+#   RECOMMENDED_PKGS: packages specified in `packages.recommended` below
+#   RECOMMENDED_DEPS: packages specified in `packages.recommended_deps` below
+#   SUGGESTED_PKGS: packages specified in `packages.suggested` below
+#   SUGGESTED_DEPS: packages specified in `packages.suggested_deps` below
+#   EXTRA_PKGS: packages specified in `packages.extra` below
+
+
+# Base configuration for the distribution
+[base]
+# name is required and should be overridden by distributions using this
+name = Generic Debian/Ubuntu distribution
+# Comma separated files to include before applying these settings.
+# Paths can be absolute or relative to the location of this file.
+includes =
+# docker image of the distribution
+image =
+# directories which are shared between the containers of a distribution when
+# `shared_root` is provided in the container configuration
+shared_root_dirs = /etc,/opt,/usr,/var
+# the secondary groups of the container user; it requires to include at least the equivalent of
+# nobody/nogroup to work correctly (the last field in /etc/subgid)
+secondary_groups = nogroup,sudo,video,input,lp,mail
+# whether to search for and configure fastest available mirrors for packages
+configure_fastest_mirrors = false
+# distribution scripts that need to be copied to the container in $YBOX_TARGET_SCRIPTS_DIR
+# (should include init.sh, init-base.sh and init-user.sh scripts that are are normally required
+# for all distributions)
+# distributions should have relative paths to the scripts from this directory
+#scripts = init-base.sh,init.sh,init-user.sh,check-package.sh,list_fmt_long.py,fetch-gpg-key-id.sh
+scripts =
+
+
+# Initial set of packages to be installed in the distribution image
+[packages]
+# packages required for a functional ybox container
+required = git ed zip dctrl-tools
+# dependencies of the `required` packages
+required_deps = less patch openssh-client unzip bash-completion psmisc
+# recommended packages required for many GUI/CLI apps to work properly
+recommended = bc man-db manpages pulseaudio-utils bzip2 xz-utils zstd fastjar wget shared-mime-info
+              iso-codes vainfo mesa-utils vulkan-tools iputils-ping iproute2 tzdata distro-info
+              pciutils whiptail python3-pip fonts-liberation2
+# dependencies of the `recommended` packages
+recommended_deps = xauth netbase xdg-user-dirs intel-media-va-driver-non-free mesa-va-drivers
+                   mesa-vulkan-drivers libfribidi0 fonts-dejavu-core sensible-utils libpam-cap
+# optional packages for enhanced experience in shell and GUI apps
+suggested = fonts-cantarell fonts-firacode fonts-noto-core neovim ncdu fd-find bat
+            kitty-terminfo tree autojump
+# dependencies of the `suggested` packages
+suggested_deps = xsel xxd
+
+
+# The commands here will be run as normal userns mapped user, so use sudo if the command
+# needs to run as root inside the container
+[pkgmgr]
+# the variables here are all required ones unless noted otherwise
+
+# install command does not have a placeholder for {package} since it is also used by
+# entrypoint scripts to install packages, so this assumes that this command accepts a list of one
+# or more space-separated packages at the end
+install = DOWNLOADBEFORE=true /usr/bin/apt-fast {quiet} {opt_dep} install
+# Show the packages that satisfy the given {package} where latter can be a virtual package
+# (i.e. "Provides") or an actual package or a combination of both (e.g. some packages provide and
+#  replace another actual package).
+check_avail = /bin/sh $YBOX_TARGET_SCRIPTS_DIR/check-package.sh available '{package}'
+# check an installed actual or virtual (i.e. "Provides") package and list them in reverse
+# install/upgrade time order (i.e. most recently installed/upgraded first)
+check_install = /bin/sh $YBOX_TARGET_SCRIPTS_DIR/check-package.sh installed '{package}'
+# proceed quietly without asking questions
+quiet_flag = -y
+# this is substituted for `{quiet}` placeholder in `info`, `info_all`, `search` and `search_all`
+quiet_details_flag = -qq
+# apt-mark works correctly only if an optional dependency is actually marked to be so in the
+# deb package, but will cause trouble for cases where user wants to mark a package as an optional
+# dependency of another even otherwise (e.g. qt5ct as optional dependency of libqt5gui5)
+opt_dep_flag =
+# Expected output of the `opt_deps` command is:
+# {header}
+# {prefix}<name>{separator}<level>{separator}<installed>{separator}<description>
+# where
+# <name>: name of the optional dependency
+# <level>: level of the dependency i.e. 1 for direct dependency, 2 for dependency of dependency and
+#          so on; resolution of level > 2 is not required since caller currently ignores those
+# <installed>: true if the dependency already installed and false otherwise
+opt_deps = /usr/bin/python3 $YBOX_TARGET_SCRIPTS_DIR/pkgdeps.py \
+           -s '{separator}' -p '{prefix}' -H '{header}'
+# disable unstable API warning for apt
+apt_no_warn = /usr/bin/apt -o Apt::Cmd::Disable-Script-Warning=true
+uninstall = /usr/bin/sudo %(apt_no_warn)s {quiet} {purge} {remove_deps} remove {package}
+purge_flag = --purge
+remove_deps_flag = --autoremove
+orphans = /usr/bin/sudo %(apt_no_warn)s --just-print autoremove | /usr/bin/mawk '/^Rem/ { print $2 }'
+update_meta = DOWNLOADBEFORE=true /usr/bin/apt-fast update
+update = DOWNLOADBEFORE=true /usr/bin/apt-fast --only-upgrade {quiet} install {packages}
+update_all = DOWNLOADBEFORE=true /usr/bin/apt-fast {quiet} full-upgrade
+clean = DOWNLOADBEFORE=true && /usr/bin/apt-fast clean && /usr/bin/sudo /usr/bin/apt clean
+clean_quiet = %(clean)s
+mark_explicit = /usr/bin/sudo /usr/bin/apt-mark manual {package}
+
+info = /usr/bin/dpkg-query -s {packages}
+info_all = /usr/bin/apt-cache {quiet} show {packages}
+
+# list and list_all show package name and version separated by {separator}; the list command only
+# shows explicitly installed packages while the "_all" variant also shows dependents
+list = PKGS="$(/usr/bin/apt-mark showmanual {packages} | /usr/bin/tr '\n' ' ')" && \
+    /usr/bin/dpkg-query -W -f '${{binary:Package}}{separator}${{Version}}\n' $PKGS
+# empty {packages} means all packages
+list_all = /usr/bin/dpkg-query -W -f '${{binary:Package}}{separator}${{Version}}\n' {packages}
+
+# next two variables are not required ones rather are used for expansion in list variables
+# to avoid repetition
+list_fmt_long = /usr/bin/python3 $YBOX_TARGET_SCRIPTS_DIR/list_fmt_long.py '{separator}'
+list_long_fields = '${{binary:Package}}{separator}${{Version}}{separator}${{Provides}}'`\
+                  `'{separator}${{Pre-Depends}}{separator}${{Depends}}{separator}${{Recommends}}'`\
+                  `'{separator}${{Suggests}}{separator}${{Description}}\n\n'
+# list_long and list_all_long show package name, version, dependency-of and description separated
+# by {separator}; the dependency-of column gives the required and optional dependencies in the
+# format: req(<pkg> <pkg> ...),opt(<pkg> <pkg> ...); like above the "_all" variant shows all
+# packages including dependents while other one shows only explicitly installed ones
+list_long = PKGS="$(/usr/bin/apt-mark showmanual {packages} | /usr/bin/tr '\n' ' ')" && \
+    /usr/bin/dpkg-query -W -f %(list_long_fields)s $PKGS | %(list_fmt_long)s
+list_all_long = /usr/bin/dpkg-query -W -f %(list_long_fields)s {packages} | %(list_fmt_long)s
+
+list_files = /usr/bin/dpkg-query -L {package}
+
+# next variable is not a required one rather are used for expansion in search variables
+
+# the weird "set ..." subcommand converts space-separated quoted arguments into a
+# regex i.e. ' one ' 'two' ' three' to " one |two | three" which is accomplished by declaring
+# those arguments as positional arguments $1, $2 etc, then echo all arguments with IFS as "|"
+args_re = "{word_start}($(set -- {search}; IFS="|"; echo "$*")){word_end}"
+
+# search in package names in the repositories
+search = %(apt_no_warn)s --names-only -q {quiet} {official} search %(args_re)s
+# search in package names, provides and descriptions in the repositories
+search_all = /usr/bin/apt-cache {quiet} {official} search %(args_re)s
+# this is substituted for `{official}` placeholder in `search` and `search_all`
+search_official_flag =
+# this is substituted for `{word_start}` placeholder in `search` and `search_all`
+search_word_start_flag = \b
+# this is substituted for `{word_end}` placeholder in `search` and `search_all`
+search_word_end_flag = \b
+
+# regex pattern matching processes that may be invoked by package manager directly or indirectly
+# that may need to be terminated for cleanup
+processes_pattern = \b(apt-get|apt-fast|apt|aptitude|nala|keyboxd|dirmngr)\b
+# comma separated globs for package manager related lock files (no spaces in names or within)
+locks_pattern = /var/lib/apt/lists/lock,/var/lib/dpkg/lock*,$HOME/.gnupg/public-keys.d/*.lock
+repair = /usr/bin/sudo /usr/bin/apt-get --fix-broken {quiet} install
+# reinstall all packages
+repair_all = %(repair)s && \
+             MANUAL_PKGS="$(/usr/bin/apt-mark showmanual)" && \
+             PKGS="$(/usr/bin/apt-mark showinstall)" && \
+             /usr/bin/apt-fast --reinstall {quiet} install $PKGS && \
+             /usr/bin/sudo /usr/bin/apt-mark auto $PKGS >/dev/null && \
+             /usr/bin/sudo /usr/bin/apt-mark manual $MANUAL_PKGS >/dev/null && %(clean)s
+
+
+# Commands related to repository management
+[repo]
+conf_dir = /etc/apt/sources.list.d
+keyring_dir = /etc/apt/keyrings
+exists = /bin/test -f "%(conf_dir)s/{name}.list"
+# Ubuntu's keyserver is more reliable than the standard gnupg.net/pgp.net ones
+default_gpg_key_server = hkps://keyserver.ubuntu.com
+# output of the `add_key` command should have a line of the form "KEYID=..." that provides the
+# fingerprints of the registered keys that can be passed to `remove_key`
+add_key = ( /usr/bin/curl -sSL '{url}' | /usr/bin/gpg --dearmor | \
+            /usr/bin/sudo /usr/bin/tee '%(keyring_dir)s/{name}.gpg' >/dev/null) && \
+          /bin/echo KEYID="$(/usr/bin/gpg --show-keys --with-colons '%(keyring_dir)s/{name}.gpg' | \
+                             /usr/bin/sed -n 's/^fpr:*\([^:]*\).*/\1/p' | /usr/bin/tr '\n' ' ')"
+# add gpg/pgp key given the key ID and key server
+add_key_id = /usr/bin/sudo /bin/bash $YBOX_TARGET_SCRIPTS_DIR/fetch-gpg-key-id.sh \
+               '{key}' '{server}' '%(keyring_dir)s/{name}.gpg'
+# additional options if supported should be mentioned using {options} below
+add = /bin/echo 'deb [signed-by=%(keyring_dir)s/{name}.gpg] {urls} {options}' | \
+      /usr/bin/sudo /usr/bin/tee '%(conf_dir)s/{name}.list'
+# if source repository is supported, then it should be provided in `add_source` like for `add`
+add_source = /bin/echo 'deb-src [signed-by=%(keyring_dir)s/{name}.gpg] {urls} {options}' | \
+             /usr/bin/sudo /usr/bin/tee -a '%(conf_dir)s/{name}.list'
+remove_key = /usr/bin/sudo /bin/rm '%(keyring_dir)s/{name}.gpg'
+remove = /usr/bin/sudo /bin/rm '%(conf_dir)s/{name}.list'

ybox/conf/distros/deb-generic/fetch-gpg-key-id.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+
+# this script fetches a GPG/PGP key and writes it to an output file given the key ID and key server
+
+set -e
+
+# Check if all arguments are provided
+if [ $# -ne 3 ]; then
+  echo "Usage: $0 <key ID> <key server> <output key file>"
+  exit 1
+fi
+
+# ensure that only system paths are searched for all the system utilities
+export PATH="/usr/sbin:/usr/bin:/sbin:/bin"
+
+current_user="$(id -un)"
+export HOME="$(getent passwd "$current_user" | cut -d: -f6)"
+mkdir -p "$HOME/.gnupg"
+chmod 0700 "$HOME/.gnupg"
+
+temp_keyring="$(mktemp /tmp/gpg-keyring-XXXXXXXXXX)"
+
+trap "rm -f $temp_keyring ${temp_keyring}~" 0 1 2 3 13 15
+
+# fetch the key from the key server and export to given output key file
+GPG_CMD="gpg --no-default-keyring --keyring $temp_keyring"
+$GPG_CMD --keyserver "$2" --recv-key "$1"
+$GPG_CMD --export --output "$3"
+
+exit 0

ybox/conf/distros/deb-generic/init-base.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+
+set -e
+
+export DEBIAN_FRONTEND=noninteractive
+
+apt-get update
+apt-get install -y apt-utils procps
+apt-get install -y sudo dbus perl
+addgroup --quiet --system input
+apt-get clean

ybox/conf/distros/deb-generic/init-user.sh

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+exit 0

ybox/conf/distros/deb-generic/init.sh

@@ -0,0 +1,136 @@
+#!/bin/bash
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+
+source "$SCRIPT_DIR/entrypoint-common.sh"
+
+if [ -f /etc/dpkg/dpkg.cfg.d/excludes ]; then
+  echo_color "$fg_cyan" "Removing dpkg excludes" >> $status_file
+  mv /etc/dpkg/dpkg.cfg.d/excludes /etc/dpkg/dpkg.cfg.d/excludes.dpkg-tmp
+elif [ -f /etc/dpkg/dpkg.cfg.d/docker ]; then
+  echo_color "$fg_cyan" "Removing dpkg docker excludes" >> $status_file
+  mv /etc/dpkg/dpkg.cfg.d/docker /etc/dpkg/dpkg.cfg.d/docker.dpkg-tmp
+fi
+
+echo_color "$fg_cyan" "Configuring apt and updating package list" >> $status_file
+export HOME=/root
+export DEBIAN_FRONTEND=noninteractive
+# don't install recommended and suggested packages by default but keep them if they are
+# deliberately marked as dependencies
+cat > /etc/apt/apt.conf.d/10-ybox << EOF
+APT::Install-Recommends "false";
+APT::Install-Suggests "false";
+APT::AutoRemove::RecommendsImportant "true";
+APT::AutoRemove::SuggestsImportant "true";
+EOF
+# allow language translations in apt for non english locales
+if [[ -n "$LANG" && ! "$LANG" =~ ^C(\..+)?$ && "$LANG" != "POSIX" && ! "$LANG" == en_* ]]; then
+  rm -f /etc/apt/apt.conf.d/docker-no-languages
+fi
+
+if [ "$(sed -n 's/^ID=//p' /etc/os-release)" = "ubuntu" ]; then
+  apt_fast_rel="$(sed -n 's/^VERSION_CODENAME=//p' /etc/os-release)"
+else
+  apt_fast_rel=focal # use focal for apt-fast install which works on all recent Debian releases
+  # enable contrib and non-free repositories for debian
+  if [ -f /etc/apt/sources.list.d/debian.sources ]; then
+    sed -i 's/^Components: main[ ]*$/Components: main contrib non-free non-free-firmware/' \
+        /etc/apt/sources.list.d/debian.sources
+  else
+    sed -i 's/ main[ ]*$/ main contrib non-free/' /etc/apt/sources.list
+  fi
+fi
+apt-get update
+
+echo_color "$fg_cyan" "Setting up apt-fast" >> $status_file
+apt-get install --install-recommends -y curl gnupg lsb-release
+keyring_file=/etc/apt/keyrings/apt-fast.gpg
+rm -f $keyring_file
+echo -e "deb [signed-by=$keyring_file] http://ppa.launchpad.net/apt-fast/stable/ubuntu $apt_fast_rel main" \
+    > /etc/apt/sources.list.d/apt-fast.list
+mkdir -p /etc/apt/keyrings
+bash "$SCRIPT_DIR/fetch-gpg-key-id.sh" 0xBC5934FD3DEBD4DAEA544F791E2824A7F22B44BD \
+     "$DEFAULT_GPG_KEY_SERVER" $keyring_file
+
+apt-get update
+apt-get install -y apt-fast
+# update couple of apt-fast defaults (both conf file and debconf selection need to be changed)
+sed -i 's/^_APTMGR=.*/_APTMGR=apt/' /etc/apt-fast.conf
+sed -i 's/^_MAXNUM=.*/_MAXNUM=6/' /etc/apt-fast.conf
+echo "apt-fast apt-fast/aptmanager select apt" | debconf-set-selections
+echo "apt-fast apt-fast/maxdownloads select 6" | debconf-set-selections
+
+echo_color "$fg_cyan" "Upgrading all packages" >> $status_file
+export DOWNLOADBEFORE=true
+apt-fast full-upgrade -y --autoremove
+
+# skip unminimize if not installing any recommended packages which should happen only in testing
+if [ -n "$RECOMMENDED_PKGS" ]; then
+  unminimize_path="$(type -p unminimize 2>/dev/null || true)"
+  if [ -z "$unminimize_path" ]; then
+    apt-get install -y unminimize 2>/dev/null || true
+  fi
+  unminimize_path="$(type -p unminimize 2>/dev/null || true)"
+  if [ -n "$unminimize_path" ]; then
+    echo_color "$fg_cyan" "Running unminimize" >> $status_file
+    sed -i 's/apt-get/apt-fast/g' "$unminimize_path"
+    yes | "$unminimize_path"
+    apt-get remove --purge -y unminimize 2>/dev/null || true
+  fi
+fi
+
+# packages can be marked as manually installed in the base image, so mark most of them as auto
+apt-mark auto $(apt-mark showinstall) >/dev/null
+apt-mark manual procps sudo curl gnupg lsb-release apt-fast
+
+# generate the configured locale and assume it is UTF-8
+echo_color "$fg_cyan" "Configuring locale" >> $status_file
+apt-fast install -y locales
+if [ -n "$LANG" -a "$LANG" != "C.UTF-8" ] && ! grep -q "^$LANG UTF-8" /etc/locale.gen; then
+  echo "$LANG UTF-8" >> /etc/locale.gen
+  # always add en_US.UTF-8 regardless since some apps seem to depend on it
+  if [ "$LANG" != "en_US.UTF-8" ]; then
+    echo "en_US.UTF-8 UTF-8" >> /etc/locale.gen
+  fi
+  if ! locale-gen; then
+    echo_color "$fg_red" "FAILED to generate locale for $LANG, fallback to en_US.UTF-8" >> $status_file
+    export LANG=en_US.UTF-8
+    export LANGUAGE="en_US:en"
+  fi
+  echo "LANG=$LANG" > /etc/default/locale
+  if [ -n "$LANGUAGE" ]; then
+    echo "LANGUAGE=\"$LANGUAGE\"" >> /etc/default/locale
+  fi
+fi
+
+echo_color "$fg_cyan" "Installing base set of packages" >> $status_file
+apt-fast install -y $REQUIRED_PKGS $RECOMMENDED_PKGS $SUGGESTED_PKGS \
+                    $REQUIRED_DEPS $RECOMMENDED_DEPS $SUGGESTED_DEPS
+apt-mark auto $REQUIRED_DEPS $RECOMMENDED_DEPS $SUGGESTED_DEPS
+apt-fast clean
+apt clean
+
+# common environment variables
+if ! grep -q '^export EDITOR=' /etc/bash.bashrc && dpkg --no-pager -l neovim 2>/dev/null >/dev/null; then
+  echo -e '\nexport EDITOR=nvim\nexport VISUAL=nvim' >> /etc/bash.bashrc
+fi
+if ! grep -q '^export LESSOPEN=' /etc/bash.bashrc && dpkg --no-pager -l lesspipe 2>/dev/null >/dev/null; then
+  echo -e '\nexport PAGER="less -RL"' >> /etc/bash.bashrc
+  lesspipe >> /etc/bash.bashrc
+fi
+if ! grep -q '^export LANG=' /etc/bash.bashrc && [ -n "$LANG" -a "$LANG" != "C.UTF-8" ]; then
+  echo -e "\nexport LANG=$LANG" >> /etc/bash.bashrc
+  if [ -n "$LANGUAGE" ]; then
+    echo "export LANGUAGE=\"$LANGUAGE\"" >> /etc/bash.bashrc
+  fi
+fi
+
+# skip starship if not installing any recommended packages which should happen only in testing
+if [ -n "$RECOMMENDED_PKGS" ]; then
+  echo_color "$fg_cyan" "Installing starship for fancy bash prompt" >> $status_file
+  curl -sSL https://starship.rs/install.sh -o starship-install.sh && \
+    /bin/sh starship-install.sh -y && rm -f starship-install.sh /tmp/tmp.*
+  echo -e 'eval "$(starship init bash)"' >> /etc/bash.bashrc
+fi

ybox/conf/distros/deb-generic/list_fmt_long.py

@@ -0,0 +1,114 @@
+"""
+Format output of `dpkg-query -W -f '${binary:Package}<sep>${Version}<sep>${Provides}<sep>\
+    ${Pre-Depends}<sep>${Depends}<sep>${Recommends}<sep>${Suggests}<sep>${Description}\n\n'`
+into four columns ${binary:Package}<sep>${Version}<sep>${Dependency Of}<sep>${Description}
+where <sep> is a user provided separator.
+"""
+
+import argparse
+import re
+import sys
+from collections import defaultdict
+from typing import Iterable
+
+from pkgdeps import PKG_DEP_RE  # pylint: disable=no-name-in-module
+
+_DOT_LINE = re.compile(r"\s+\.\s*")
+
+
+def parse_separator():
+    """expect a single argument which will be used as the separator between the fields"""
+    parser = argparse.ArgumentParser(description="Format output of dpkg-query into a table.")
+    parser.add_argument("separator", type=str,
+                        help="separator to use between the fields of the output")
+    args = parser.parse_args()
+    return args.separator
+
+
+def format_dep_of(req_parts: Iterable[str], opt_parts: Iterable[str]) -> str:
+    """format the `Dependency Of` column to include the required and optional dependencies"""
+    dep_of_parts = [f"req({' '.join(req_parts)})"] if req_parts else []
+    if opt_parts:
+        dep_of_parts.append(f"opt({' '.join(opt_parts)})")
+    return ",".join(dep_of_parts)
+
+
+def process() -> None:
+    """process dpkg-query output on stdin to create fields separated by a given separator"""
+    sep = parse_separator()
+    current_pkg = ""
+    desc: list[str] = []  # description can be multiline so accumulate it
+    # map of package name to version and description; required and optional dependencies
+    # have be to looked up in the respective maps using the dependency name so need to build
+    # the full pkg_map first
+    pkg_map: defaultdict[str, list[str]] = defaultdict(lambda: ["", ""])
+    # reverse map of package to list of packages that require it (in their pre-depends or depends)
+    req_map: defaultdict[str, list[str]] = defaultdict(list[str])
+    # reverse map of package to list of packages that require it (in their recommends or suggests)
+    opt_map: defaultdict[str, list[str]] = defaultdict(list[str])
+    # map of package name to list of packages it provides (the reverse maps above can have
+    #  either the dependency as the key or one of its provides as the key)
+    provides_map: defaultdict[str, list[str]] = defaultdict(list[str])
+
+    for line in sys.stdin:
+        if not line:
+            continue
+        if line[0].isspace():
+            # continuation of the previous description
+            if _DOT_LINE.fullmatch(line):
+                desc.append(r"\n")  # literal \n will be replaced by newline in the table display
+            else:
+                # for simple line breaks in the description, it is just a continuation and can be
+                # appended with a space, but for the case of `_DOT_LINE` as well as the first
+                # description line and details later, it constitutes a new paragraph which are
+                # separated by a literal \n
+                if desc and desc[-1] != r"\n":
+                    desc.append(" ")
+                desc.append(line.strip())
+        else:
+            if current_pkg:
+                # indicates start of fields of a new package, so fill in description and clear
+                pkg_map[current_pkg][1] = "".join(desc)
+                desc.clear()
+            current_pkg, version, provides, pre_depends, depends, recommends, suggests, desc_s = \
+                line.split(sep, maxsplit=7)
+            pkg_map[current_pkg][0] = version
+            # Iterate Provides, Pre-Depends, Depends, Recommends, Suggests to fill in their maps.
+            # This does not take care of version comparisons in the dependencies but it should
+            # not be possible for an installed package to fail version dependency check (assuming
+            #   the packages are not broken), while virtual packages don't have versions
+            for match in PKG_DEP_RE.finditer(provides):
+                provides_map[current_pkg].append(match.group(1))
+            # fill in reverse mapping of required dependencies
+            for match in PKG_DEP_RE.finditer(pre_depends):
+                req_map[match.group(1)].append(current_pkg)
+            for match in PKG_DEP_RE.finditer(depends):
+                req_map[match.group(1)].append(current_pkg)
+            # fill in reverse mapping of optional dependencies
+            for match in PKG_DEP_RE.finditer(recommends):
+                opt_map[match.group(1)].append(current_pkg)
+            for match in PKG_DEP_RE.finditer(suggests):
+                opt_map[match.group(1)].append(current_pkg)
+            desc.append(desc_s.rstrip())
+            desc.append(r"\n")  # literal \n will be replaced by newline in the table display
+    # fill description of the last package
+    if current_pkg and desc:
+        pkg_map[current_pkg][1] = "".join(desc)
+
+    # for each package in pkg_map, find the packages that require it by looking up the
+    # req_map and opt_map reverse maps; it also need to check all entries in the provides
+    # map to get the full list of packages that require the dependency
+    for pkg_name, (version, description) in pkg_map.items():
+        req_parts = set[str]()
+        opt_parts = set[str]()
+        for dep_name in (pkg_name, *provides_map.get(pkg_name, [])):
+            if req_pkg := req_map.get(dep_name):
+                req_parts.update(req_pkg)
+            if opt_pkg := opt_map.get(dep_name):
+                opt_parts.update(opt_pkg)
+        dep_of = format_dep_of(req_parts, opt_parts)
+        print(f"{pkg_name}{sep}{version}{sep}{dep_of}{sep}{description}")
+
+
+if __name__ == "__main__":
+    process()