Refactoring repository...

archive/snigdhaos-calamares/PKGBUILD

@@ -0,0 +1,151 @@
+# PKGBUILD for snigdhaos-calamares
+
+pkgname=snigdhaos-calamares
+_pkgname=calamares
+pkgver=3.3.13
+pkgrel=06
+pkgdesc="Distribution-independent installer framework"
+arch=("i686" "x86_64")
+url="https://github.com/calamares/calamares/releases"
+license=("LGPL")
+
+# Dependencies
+provides=("calamares")
+depends=(
+    'boost-libs'
+    'ckbcomp'
+    'cryptsetup'
+    'doxygen'
+    'efibootmgr'
+    'gptfdisk'
+    'gtk-update-icon-cache'
+    'hwinfo'
+    'icu'
+    'kconfig'
+    'kcoreaddons'
+    'kcrash'
+    'ki18n'
+    'kparts'
+    'kpmcore'
+    'kservice'
+    'kwidgetsaddons'
+    'libpwquality'
+    'mkinitcpio-openswap'
+    'polkit-qt6'
+    'rsync'
+    'qt6-declarative'
+    'solid'
+    'squashfs-tools'
+    'yaml-cpp'
+)
+
+conflicts=()
+
+makedepends=(
+    'boost'
+    'cmake'
+    'extra-cmake-modules'
+    'git'
+    'ninja'
+    'python-jsonschema'
+    'python-pyaml'
+    'python-unidecode'
+    'qt6-tools'
+)
+
+backup=(
+    'usr/share/calamares/modules/bootloader.conf'
+    'usr/share/calamares/modules/displaymanager.conf'
+    'usr/share/calamares/modules/initcpio.conf'
+    'usr/share/calamares/modules/unpackfs.conf'
+)
+
+# Source files
+source=(
+    "calamares::https://github.com/erikdubois/calamares/archive/refs/tags/$pkgver-$pkgrel.tar.gz"
+    "snigdhaos-calamares.desktop"
+    "snigdhaos-calamares-debug.desktop"
+    "calamares_polkit"
+)
+
+sha256sums=(
+    'SKIP'  # Placeholder for proper checksum values
+    'SKIP'
+    'SKIP'
+    'SKIP'
+)
+
+# Prepare the build environment
+prepare() {
+    cp -rv ../modules/* "${srcdir}/$_pkgname-${pkgver}-${pkgrel}/src/modules/"
+
+    # Modify default settings
+    sed -i -e 's/"Install configuration files" OFF/"Install configuration files" ON/' \
+        "${srcdir}/${_pkgname}-${pkgver}-${pkgrel}/CMakeLists.txt"
+    sed -i -e "s/desired_size = 512 \* 1024 \* 1024  # 512MiB/desired_size = 512 \* 1024 \* 1024 \* 4  # 2048MiB/" \
+        "${srcdir}/${_pkgname}-${pkgver}-${pkgrel}/src/modules/fstab/main.py"
+
+    cd "${_pkgname}-${pkgver}-${pkgrel}"
+
+    # Update versioning in CMakeLists
+    sed -i -e "s|CALAMARES_VERSION 3.3.5|CALAMARES_VERSION $pkgver-$pkgrel|g" CMakeLists.txt
+
+    # Remove redundant padding properties in QML
+    sed -i -e '/property real padding: 16;/d' \
+        "$srcdir/${_pkgname}-${pkgver}-${pkgrel}/src/qml/calamares-qt5/slideshow/Presentation.qml"
+    sed -i -e '/property real padding: 16;/d' \
+        "$srcdir/${_pkgname}-${pkgver}-${pkgrel}/src/qml/calamares-qt6/slideshow/Presentation.qml"
+}
+
+# Build the package
+build() {
+    cd "${_pkgname}-${pkgver}-${pkgrel}"
+
+    cmake -S . -Bbuild \
+        -GNinja \
+        -DCMAKE_BUILD_TYPE=Release \
+        -DCMAKE_INSTALL_PREFIX=/usr \
+        -DCMAKE_INSTALL_LIBDIR=lib \
+        -DWITH_APPSTREAM=OFF \
+        -DWITH_PYBIND11=OFF \
+        -DWITH_QT6=ON \
+        -DSKIP_MODULES="dracut \
+            dracutlukscfg \
+            dummycpp \
+            dummyprocess \
+            dummypython \
+            dummypythonqt \
+            initramfs \
+            initramfscfg \
+            interactiveterminal \
+            keyboardq \
+            license \
+            localeq \
+            oemid \
+            packagechooserq \
+            partitionq \
+            services-openrc \
+            services-systemd \
+            summaryq \
+            tracking \
+            usersq \
+            welcomeq \
+            zfs \
+            zfshostid"
+
+    cmake --build build
+}
+
+# Package installation
+package() {
+    cd "${_pkgname}-${pkgver}-${pkgrel}/build"
+    DESTDIR="${pkgdir}" cmake --build . --target install
+
+    # Install desktop and polkit files
+    install -Dm644 "$srcdir/snigdhaos-calamares.desktop" "$pkgdir/usr/share/applications/snigdhaos-calamares.desktop"
+    install -Dm644 "$srcdir/snigdhaos-calamares-debug.desktop" "$pkgdir/usr/share/applications/snigdhaos-calamares-debug.desktop"
+    install -Dm755 "$srcdir/calamares_polkit" "$pkgdir/usr/bin/calamares_polkit"
+
+    # Remove default Calamares desktop file
+    rm "$pkgdir/usr/share/applications/calamares.desktop"
+}

archive/snigdhaos-calamares/calamares_polkit

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Check if pkexec exists and is executable
+if command -v pkexec &>/dev/null; then
+    # Use pkexec to run calamares with administrative privileges
+    pkexec --disable-internal-agent /usr/bin/calamares "$@"
+else
+    # Fallback to running calamares without administrative privileges
+    /usr/bin/calamares "$@"
+fi

archive/snigdhaos-calamares/modules/displaymanager/displaymanager.schema.yaml

@@ -0,0 +1,39 @@
+# SPDX-FileCopyrightText: 2020 Adriaan de Groot <groot@kde.org>
+# SPDX-License-Identifier: GPL-3.0-or-later
+---
+$schema: https://json-schema.org/schema#
+$id: https://calamares.io/schemas/displaymanager
+additionalProperties: false
+type: object
+properties:
+    displaymanagers:
+        type: array
+        items:
+            type: string
+            enum: [slim, sddm, lightdm, gdm, mdm, lxdm, greetd]
+        minItems: 1  # Must be non-empty, if present at all
+    defaultDesktopEnvironment:
+        type: object
+        properties:
+            executable: { type: string }
+            desktopFile: { type: string }
+        required: [ executable, desktopFile ]
+    basicSetup: { type: boolean, default: false }
+    sysconfigSetup: { type: boolean, default: false }
+    greetd:
+        type: object
+        properties:
+            greeter_user: { type: string }
+            greeter_group: { type: string }
+            greeter_css_location: { type: string }
+        additionalProperties: false
+    lightdm:
+        type: object
+        properties:
+            preferred_greeters: { type: array, items: { type: string } }
+        additionalProperties: false
+    sddm:
+        type: object
+        properties:
+            configuration_file: { type: string }
+        additionalProperties: false

archive/snigdhaos-calamares/modules/displaymanager/module.desc

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+---
+type:       "job"
+name:       "displaymanager"
+interface:  "python"
+script:     "main.py"

archive/snigdhaos-calamares/modules/displaymanager/tests/1.global

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+rootMountPoint: /tmp

archive/snigdhaos-calamares/modules/displaymanager/tests/CMakeTests.txt

@@ -0,0 +1,13 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# We have tests to load (some) of the DMs specifically, to test their
+# configuration code. Those tests conventionally live in Python
+# files here in the tests/ directory. Add them.
+foreach(_dmname greetd sddm)
+    add_test(
+        NAME configure-displaymanager-${_dmname}
+        COMMAND env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-dm-${_dmname}.py
+        WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+    )
+endforeach()

archive/snigdhaos-calamares/modules/displaymanager/tests/test-dm-greetd.py

@@ -0,0 +1,33 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Calamares Boilerplate
+import libcalamares
+libcalamares.globalstorage = libcalamares.GlobalStorage(None)
+libcalamares.globalstorage.insert("testing", True)
+
+# Module prep-work
+from src.modules.displaymanager import main
+default_desktop_environment = main.DesktopEnvironment("startplasma-x11", "kde-plasma.desktop")
+
+import os
+os.makedirs("/tmp/etc/greetd/", exist_ok=True)
+try:
+    os.remove("/tmp/etc/greetd/config.toml")
+except FileNotFoundError as e:
+    pass
+
+try:
+    import toml
+except ImportError:
+    # This is a failure of the test-environment.
+    import sys
+    print("Can't find module toml.", file=sys.stderr)
+    sys.exit(0)
+
+# Specific DM test
+d = main.DMgreetd("/tmp")
+d.set_autologin("d", True, default_desktop_environment)
+# .. and again (this time checks load/save)
+d.set_autologin("d", True, default_desktop_environment)
+d.set_autologin("d", True, default_desktop_environment)

archive/snigdhaos-calamares/modules/displaymanager/tests/test-dm-sddm.py

@@ -0,0 +1,18 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Calamares Boilerplate
+import libcalamares
+libcalamares.globalstorage = libcalamares.GlobalStorage(None)
+libcalamares.globalstorage.insert("testing", True)
+
+# Module prep-work
+from src.modules.displaymanager import main
+default_desktop_environment = main.DesktopEnvironment("startplasma-x11", "kde-plasma.desktop")
+
+# Specific DM test
+d = main.DMsddm("/tmp")
+d.set_autologin("d", True, default_desktop_environment)
+# .. and again (this time checks load/save)
+d.set_autologin("d", True, default_desktop_environment)
+d.set_autologin("d", True, default_desktop_environment)

archive/snigdhaos-calamares/modules/packages/main.py

@@ -0,0 +1,819 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# === This file is part of Calamares - <https://calamares.io> ===
+#
+#   SPDX-FileCopyrightText: 2014 Pier Luigi Fiorini <pierluigi.fiorini@gmail.com>
+#   SPDX-FileCopyrightText: 2015-2017 Teo Mrnjavac <teo@kde.org>
+#   SPDX-FileCopyrightText: 2016-2017 Kyle Robbertze <kyle@aims.ac.za>
+#   SPDX-FileCopyrightText: 2017 Alf Gaida <agaida@siduction.org>
+#   SPDX-FileCopyrightText: 2018 Adriaan de Groot <groot@kde.org>
+#   SPDX-FileCopyrightText: 2018 Philip Müller <philm@manjaro.org>
+#   SPDX-License-Identifier: GPL-3.0-or-later
+#
+#   Calamares is Free Software: see the License-Identifier above.
+#
+
+import abc
+from string import Template
+import subprocess
+
+import libcalamares
+from libcalamares.utils import check_target_env_call, target_env_call
+from libcalamares.utils import gettext_path, gettext_languages
+
+import gettext
+_translation = gettext.translation("calamares-python",
+                                   localedir=gettext_path(),
+                                   languages=gettext_languages(),
+                                   fallback=True)
+_ = _translation.gettext
+_n = _translation.ngettext
+
+
+total_packages = 0  # For the entire job
+completed_packages = 0  # Done so far for this job
+group_packages = 0  # One group of packages from an -install or -remove entry
+
+# A PM object may set this to a string (take care of translations!)
+# to override the string produced by pretty_status_message()
+custom_status_message = None
+
+INSTALL = object()
+REMOVE = object()
+mode_packages = None  # Changes to INSTALL or REMOVE
+
+
+def _change_mode(mode):
+    global mode_packages
+    mode_packages = mode
+    libcalamares.job.setprogress(completed_packages * 1.0 / total_packages)
+
+
+def pretty_name():
+    return _("Install packages.")
+
+
+def pretty_status_message():
+    if custom_status_message is not None:
+        return custom_status_message
+    if not group_packages:
+        if (total_packages > 0):
+            # Outside the context of an operation
+            s = _("Processing packages (%(count)d / %(total)d)")
+        else:
+            s = _("Install packages.")
+
+    elif mode_packages is INSTALL:
+        s = _n("Installing one package.",
+               "Installing %(num)d packages.", group_packages)
+    elif mode_packages is REMOVE:
+        s = _n("Removing one package.",
+               "Removing %(num)d packages.", group_packages)
+    else:
+        # No mode, generic description
+        s = _("Install packages.")
+
+    return s % {"num": group_packages,
+                "count": completed_packages,
+                "total": total_packages}
+
+
+class PackageManager(metaclass=abc.ABCMeta):
+    """
+    Package manager base class. A subclass implements package management
+    for a specific backend, and must have a class property `backend`
+    with the string identifier for that backend.
+
+    Subclasses are collected below to populate the list of possible
+    backends.
+    """
+    backend = None
+
+    @abc.abstractmethod
+    def install(self, pkgs, from_local=False):
+        """
+        Install a list of packages (named) into the system.
+        Although this handles lists, in practice it is called
+        with one package at a time.
+
+        @param pkgs: list[str]
+            list of package names
+        @param from_local: bool
+            if True, then these are local packages (on disk) and the
+            pkgs names are paths.
+        """
+        pass
+
+    @abc.abstractmethod
+    def remove(self, pkgs):
+        """
+        Removes packages.
+
+        @param pkgs: list[str]
+            list of package names
+        """
+        pass
+
+    @abc.abstractmethod
+    def update_db(self):
+        pass
+
+    def run(self, script):
+        if script != "":
+            check_target_env_call(script.split(" "))
+
+    def install_package(self, packagedata, from_local=False):
+        """
+        Install a package from a single entry in the install list.
+        This can be either a single package name, or an object
+        with pre- and post-scripts. If @p packagedata is a dict,
+        it is assumed to follow the documented structure.
+
+        @param packagedata: str|dict
+        @param from_local: bool
+            see install.from_local
+        """
+        if isinstance(packagedata, str):
+            self.install([packagedata], from_local=from_local)
+        else:
+            self.run(packagedata["pre-script"])
+            self.install([packagedata["package"]], from_local=from_local)
+            self.run(packagedata["post-script"])
+
+    def remove_package(self, packagedata):
+        """
+        Remove a package from a single entry in the remove list.
+        This can be either a single package name, or an object
+        with pre- and post-scripts. If @p packagedata is a dict,
+        it is assumed to follow the documented structure.
+
+        @param packagedata: str|dict
+        """
+        if isinstance(packagedata, str):
+            self.remove([packagedata])
+        else:
+            self.run(packagedata["pre-script"])
+            self.remove([packagedata["package"]])
+            self.run(packagedata["post-script"])
+
+    def operation_install(self, package_list, from_local=False):
+        """
+        Installs the list of packages named in @p package_list .
+        These can be strings -- plain package names -- or
+        structures (with a pre- and post-install step).
+
+        This operation is called for "critical" packages,
+        which are expected to succeed, or fail, all together.
+        However, if there are packages with pre- or post-scripts,
+        then packages are installed one-by-one instead.
+
+        NOTE: package managers may reimplement this method
+        NOTE: exceptions are expected to leave this method, to indicate
+              failure of the installation.
+        """
+        if all([isinstance(x, str) for x in package_list]):
+            self.install(package_list, from_local=from_local)
+        else:
+            for package in package_list:
+                self.install_package(package, from_local=from_local)
+
+    def operation_try_install(self, package_list):
+        """
+        Installs the list of packages named in @p package_list .
+        These can be strings -- plain package names -- or
+        structures (with a pre- and post-install step).
+
+        This operation is called for "non-critical" packages,
+        which can succeed or fail without affecting the overall installation.
+        Packages are installed one-by-one to support package managers
+        that do not have a "install as much as you can" mode.
+
+        NOTE: package managers may reimplement this method
+        NOTE: no package-installation exceptions should be raised
+        """
+        # we make a separate package manager call for each package so a
+        # single failing package won't stop all of them
+        for package in package_list:
+            try:
+                self.install_package(package)
+            except subprocess.CalledProcessError:
+                libcalamares.utils.warning("Could not install package %s" % package)
+
+    def operation_remove(self, package_list):
+        """
+        Removes the list of packages named in @p package_list .
+        These can be strings -- plain package names -- or
+        structures (with a pre- and post-install step).
+
+        This operation is called for "critical" packages, which are
+        expected to succeed or fail all together.
+        However, if there are packages with pre- or post-scripts,
+        then packages are removed one-by-one instead.
+
+        NOTE: package managers may reimplement this method
+        NOTE: exceptions should be raised to indicate failure
+        """
+        if all([isinstance(x, str) for x in package_list]):
+            self.remove(package_list)
+        else:
+            for package in package_list:
+                self.remove_package(package)
+
+    def operation_try_remove(self, package_list):
+        """
+        Same relation as try_install has to install, except it removes
+        packages instead. Packages are removed one-by-one.
+
+        NOTE: package managers may reimplement this method
+        NOTE: no package-installation exceptions should be raised
+        """
+        for package in package_list:
+            try:
+                self.remove_package(package)
+            except subprocess.CalledProcessError:
+                libcalamares.utils.warning("Could not remove package %s" % package)
+
+### PACKAGE MANAGER IMPLEMENTATIONS
+#
+# Keep these alphabetical (presumably both by class name and backend name),
+# even the Dummy implementation.
+#
+
+class PMApk(PackageManager):
+    backend = "apk"
+
+    def install(self, pkgs, from_local=False):
+        for pkg in pkgs:
+            check_target_env_call(["apk", "add", pkg])
+
+    def remove(self, pkgs):
+        for pkg in pkgs:
+            check_target_env_call(["apk", "del", pkg])
+
+    def update_db(self):
+        check_target_env_call(["apk", "update"])
+
+    def update_system(self):
+        check_target_env_call(["apk", "upgrade", "--available"])
+
+
+class PMApt(PackageManager):
+    backend = "apt"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["apt-get", "-q", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["apt-get", "--purge", "-q", "-y",
+                               "remove"] + pkgs)
+        check_target_env_call(["apt-get", "--purge", "-q", "-y",
+                               "autoremove"])
+
+    def update_db(self):
+        check_target_env_call(["apt-get", "update"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+class PMDnf(PackageManager):
+    """
+    This is "legacy" DNF, called DNF-4 even though the
+    executable is dnf-3 in modern Fedora. Executable dnf
+    is a symlink to dnf-3 in systems that use it.
+    """
+    backend = "dnf"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["dnf-3", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        # ignore the error code for now because dnf thinks removing a
+        # nonexistent package is an error
+        target_env_call(["dnf-3", "--disablerepo=*", "-C", "-y",
+                         "remove"] + pkgs)
+
+    def update_db(self):
+        # Doesn't need updates
+        pass
+
+    def update_system(self):
+        check_target_env_call(["dnf-3", "-y", "upgrade"])
+
+
+class PMDnf5(PackageManager):
+    """
+    This is "modern" DNF, DNF-5 which is for Fedora 41 (presumably)
+    and later. Executable dnf is a symlink to dnf5 in systems that use it.
+    """
+    backend = "dnf5"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["dnf5", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        # ignore the error code for now because dnf thinks removing a
+        # nonexistent package is an error
+        target_env_call(["dnf5", "--disablerepo=*", "-C", "-y",
+                         "remove"] + pkgs)
+
+    def update_db(self):
+        # Doesn't need updates
+        pass
+
+    def update_system(self):
+        check_target_env_call(["dnf5", "-y", "upgrade"])
+
+
+class PMDummy(PackageManager):
+    backend = "dummy"
+
+    def install(self, pkgs, from_local=False):
+        from time import sleep
+        libcalamares.utils.debug("Dummy backend: Installing " + str(pkgs))
+        sleep(3)
+
+    def remove(self, pkgs):
+        from time import sleep
+        libcalamares.utils.debug("Dummy backend: Removing " + str(pkgs))
+        sleep(3)
+
+    def update_db(self):
+        libcalamares.utils.debug("Dummy backend: Updating DB")
+
+    def update_system(self):
+        libcalamares.utils.debug("Dummy backend: Updating System")
+
+    def run(self, script):
+        libcalamares.utils.debug("Dummy backend: Running script '" + str(script) + "'")
+
+
+class PMEntropy(PackageManager):
+    backend = "entropy"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["equo", "i"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["equo", "rm"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["equo", "update"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+class PMFlatpak(PackageManager):
+    backend = "flatpak"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["flatpak", "install", "--assumeyes"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["flatpak", "uninstall", "--noninteractive"] + pkgs)
+
+    def update_db(self):
+        pass
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+class PMLuet(PackageManager):
+    backend = "luet"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["luet", "install", "-y"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["luet", "uninstall", "-y"] + pkgs)
+
+    def update_db(self):
+          # Luet checks for DB update everytime its ran.
+        pass
+
+    def update_system(self):
+        check_target_env_call(["luet", "upgrade", "-y"])
+
+
+class PMPackageKit(PackageManager):
+    backend = "packagekit"
+
+    def install(self, pkgs, from_local=False):
+        for pkg in pkgs:
+            check_target_env_call(["pkcon", "-py", "install", pkg])
+
+    def remove(self, pkgs):
+        for pkg in pkgs:
+            check_target_env_call(["pkcon", "-py", "remove", pkg])
+
+    def update_db(self):
+        check_target_env_call(["pkcon", "refresh"])
+
+    def update_system(self):
+        check_target_env_call(["pkcon", "-py", "update"])
+
+
+class PMPacman(PackageManager):
+    backend = "pacman"
+
+    def __init__(self):
+        import re
+        progress_match = re.compile("^\\((\\d+)/(\\d+)\\)")
+
+        def line_cb(line):
+            if line.startswith(":: "):
+                self.in_package_changes = "package" in line or "hooks" in line
+            else:
+                if self.in_package_changes and line.endswith("...\n"):
+                    # Update the message, untranslated; do not change the
+                    # progress percentage, since there may be more "installing..."
+                    # lines in the output for the group, than packages listed
+                    # explicitly. We don't know how to calculate proper progress.
+                    global custom_status_message
+                    custom_status_message = "pacman: " + line.strip()
+                    libcalamares.job.setprogress(self.progress_fraction)
+            libcalamares.utils.debug(line)
+
+        self.in_package_changes = False
+        self.line_cb = line_cb
+
+        pacman = libcalamares.job.configuration.get("pacman", None)
+        if pacman is None:
+            pacman = dict()
+        if type(pacman) is not dict:
+            libcalamares.utils.warning("Job configuration *pacman* will be ignored.")
+            pacman = dict()
+        self.pacman_num_retries = pacman.get("num_retries", 0)
+        self.pacman_disable_timeout = pacman.get("disable_download_timeout", False)
+        self.pacman_needed_only = pacman.get("needed_only", False)
+
+    def reset_progress(self):
+        self.in_package_changes = False
+        # These are globals
+        self.progress_fraction = (completed_packages * 1.0 / total_packages)
+
+    def run_pacman(self, command, callback=False):
+        """
+        Call pacman in a loop until it is successful or the number of retries is exceeded
+        :param command: The pacman command to run
+        :param callback: An optional boolean that indicates if this pacman run should use the callback
+        :return:
+        """
+
+        pacman_count = 0
+        while pacman_count <= self.pacman_num_retries:
+            pacman_count += 1
+            try:
+                if False: # callback:
+                    libcalamares.utils.target_env_process_output(command, self.line_cb)
+                else:
+                    libcalamares.utils.target_env_process_output(command)
+
+                return
+            except subprocess.CalledProcessError:
+                if pacman_count <= self.pacman_num_retries:
+                    pass
+                else:
+                    raise
+
+    def install(self, pkgs, from_local=False):
+        command = ["pacman"]
+
+        if from_local:
+            command.append("-U")
+        else:
+            command.append("-S")
+
+        # Don't ask for user intervention, take the default action
+        command.append("--noconfirm")
+
+        # Don't report download progress for each file
+        command.append("--noprogressbar")
+
+        if self.pacman_needed_only is True:
+            command.append("--needed")
+            command.append("--ask=4")
+
+        if self.pacman_disable_timeout is True:
+            command.append("--disable-download-timeout")
+
+        command += pkgs
+
+        self.reset_progress()
+        self.run_pacman(command, True)
+
+    def remove(self, pkgs):
+        self.reset_progress()
+        self.run_pacman(["pacman", "-Rs", "--noconfirm"] + pkgs, True)
+
+    def update_db(self):
+        self.run_pacman(["pacman", "-Sy"])
+
+    def update_system(self):
+        self.run_pacman(["pacman", "-S", "archlinux-keyring", "--noconfirm"])
+        command = ["pacman", "-Su", "--noconfirm"]
+        if self.pacman_disable_timeout is True:
+            command.append("--disable-download-timeout")
+
+        self.run_pacman(command)
+
+
+class PMPamac(PackageManager):
+    backend = "pamac"
+
+    def del_db_lock(self, lock="/var/lib/pacman/db.lck"):
+        # In case some error or crash, the database will be locked,
+        # resulting in remaining packages not being installed.
+        check_target_env_call(["rm", "-f", lock])
+
+    def install(self, pkgs, from_local=False):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "install", "--no-confirm"] + pkgs)
+
+    def remove(self, pkgs):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "remove", "--no-confirm"] + pkgs)
+
+    def update_db(self):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "update", "--no-confirm"])
+
+    def update_system(self):
+        self.del_db_lock()
+        check_target_env_call([self.backend, "upgrade", "--no-confirm"])
+
+
+class PMPisi(PackageManager):
+    backend = "pisi"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["pisi", "install" "-y"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["pisi", "remove", "-y"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["pisi", "update-repo"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+class PMPortage(PackageManager):
+    backend = "portage"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["emerge", "-v"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["emerge", "-C"] + pkgs)
+        check_target_env_call(["emerge", "--depclean", "-q"])
+
+    def update_db(self):
+        check_target_env_call(["emerge", "--sync"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+class PMXbps(PackageManager):
+    backend = "xbps"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["xbps-install", "-Sy"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["xbps-remove", "-Ry", "--noconfirm"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["xbps-install", "-S"])
+
+    def update_system(self):
+        check_target_env_call(["xbps", "-Suy"])
+
+
+class PMYum(PackageManager):
+    backend = "yum"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["yum", "-y", "install"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["yum", "--disablerepo=*", "-C", "-y",
+                               "remove"] + pkgs)
+
+    def update_db(self):
+        # Doesn't need updates
+        pass
+
+    def update_system(self):
+        check_target_env_call(["yum", "-y", "upgrade"])
+
+
+class PMZypp(PackageManager):
+    backend = "zypp"
+
+    def install(self, pkgs, from_local=False):
+        check_target_env_call(["zypper", "--non-interactive",
+                               "--quiet-install", "install",
+                               "--auto-agree-with-licenses",
+                               "install"] + pkgs)
+
+    def remove(self, pkgs):
+        check_target_env_call(["zypper", "--non-interactive",
+                               "remove"] + pkgs)
+
+    def update_db(self):
+        check_target_env_call(["zypper", "--non-interactive", "update"])
+
+    def update_system(self):
+        # Doesn't need to update the system explicitly
+        pass
+
+
+# Collect all the subclasses of PackageManager defined above,
+# and index them based on the backend property of each class.
+backend_managers = [
+    (c.backend, c)
+    for c in globals().values()
+    if type(c) is abc.ABCMeta and issubclass(c, PackageManager) and c.backend]
+
+
+def subst_locale(plist):
+    """
+    Returns a locale-aware list of packages, based on @p plist.
+    Package names that contain LOCALE are localized with the
+    BCP47 name of the chosen system locale; if the system
+    locale is 'en' (e.g. English, US) then these localized
+    packages are dropped from the list.
+
+    @param plist: list[str|dict]
+        Candidate packages to install.
+    @return: list[str|dict]
+    """
+    locale = libcalamares.globalstorage.value("locale")
+    if not locale:
+        # It is possible to skip the locale-setting entirely.
+        # Then pretend it is "en", so that {LOCALE}-decorated
+        # package names are removed from the list.
+        locale = "en"
+
+    ret = []
+    for packagedata in plist:
+        if isinstance(packagedata, str):
+            packagename = packagedata
+        else:
+            packagename = packagedata["package"]
+
+        # Update packagename: substitute LOCALE, and drop packages
+        # if locale is en and LOCALE is in the package name.
+        if locale != "en":
+            packagename = Template(packagename).safe_substitute(LOCALE=locale)
+        elif 'LOCALE' in packagename:
+            packagename = None
+
+        if packagename is not None:
+            # Put it back in packagedata
+            if isinstance(packagedata, str):
+                packagedata = packagename
+            else:
+                packagedata["package"] = packagename
+
+            ret.append(packagedata)
+
+    return ret
+
+
+def run_operations(pkgman, entry):
+    """
+    Call package manager with suitable parameters for the given
+    package actions.
+
+    :param pkgman: PackageManager
+        This is the manager that does the actual work.
+    :param entry: dict
+        Keys are the actions -- e.g. "install" -- to take, and the values
+        are the (list of) packages to apply the action to. The actions are
+        not iterated in a specific order, so it is recommended to use only
+        one action per dictionary. The list of packages may be package
+        names (strings) or package information dictionaries with pre-
+        and post-scripts.
+    """
+    global group_packages, completed_packages, mode_packages
+
+    for key in entry.keys():
+        package_list = subst_locale(entry[key])
+        group_packages = len(package_list)
+        if key == "install":
+            _change_mode(INSTALL)
+            pkgman.operation_install(package_list)
+        elif key == "try_install":
+            _change_mode(INSTALL)
+            pkgman.operation_try_install(package_list)
+        elif key == "remove":
+            _change_mode(REMOVE)
+            pkgman.operation_remove(package_list)
+        elif key == "try_remove":
+            _change_mode(REMOVE)
+            pkgman.operation_try_remove(package_list)
+        elif key == "localInstall":
+            _change_mode(INSTALL)
+            pkgman.operation_install(package_list, from_local=True)
+        elif key == "source":
+            libcalamares.utils.debug("Package-list from {!s}".format(entry[key]))
+        else:
+            libcalamares.utils.warning("Unknown package-operation key {!s}".format(key))
+        completed_packages += len(package_list)
+        libcalamares.job.setprogress(completed_packages * 1.0 / total_packages)
+        libcalamares.utils.debug("Pretty name: {!s}, setting progress..".format(pretty_name()))
+
+    group_packages = 0
+    _change_mode(None)
+
+
+def run():
+    """
+    Calls routine with detected package manager to install locale packages
+    or remove drivers not needed on the installed system.
+
+    :return:
+    """
+    global mode_packages, total_packages, completed_packages, group_packages
+
+    backend = libcalamares.job.configuration.get("backend")
+
+    for identifier, impl in backend_managers:
+        if identifier == backend:
+            pkgman = impl()
+            break
+    else:
+        return "Bad backend", "backend=\"{}\"".format(backend)
+
+    skip_this = libcalamares.job.configuration.get("skip_if_no_internet", False)
+    if skip_this and not libcalamares.globalstorage.value("hasInternet"):
+        libcalamares.utils.warning( "Package installation has been skipped: no internet" )
+        return None
+
+    update_db = libcalamares.job.configuration.get("update_db", False)
+    if update_db and libcalamares.globalstorage.value("hasInternet"):
+        try:
+            pkgman.update_db()
+        except subprocess.CalledProcessError as e:
+            libcalamares.utils.warning(str(e))
+            libcalamares.utils.debug("stdout:" + str(e.stdout))
+            libcalamares.utils.debug("stderr:" + str(e.stderr))
+            return (_("Package Manager error"),
+                    _("The package manager could not prepare updates. The command <pre>{!s}</pre> returned error code {!s}.")
+                    .format(e.cmd, e.returncode))
+
+    update_system = libcalamares.job.configuration.get("update_system", False)
+    if update_system and libcalamares.globalstorage.value("hasInternet"):
+        try:
+            pkgman.update_system()
+        except subprocess.CalledProcessError as e:
+            libcalamares.utils.warning(str(e))
+            libcalamares.utils.debug("stdout:" + str(e.stdout))
+            libcalamares.utils.debug("stderr:" + str(e.stderr))
+            return (_("Package Manager error"),
+                    _("The package manager could not update the system. The command <pre>{!s}</pre> returned error code {!s}.")
+                    .format(e.cmd, e.returncode))
+
+    operations = libcalamares.job.configuration.get("operations", [])
+    if libcalamares.globalstorage.contains("packageOperations"):
+        operations += libcalamares.globalstorage.value("packageOperations")
+
+    mode_packages = None
+    total_packages = 0
+    completed_packages = 0
+    for op in operations:
+        for packagelist in op.values():
+            total_packages += len(subst_locale(packagelist))
+
+    if not total_packages:
+        # Avoids potential divide-by-zero in progress reporting
+        return None
+
+    for entry in operations:
+        group_packages = 0
+        libcalamares.utils.debug(pretty_name())
+        try:
+            run_operations(pkgman, entry)
+        except subprocess.CalledProcessError as e:
+            libcalamares.utils.warning(str(e))
+            libcalamares.utils.debug("stdout:" + str(e.stdout))
+            libcalamares.utils.debug("stderr:" + str(e.stderr))
+            return (_("Package Manager error"),
+                    _("The package manager could not make changes to the installed system. The command <pre>{!s}</pre> returned error code {!s}.")
+                    .format(e.cmd, e.returncode))
+
+    mode_packages = None
+
+    libcalamares.job.setprogress(1.0)
+
+    return None

archive/snigdhaos-calamares/modules/packages/module.desc

@@ -0,0 +1,7 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+---
+type:       "job"
+name:       "packages"
+interface:  "python"
+script:     "main.py"

archive/snigdhaos-calamares/modules/packages/packages.schema.yaml

@@ -0,0 +1,54 @@
+# SPDX-FileCopyrightText: 2020 Adriaan de Groot <groot@kde.org>
+# SPDX-License-Identifier: GPL-3.0-or-later
+---
+$schema: https://json-schema.org/schema#
+$id: https://calamares.io/schemas/packages
+additionalProperties: false
+type: object
+properties:
+    backend:
+        type: string
+        enum:
+            - apk
+            - apt
+            - dnf
+            - dnf5
+            - entropy
+            - luet
+            - packagekit
+            - pacman
+            - pamac
+            - portage
+            - yum
+            - zypp
+            - dummy
+
+    update_db: { type: boolean, default: true }
+    update_system: { type: boolean, default: false }
+    skip_if_no_internet: { type: boolean, default: false }
+
+    pacman:
+        additionalProperties: false
+        type: object
+        properties:
+            num_retries: { type: integer, default: 0 }
+            disable_download_timeout: { type: boolean, default: false }
+            needed_only: { type: boolean, default: false }
+
+    operations:
+        type: array
+        items:
+            additionalProperties: false
+            type: object
+            properties:
+                # TODO: these are either-string-or-struct items,
+                #       need their own little schema.
+                install: { type: array }
+                remove: { type: array }
+                try_install: { type: array }
+                try_remove: { type: array }
+                localInstall: { type: array }
+                source: { type: string }
+
+
+required: [ backend ]

archive/snigdhaos-calamares/modules/packages/tests/1.global

@@ -0,0 +1,3 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+rootMountPoint: /tmp

archive/snigdhaos-calamares/modules/packages/tests/2.job

@@ -0,0 +1,13 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+backend: dummy
+operations:
+  - install:
+    - pre-script: touch /tmp/foo
+      package: vi
+      post-script: rm /tmp/foo
+    - wget
+    - binutils
+  - remove:
+    - vi
+    - wget

archive/snigdhaos-calamares/modules/packages/tests/CMakeTests.txt

@@ -0,0 +1,46 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# We have tests to load (some) of the package-managers specifically, to
+# test their configuration code and implementation. Those tests conventionally
+# live in Python files here in the tests/ directory. Add them.
+
+# Pacman (Arch) tests
+set(_pm pacman)
+add_test(
+    NAME configure-packages-${_pm}
+    COMMAND env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-pm-${_pm}.py
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+)
+add_test(
+    NAME configure-packages-${_pm}-ops-1
+    COMMAND
+        env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-pm-${_pm}.py ${CMAKE_CURRENT_LIST_DIR}/pm-pacman-1.yaml
+        4 1 1
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+)
+add_test(
+    NAME configure-packages-${_pm}-ops-2
+    COMMAND
+        env PYTHONPATH=.: python3 ${CMAKE_CURRENT_LIST_DIR}/test-pm-${_pm}.py ${CMAKE_CURRENT_LIST_DIR}/pm-pacman-2.yaml
+        3 0 0
+    WORKING_DIRECTORY ${CMAKE_BINARY_DIR}
+)
+
+if(BUILD_TESTING AND BUILD_SCHEMA_TESTING AND Python_Interpreter_FOUND)
+    set(_module packages)
+    set(_schema_file "${CMAKE_CURRENT_SOURCE_DIR}/${_module}/${_module}.schema.yaml")
+    message(STATUS "Schema ${_schema_file}")
+    foreach(_cf pm-pacman-1.yaml pm-pacman-2.yaml)
+        set(_conf_file "${CMAKE_CURRENT_SOURCE_DIR}/${_module}/tests/${_cf}")
+        if(EXISTS "${_schema_file}" AND EXISTS "${_conf_file}")
+            add_test(
+                NAME validate-packages-${_cf}
+                COMMAND
+                    ${Python_EXECUTABLE} "${CMAKE_SOURCE_DIR}/ci/configvalidator.py" "${_schema_file}" "${_conf_file}"
+            )
+        else()
+            message(FATAL_ERROR "Missing ${_conf_file}")
+        endif()
+    endforeach()
+endif()

archive/snigdhaos-calamares/modules/packages/tests/pm-pacman-1.yaml

@@ -0,0 +1,10 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+backend: pacman
+operations: []
+
+pacman:
+    num_retries: 4
+    disable_download_timeout: true
+    needed_only: true
+

archive/snigdhaos-calamares/modules/packages/tests/pm-pacman-2.yaml

@@ -0,0 +1,9 @@
+# SPDX-FileCopyrightText: no
+# SPDX-License-Identifier: CC0-1.0
+backend: pacman
+operations: []
+
+# Leave some things unspecified
+pacman:
+    num_retries: 3
+

archive/snigdhaos-calamares/modules/packages/tests/test-pm-pacman.py

@@ -0,0 +1,36 @@
+#   SPDX-FileCopyrightText: no
+#   SPDX-License-Identifier: CC0-1.0
+#
+# Calamares Boilerplate
+import libcalamares
+libcalamares.globalstorage = libcalamares.GlobalStorage(None)
+libcalamares.globalstorage.insert("testing", True)
+
+# Module prep-work
+from src.modules.packages import main
+
+# .. we don't have a job in this test, so fake one
+class Job(object):
+    def __init__(self, filename):
+        self.configuration = libcalamares.utils.load_yaml(filename) if filename is not None else dict()
+
+import sys
+if len(sys.argv) > 4:
+    filename = sys.argv[1]
+    retry = int(sys.argv[2])
+    timeout = bool(int(sys.argv[3]))
+    needed = bool(int(sys.argv[4]))
+else:
+    filename = None
+    retry = 0
+    timeout = False
+    needed = False
+
+libcalamares.utils.warning("Expecting {!s} retry={!s} timeout={!s} needed={!s}".format(filename, retry, timeout, needed))
+
+# Specific PM test
+libcalamares.job = Job(filename)
+p = main.PMPacman()
+assert p.pacman_num_retries == retry, "{!r} vs {!r}".format(p.pacman_num_retries, retry)
+assert p.pacman_disable_timeout == timeout, "{!r} vs {!r}".format(p.pacman_disable_timeout, timeout)
+assert p.pacman_needed_only == needed, "{!r} vs {!r}".format(p.pacman_needed_only, needed)

archive/snigdhaos-calamares/modules/ucode/main.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+#
+# === This file is part of Calamares - <http://github.com/calamares> ===
+#
+#   Copyright 2014 - 2019, Philip Müller <philm@manjaro.org>
+#   Copyright 2016, Artoo <artoo@manjaro.org>
+#
+#   Calamares is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU General Public License as published by
+#   the Free Software Foundation, either version 3 of the License, or
+#   (at your option) any later version.
+#
+#   Calamares is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+#   GNU General Public License for more details.
+#
+#   You should have received a copy of the GNU General Public License
+#   along with Calamares. If not, see <http://www.gnu.org/licenses/>.
+
+import libcalamares
+import subprocess
+
+from shutil import copy2
+from distutils.dir_util import copy_tree
+from os.path import join, exists
+from libcalamares.utils import target_env_call
+
+
+class ConfigController:
+    def __init__(self):
+        self.__root = libcalamares.globalstorage.value("rootMountPoint")
+        self.__keyrings = libcalamares.job.configuration.get('keyrings', [])
+
+    @property
+    def root(self):
+        return self.__root
+
+    @property
+    def keyrings(self):
+        return self.__keyrings
+
+    def init_keyring(self):
+        target_env_call(["pacman-key", "--init"])
+
+    def populate_keyring(self):
+        target_env_call(["pacman-key", "--populate"] + self.keyrings)
+
+    def terminate(self, proc):
+        target_env_call(['killall', '-9', proc])
+
+    def copy_file(self, file):
+        if exists("/" + file):
+            copy2("/" + file, join(self.root, file))
+
+    def copy_folder(self, source, target):
+        if exists("/" + source):
+            copy_tree("/" + source, join(self.root, target))
+
+    def remove_pkg(self, pkg, path):
+        if exists(join(self.root, path)):
+            target_env_call(['pacman', '-R', '--noconfirm', pkg])
+
+    def umount(self, mp):
+        subprocess.call(["umount", "-l", join(self.root, mp)])
+
+    def mount(self, mp):
+        subprocess.call(["mount", "-B", "/" + mp, join(self.root, mp)])
+
+    def rmdir(self, dir):
+        subprocess.call(["rm", "-Rf", join(self.root, dir)])
+
+    def mkdir(self, dir):
+        subprocess.call(["mkdir", "-p", join(self.root, dir)])
+
+    def run(self):
+
+        # ucode
+        cpu_ucode = subprocess.getoutput("hwinfo --cpu | grep Vendor: -m1 | cut -d\'\"\' -f2")
+        if cpu_ucode == "AuthenticAMD":
+            #target_env_call(["pacman", "-S", "amd-ucode", "--noconfirm"])
+            target_env_call(["pacman", "-R", "intel-ucode", "--noconfirm"])
+        elif cpu_ucode == "GenuineIntel":
+            #target_env_call(["pacman", "-S", "intel-ucode", "--noconfirm"])
+            target_env_call(["pacman", "-R", "amd-ucode", "--noconfirm"])
+
+        if exists(join(self.root, "usr/bin/snapper")):
+            target_env_call(["snapper", "-c", "root", "--no-dbus", "create-config", "/"])
+            target_env_call(["btrfs", "subvolume", "create", "/.snapshots"])
+            target_env_call(["chmod", "a+rx", "/.snapshots"])
+            target_env_call(["chown", ":users", "/.snapshots"])
+
+def run():
+    """ Post installation configurations  """
+
+    config = ConfigController()
+
+    return config.run()

archive/snigdhaos-calamares/modules/ucode/module.desc

@@ -0,0 +1,6 @@
+# Syntax is YAML 1.2
+---
+type:       "job"
+name:       "ucode"
+interface:  "python"
+script:     "main.py"   #assumed relative to the current directory

archive/snigdhaos-calamares/snigdhaos-calamares-debug.desktop

@@ -0,0 +1,240 @@
+[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Install Snigdha OS Debug
+Comment=Installer for Snigdha OS debug
+GenericName=System Installer
+Keywords=calamares;system;installer;
+TryExec=/usr/bin/calamares_polkit %f -d -style breeze
+Exec=/usr/bin/calamares_polkit %f -d -style breeze
+Icon=snigdhaos-calamares
+Terminal=false
+Type=Application
+StartupNotify=true
+Categories=GTK;Settings;Security;X-GNOME-Settings-Panel;X-GNOME-SystemSettings;X-Unity-Settings-Panel;X-XFCE-SettingsDialog;X-XFCE-SystemSettings;Utility;System;Filesystem;GNOME;Qt;KDE;
+X-AppStream-Ignore=true
+
+Name[ar]=تثبيت النظام 
+Icon[ar]=كالامارس
+GenericName[ar]=مثبت النظام
+Comment[ar]=كالامارس - مثبت النظام
+Name[as]=চিছটেম ইনস্তল কৰক
+Icon[as]=কেলামাৰেচ
+GenericName[as]=চিছটেম ইনস্তলাৰ
+Comment[as]=কেলামাৰেচ — চিছটেম​ ইনস্তলাৰ
+Name[az]=Sistemi Quraşdırmaq
+Icon[az]=calamares
+GenericName[az]=Sistem Quraşdırıcısı
+Comment[az]=Calamares Sistem Quraşdırıcısı
+Name[be]=Усталяваць сістэму
+Icon[be]=calamares
+GenericName[be]=Усталёўшчык сістэмы
+Comment[be]=Calamares — усталёўшчык сістэмы
+Name[bg]=Инсталирай системата
+Icon[bg]=calamares
+GenericName[bg]=Системен Инсталатор
+Comment[bg]=Calamares — Системен Инсталатор
+Name[bn]=সিস্টেম ইনস্টল করুন
+Icon[bn]=ক্যালামারেস
+GenericName[bn]=সিস্টেম ইনস্টলার
+Comment[bn]=ক্যালামারেস - সিস্টেম ইনস্টলার
+Name[ca]=Instal·la el sistema
+Icon[ca]=calamares
+GenericName[ca]=Instal·lador de sistema
+Comment[ca]=Calamares — Instal·lador de sistema
+Name[da]=Installér system
+Icon[da]=calamares
+GenericName[da]=Systeminstallationsprogram
+Comment[da]=Calamares — Systeminstallationsprogram
+Name[de]=System installieren
+Icon[de]=calamares
+GenericName[de]=Installation des Betriebssystems
+Comment[de]=Calamares - Installation des Betriebssystems
+Name[el]=Εγκατάσταση συστήματος
+Icon[el]=calamares
+GenericName[el]=Εγκατάσταση συστήματος
+Comment[el]=Calamares — Εγκατάσταση συστήματος
+Name[en_GB]=Install System
+Icon[en_GB]=calamares
+GenericName[en_GB]=System Installer
+Comment[en_GB]=Calamares — System Installer
+Name[es]=Instalar Sistema
+Icon[es]=calamares
+GenericName[es]=Instalador del Sistema
+Comment[es]=Calamares — Instalador del Sistema
+Name[et]=Paigalda süsteem
+Icon[et]=calamares
+GenericName[et]=Süsteemipaigaldaja
+Comment[et]=Calamares — süsteemipaigaldaja
+Name[eu]=Sistema instalatu
+Icon[eu]=calamares
+GenericName[eu]=Sistema instalatzailea
+Comment[eu]=Calamares - sistema instalatzailea
+Name[fa]=نصب سامانه
+Icon[fa]=کالامارس
+GenericName[fa]=نصب‌کنندهٔ سامانه
+Comment[fa]=کالامارس — نصب‌کنندهٔ سامانه
+Name[es_PR]=Instalar el sistema
+Name[fr]=Installer le système
+Icon[fr]=calamares
+GenericName[fr]=Installateur système
+Comment[fr]=Calamares - Installateur système
+Name[fur]=Instale il sisteme
+Icon[fur]=calamares
+GenericName[fur]=Program di instalazion dal sisteme
+Comment[fur]=Calamares — Program di instalazion dal sisteme
+Name[gl]=Instalación do Sistema
+Icon[gl]=calamares
+GenericName[gl]=Instalador de sistemas
+Comment[gl]=Calamares — Instalador de sistemas
+Name[he]=התקנת מערכת
+Icon[he]=calamares
+GenericName[he]=אשף התקנה
+Comment[he]=Calamares - אשף התקנה
+Name[hi]=सिस्टम इंस्टॉल करें
+Icon[hi]=calamares
+GenericName[hi]=सिस्टम इंस्टॉलर
+Comment[hi]=Calamares — सिस्टम इंस्टॉलर
+Name[hr]=Instaliraj sustav
+Icon[hr]=calamares
+GenericName[hr]=Instalacija sustava
+Comment[hr]=Calamares — Instalacija sustava
+Name[ie]=Installar li sistema
+Icon[ie]=calamares
+GenericName[ie]=Installator del sistema
+Comment[ie]=Calamares — Installator del sistema
+Name[hu]=Rendszer telepítése
+Icon[hu]=calamares
+GenericName[hu]=Rendszertelepítő
+Comment[hu]=Calamares – Rendszertelepítő
+Name[id]=Instal Sistem
+Icon[id]=calamares
+GenericName[id]=Pemasang
+Comment[id]=Calamares — Pemasang Sistem
+Name[is]=Setja upp kerfið
+Icon[is]=calamares
+GenericName[is]=Kerfis uppsetning
+Comment[is]=Calamares — Kerfis uppsetning
+Name[cs_CZ]=Nainstalovat systém
+Icon[cs_CZ]=calamares
+GenericName[cs_CZ]=Instalátor systému
+Comment[cs_CZ]=Calamares – instalátor operačních systémů
+Name[ja]=システムをインストール
+Icon[ja]=calamares
+GenericName[ja]=システムインストーラー
+Comment[ja]=Calamares — システムインストーラー
+Name[ko]=시스템 설치
+Icon[ko]=깔라마레스
+GenericName[ko]=시스템 설치 관리자
+Comment[ko]=깔라마레스 — 시스템 설치 관리자
+Name[lt]=Įdiegti Sistemą
+Icon[lt]=calamares
+GenericName[lt]=Sistemos diegimas į kompiuterį
+Comment[lt]=Calamares — Sistemos diegimo programa
+Name[it_IT]=Installa il sistema
+Icon[it_IT]=calamares
+GenericName[it_IT]=Programma d'installazione del sistema
+Comment[it_IT]=Calamares — Programma d'installazione del sistema
+Name[mk]=Инсталирај го системот
+Icon[mk]=calamares
+GenericName[mk]=Системен Инсталер
+Comment[mk]=Calamares - Системен Инсталер
+Name[ml]=സിസ്റ്റം ഇൻസ്റ്റാൾ ചെയ്യുക
+Icon[ml]=കലാമാരേസ്
+GenericName[ml]=സിസ്റ്റം ഇൻസ്റ്റാളർ
+Comment[ml]=കലാമാരേസ് - സിസ്റ്റം ഇൻസ്റ്റാളർ
+Name[nb]=Installer System
+Icon[nb]=calamares
+GenericName[nb]=Systeminstallatør
+Comment[nb]=Calamares-systeminstallatør
+Name[nl]=Installeer systeem
+Icon[nl]=calamares
+GenericName[nl]=Installatieprogramma
+Comment[nl]=Calamares — Installatieprogramma
+Name[az_AZ]=Sistemi quraşdırmaq
+Icon[az_AZ]=calamares
+GenericName[az_AZ]=Sistem quraşdırcısı
+Comment[az_AZ]=Calamares — Sistem Quraşdırıcısı
+Name[pl]=Zainstaluj system
+Icon[pl]=calamares
+GenericName[pl]=Instalator systemu
+Comment[pl]=Calamares — Instalator systemu
+Name[pt_BR]=Sistema de Instalação
+Icon[pt_BR]=calamares
+GenericName[pt_BR]=Instalador de Sistema
+Comment[pt_BR]=Calamares — Instalador de Sistema
+Name[ro]=Instalează sistemul
+Icon[ro]=calamares
+GenericName[ro]=Instalator de sistem
+Comment[ro]=Calamares — Instalator de sistem
+Name[ru]=Установить систему
+Icon[ru]=calamares
+GenericName[ru]=Установщик системы
+Comment[ru]=Calamares - Установщик системы
+Name[sk]=Inštalovať systém
+Icon[sk]=calamares
+GenericName[sk]=Inštalátor systému
+Comment[sk]=Calamares — Inštalátor systému
+Name[sl]=Namesti sistem
+Name[sq]=Instalo Sistemin
+Icon[sq]=calamares
+GenericName[sq]=Instalues Sistemi
+Comment[sq]=Calamares — Instalues Sistemi
+Name[fi_FI]=Asenna Järjestelmä
+Icon[fi_FI]=calamares
+GenericName[fi_FI]=Järjestelmän Asennusohjelma
+Comment[fi_FI]=Calamares — Järjestelmän Asentaja
+Name[sr@latin]=Instaliraj sistem
+Name[sr]=Инсталирај систем
+Icon[sr]=calamares
+GenericName[sr]=Инсталатер система
+Comment[sr]=Каламарес — инсталатер система
+Name[sv]=Installera system
+Icon[sv]=calamares
+GenericName[sv]=Systeminstallerare
+Comment[sv]=Calamares — Systeminstallerare
+Name[tg]=Насбкунии низом
+Icon[tg]=calamares
+GenericName[tg]=Насбкунандаи низомӣ
+Comment[tg]=Calamares — Насбкунандаи низомӣ
+Name[th]=ติดตั้งระบบ
+Name[uk]=Встановити Систему
+Icon[uk]=calamares
+GenericName[uk]=Встановлювач системи
+Comment[uk]=Calamares - Встановлювач системи
+Name[vi]=Cài đặt hệ thống
+Icon[vi]=calamares
+GenericName[vi]=Bộ cài đặt hệ thống
+Comment[vi]=Calamares — Bộ cài đặt hệ thống
+Name[zh_CN]=安装系统
+Icon[zh_CN]=calamares
+GenericName[zh_CN]=系统安装程序
+Comment[zh_CN]=Calamares — 系统安装程序
+Name[zh_TW]=安裝系統
+Icon[zh_TW]=calamares
+GenericName[zh_TW]=系統安裝程式
+Comment[zh_TW]=Calamares ── 系統安裝程式
+Name[ast]=Instalar el sistema
+Icon[ast]=calamares
+GenericName[ast]=Instalador del sistema
+Comment[ast]=Calamares — Instalador del sistema
+Name[eo]=Instali Sistemo
+Icon[eo]=calamares
+GenericName[eo]=Sistema Instalilo
+Comment[eo]=Calamares — Sistema Instalilo
+Name[ne_NP]= सिस्टम इन्स्टल गर्नुहोस्
+Icon[ne_NP]=Calamares
+GenericName[ne_NP]=सिस्टम इन्स्टलर
+Comment[ne_NP]=Calamares - सिस्टम इन्स्टलर
+Name[es_MX]=Instalar el Sistema
+Icon[es_MX]=calamares
+GenericName[es_MX]=Instalador del sistema
+Comment[es_MX]=Calamares - Instalador del sistema
+Name[pt_PT]=Instalar Sistema
+Icon[pt_PT]=calamares
+GenericName[pt_PT]=Instalador de Sistema
+Comment[pt_PT]=Calamares - Instalador de Sistema
+Name[tr_TR]=Sistemi Yükle
+Icon[tr_TR]=calamares
+GenericName[tr_TR]=Sistem Yükleyici
+Comment[tr_TR]=Calamares — Sistem Yükleyici

archive/snigdhaos-calamares/snigdhaos-calamares.desktop

@@ -0,0 +1,14 @@
+[Desktop Entry]
+Type=Application
+Version=1.0
+Name=Install Snigdha OS
+GenericName=System Installer
+Comment=Installer for Snigdha OS
+Keywords=calamares;installer;system;setup;OS;
+TryExec=/usr/bin/calamares_polkit
+Exec=/usr/bin/calamares_polkit %f -style breeze
+Icon=snigdhaos-calamares
+Terminal=false
+StartupNotify=true
+Categories=System;Settings;Utility;Security;Qt;KDE;GTK;Filesystem;GNOME;
+X-AppStream-Ignore=true