<div style='background:#0a0a0a; color:#00ff41; font-family:monospace; padding:20px; max-width:900px; margin:20px auto; border:1px solid #00ff41;'><h2 style='color:#ffcc80;'>✏ EDIT: groups_manager.py</h2><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#1a1a1a; color:#00ff41; border:1px solid #00ff41; font-family:monospace; padding:10px;'># groups_manager.py
# DNF plugin for managing comps groups metadata files
#
# Copyright (C) 2020 Red Hat, Inc.
#
# This copyrighted material is made available to anyone wishing to use,
# modify, copy, or redistribute it subject to the terms and conditions of
# the GNU General Public License v.2, or (at your option) any later version.
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY expressed or implied, including the implied warranties 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 this program; if not, write to the
# Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
# 02110-1301, USA.  Any Red Hat trademarks that are incorporated in the
# source code or documentation are not subject to the GNU General Public
# License and may only be used or replicated with the express permission of
# Red Hat, Inc.
#

from __future__ import absolute_import
from __future__ import unicode_literals

import argparse
import gzip
import libcomps
import os
import re
import shutil
import tempfile

from dnfpluginscore import _, logger
import dnf
import dnf.cli


RE_GROUP_ID_VALID = &#039;-a-z0-9_.:&#039;
RE_GROUP_ID = re.compile(r&#039;^[{}]+$&#039;.format(RE_GROUP_ID_VALID))
RE_LANG = re.compile(r&#039;^[-a-zA-Z0-9_.@]+$&#039;)
COMPS_XML_OPTIONS = {
    &#039;default_explicit&#039;: True,
    &#039;uservisible_explicit&#039;: True,
    &#039;empty_groups&#039;: True}


def group_id_type(value):
    &#039;&#039;&#039;group id validator&#039;&#039;&#039;
    if not RE_GROUP_ID.match(value):
        raise argparse.ArgumentTypeError(_(&#039;Invalid group id&#039;))
    return value


def translation_type(value):
    &#039;&#039;&#039;translated texts validator&#039;&#039;&#039;
    data = value.split(&#039;:&#039;, 2)
    if len(data) != 2:
        raise argparse.ArgumentTypeError(
            _(&quot;Invalid translated data, should be in form &#039;lang:text&#039;&quot;))
    lang, text = data
    if not RE_LANG.match(lang):
        raise argparse.ArgumentTypeError(_(&#039;Invalid/empty language for translated data&#039;))
    return lang, text


def text_to_id(text):
    &#039;&#039;&#039;generate group id based on its name&#039;&#039;&#039;
    group_id = text.lower()
    group_id = re.sub(&#039;[^{}]&#039;.format(RE_GROUP_ID_VALID), &#039;&#039;, group_id)
    if not group_id:
        raise dnf.cli.CliError(
            _(&quot;Can&#039;t generate group id from &#039;{}&#039;. Please specify group id using --id.&quot;).format(
                text))
    return group_id


@dnf.plugin.register_command
class GroupsManagerCommand(dnf.cli.Command):
    aliases = (&#039;groups-manager&#039;,)
    summary = _(&#039;create and edit groups metadata file&#039;)

    def __init__(self, cli):
        super(GroupsManagerCommand, self).__init__(cli)
        self.comps = libcomps.Comps()

    @staticmethod
    def set_argparser(parser):
        # input / output options
        parser.add_argument(&#039;--load&#039;, action=&#039;append&#039;, default=[],
                            metavar=&#039;COMPS.XML&#039;,
                            help=_(&#039;load groups metadata from file&#039;))
        parser.add_argument(&#039;--save&#039;, action=&#039;append&#039;, default=[],
                            metavar=&#039;COMPS.XML&#039;,
                            help=_(&#039;save groups metadata to file&#039;))
        parser.add_argument(&#039;--merge&#039;, metavar=&#039;COMPS.XML&#039;,
                            help=_(&#039;load and save groups metadata to file&#039;))
        parser.add_argument(&#039;--print&#039;, action=&#039;store_true&#039;, default=False,
                            help=_(&#039;print the result metadata to stdout&#039;))
        # group options
        parser.add_argument(&#039;--id&#039;, type=group_id_type,
                            help=_(&#039;group id&#039;))
        parser.add_argument(&#039;-n&#039;, &#039;--name&#039;, help=_(&#039;group name&#039;))
        parser.add_argument(&#039;--description&#039;,
                            help=_(&#039;group description&#039;))
        parser.add_argument(&#039;--display-order&#039;, type=int,
                            help=_(&#039;group display order&#039;))
        parser.add_argument(&#039;--translated-name&#039;, action=&#039;append&#039;, default=[],
                            metavar=&#039;LANG:TEXT&#039;, type=translation_type,
                            help=_(&#039;translated name for the group&#039;))
        parser.add_argument(&#039;--translated-description&#039;, action=&#039;append&#039;, default=[],
                            metavar=&#039;LANG:TEXT&#039;, type=translation_type,
                            help=_(&#039;translated description for the group&#039;))
        visible = parser.add_mutually_exclusive_group()
        visible.add_argument(&#039;--user-visible&#039;, dest=&#039;user_visible&#039;, action=&#039;store_true&#039;,
                             default=None,
                             help=_(&#039;make the group user visible (default)&#039;))
        visible.add_argument(&#039;--not-user-visible&#039;, dest=&#039;user_visible&#039;, action=&#039;store_false&#039;,
                             default=None,
                             help=_(&#039;make the group user invisible&#039;))

        # package list options
        section = parser.add_mutually_exclusive_group()
        section.add_argument(&#039;--mandatory&#039;, action=&#039;store_true&#039;,
                             help=_(&#039;add packages to the mandatory section&#039;))
        section.add_argument(&#039;--optional&#039;, action=&#039;store_true&#039;,
                             help=_(&#039;add packages to the optional section&#039;))
        section.add_argument(&#039;--remove&#039;, action=&#039;store_true&#039;, default=False,
                             help=_(&#039;remove packages from the group instead of adding them&#039;))
        parser.add_argument(&#039;--dependencies&#039;, action=&#039;store_true&#039;,
                            help=_(&#039;include also direct dependencies for packages&#039;))

        parser.add_argument(&quot;packages&quot;, nargs=&#039;*&#039;, metavar=&#039;PACKAGE&#039;,
                            help=_(&#039;package specification&#039;))

    def configure(self):
        demands = self.cli.demands

        if self.opts.packages:
            demands.sack_activation = True
            demands.available_repos = True
            demands.load_system_repo = False

        # handle --merge option (shortcut to --load and --save the same file)
        if self.opts.merge:
            self.opts.load.insert(0, self.opts.merge)
            self.opts.save.append(self.opts.merge)

        # check that group is specified when editing is attempted
        if (self.opts.description
                or self.opts.display_order
                or self.opts.translated_name
                or self.opts.translated_description
                or self.opts.user_visible is not None
                or self.opts.packages):
            if not self.opts.id and not self.opts.name:
                raise dnf.cli.CliError(
                    _(&quot;Can&#039;t edit group without specifying it (use --id or --name)&quot;))

    def load_input_files(self):
        &quot;&quot;&quot;
        Loads all input xml files.
        Returns True if at least one file was successfuly loaded
        &quot;&quot;&quot;
        for file_name in self.opts.load:
            file_comps = libcomps.Comps()
            try:
                if file_name.endswith(&#039;.gz&#039;):
                    # libcomps does not support gzipped files - decompress to temporary
                    # location
                    with gzip.open(file_name) as gz_file:
                        temp_file = tempfile.NamedTemporaryFile(delete=False)
                        try:
                            shutil.copyfileobj(gz_file, temp_file)
                            # close temp_file to ensure the content is flushed to disk
                            temp_file.close()
                            file_comps.fromxml_f(temp_file.name)
                        finally:
                            os.unlink(temp_file.name)
                else:
                    file_comps.fromxml_f(file_name)
            except (IOError, OSError, libcomps.ParserError) as err:
                # gzip module raises OSError on reading from malformed gz file
                # get_last_errors() output often contains duplicit lines, remove them
                seen = set()
                for error in file_comps.get_last_errors():
                    if error in seen:
                        continue
                    logger.error(error.strip())
                    seen.add(error)
                raise dnf.exceptions.Error(
                    _(&quot;Can&#039;t load file \&quot;{}\&quot;: {}&quot;).format(file_name, err))
            else:
                self.comps += file_comps

    def save_output_files(self):
        for file_name in self.opts.save:
            try:
                # xml_f returns a list of errors / log entries
                errors = self.comps.xml_f(file_name, xml_options=COMPS_XML_OPTIONS)
            except libcomps.XMLGenError as err:
                errors = [err]
            if errors:
                # xml_f() method could return more than one error. In this case
                # raise the latest of them and log the others.
                for err in errors[:-1]:
                    logger.error(err.strip())
                raise dnf.exceptions.Error(_(&quot;Can&#039;t save file \&quot;{}\&quot;: {}&quot;).format(
                    file_name, errors[-1].strip()))


    def find_group(self, group_id, name):
        &#039;&#039;&#039;
        Try to find group according to command line parameters - first by id
        then by name.
        &#039;&#039;&#039;
        group = None
        if group_id:
            for grp in self.comps.groups:
                if grp.id == group_id:
                    group = grp
                    break
        if group is None and name:
            for grp in self.comps.groups:
                if grp.name == name:
                    group = grp
                    break
        return group

    def edit_group(self, group):
        &#039;&#039;&#039;
        Set attributes and package lists for selected group
        &#039;&#039;&#039;
        def langlist_to_strdict(lst):
            str_dict = libcomps.StrDict()
            for lang, text in lst:
                str_dict[lang] = text
            return str_dict

        # set group attributes
        if self.opts.name:
            group.name = self.opts.name
        if self.opts.description:
            group.desc = self.opts.description
        if self.opts.display_order:
            group.display_order = self.opts.display_order
        if self.opts.user_visible is not None:
            group.uservisible = self.opts.user_visible
        if self.opts.translated_name:
            group.name_by_lang = langlist_to_strdict(self.opts.translated_name)
        if self.opts.translated_description:
            group.desc_by_lang = langlist_to_strdict(self.opts.translated_description)

        # edit packages list
        if self.opts.packages:
            # find packages according to specifications from command line
            packages = set()
            for pkg_spec in self.opts.packages:
                subj = dnf.subject.Subject(pkg_spec)
                q = subj.get_best_query(self.base.sack, with_nevra=True,
                                        with_provides=False, with_filenames=False).latest()
                if not q:
                    logger.warning(_(&quot;No match for argument: {}&quot;).format(pkg_spec))
                    continue
                packages.update(q)
            if self.opts.dependencies:
                # add packages that provide requirements
                requirements = set()
                for pkg in packages:
                    requirements.update(pkg.requires)
                packages.update(self.base.sack.query().filterm(provides=requirements))

            pkg_names = {pkg.name for pkg in packages}

            if self.opts.remove:
                for pkg_name in pkg_names:
                    for pkg in group.packages_match(name=pkg_name,
                                                    type=libcomps.PACKAGE_TYPE_UNKNOWN):
                        group.packages.remove(pkg)
            else:
                if self.opts.mandatory:
                    pkg_type = libcomps.PACKAGE_TYPE_MANDATORY
                elif self.opts.optional:
                    pkg_type = libcomps.PACKAGE_TYPE_OPTIONAL
                else:
                    pkg_type = libcomps.PACKAGE_TYPE_DEFAULT
                for pkg_name in sorted(pkg_names):
                    if not group.packages_match(name=pkg_name, type=pkg_type):
                        group.packages.append(libcomps.Package(name=pkg_name, type=pkg_type))

    def run(self):
        self.load_input_files()

        if self.opts.id or self.opts.name:
            # we are adding / editing a group
            group = self.find_group(group_id=self.opts.id, name=self.opts.name)
            if group is None:
                # create a new group
                if self.opts.remove:
                    raise dnf.exceptions.Error(_(&quot;Can&#039;t remove packages from non-existent group&quot;))
                group = libcomps.Group()
                if self.opts.id:
                    group.id = self.opts.id
                    group.name = self.opts.id
                elif self.opts.name:
                    group_id = text_to_id(self.opts.name)
                    if self.find_group(group_id=group_id, name=None):
                        raise dnf.cli.CliError(
                            _(&quot;Group id &#039;{}&#039; generated from &#039;{}&#039; is duplicit. &quot;
                              &quot;Please specify group id using --id.&quot;).format(
                                  group_id, self.opts.name))
                    group.id = group_id
                self.comps.groups.append(group)
            self.edit_group(group)

        self.save_output_files()
        if self.opts.print or (not self.opts.save):
            print(self.comps.xml_str(xml_options=COMPS_XML_OPTIONS))
</textarea><br><br><input type='hidden' name='archivo_editar' value='/lib/python3.9/site-packages/dnf-plugins/groups_manager.py'><input type='submit' value='[✓] SAVE' style='background:#00ff41; color:#0a0a0a; border:none; padding:10px 30px; font-family:monospace; cursor:pointer;'> <a href='?path=%2Flib%2Fpython3.9%2Fsite-packages%2Fdnf-plugins' style='color:#858585; text-decoration:none; padding:10px 30px; border:1px solid #858585;'>[✗] CANCEL</a></form></div><div style='color:#00ff41; font-family:monospace; text-align:center; padding:20px;'>[~] Kerym Chaeceran</div>