# packages

pkgId: 2418cbdfc14bb9957935b6022bf46da1807af72cc801858d5b4e604ad11e5f76
name: ansible
arch: src
version: 2.8.10
epoch: 0
release: 1.el7.ans
summary: SSH-based application deployment, configuration management, and IT orchestration platform
url: https://www.ansible.com
rpm_license: GPLv3+
rpm_group: Development/Libraries
rpm_buildhost: jenkins-jnlp-agent-pf685
location_href: SRPMS/ansible-2.8.10-1.el7.ans.src.rpm
checksum_type: sha256
description:
  Ansible is a radically simple model-driven configuration management,
  multi-node deployment, and orchestration engine. Ansible works
  over SSH and does not require any software or daemons to be installed
  on remote nodes. Extension modules can be written in any language and
  are transferred to managed machines automatically.


pkgId: 0ece3a17b0af0fe95971ac8757aaeb639f536b68692785c433ae9b55a207e1bd
name: cockpit
arch: src
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Web Console for Linux servers
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
location_href: SRPMS/cockpit-195.12-1.45d.el7.src.rpm
checksum_type: sha256
description:
  The Cockpit Web Console enables users to administer GNU/Linux servers using a
  web browser.

  It offers network configuration, log inspection, diagnostic reports, SELinux
  troubleshooting, interactive command-line sessions, and more.


pkgId: fa383e5bee680fd13ecd12b0683b90b682b0aa361598411bfdfa4102ed86f1f2
name: cockpit-ceph-installer
arch: src
version: 1.0
epoch: 0
release: 1.el7
summary: Cockpit plugin for Ceph cluster installation
url: https://github.com/red-hat-storage/cockpit-ceph-installer
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
location_href: SRPMS/cockpit-ceph-installer-1.0-1.el7.src.rpm
checksum_type: sha256
description:
  This package installs a cockpit plugin that provides a graphical interface to install a Ceph cluster. The plugin itself handles UI interaction and depends on the ansible-runner-service API to handle the configuration and management of the ansible inventory and playbooks.
  In addition to the plugin, the installation process also enables docker/podman which is required for the ansible-runner-service API.

  Once installed, a helper script called ansible-runner-service.sh is available to handle the installation and configuration of the ansible-runner-service daemon (container).


pkgId: addff47e97b97ca9deac42a0d1eb15fcc56887e57a4877b06f6600c960de8615
name: kmod-kvdo
arch: src
version: 6.2.2.117
epoch: 0
release: 1.el7
summary: Kernel Modules for Virtual Data Optimizer
url: http://github.com/dm-vdo/kvdo
rpm_license: GPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
location_href: SRPMS/kmod-kvdo-6.2.2.117-1.el7.src.rpm
checksum_type: sha256
description:
  Virtual Data Optimizer (VDO) is a device mapper target that delivers
  block-level deduplication, compression, and thin provisioning.

  This package provides the kernel modules for VDO.


pkgId: eb7862b66572f5ebd73d104a04d12e0bbffd9e83ca9577a3198b19bfed6ddbde
name: pyparsing
arch: src
version: 2.4.6
epoch: 0
release: 1.el7
summary: Python parsing module
url: https://github.com/pyparsing/pyparsing/
rpm_license: MIT License
rpm_vendor: Paul McGuire <ptmcg@users.sourceforge.net>
rpm_group: Development/Libraries
rpm_buildhost: rpmbuild.45lab.com
rpm_packager: Brett Kelly <bkelly@45drives.com>
location_href: SRPMS/pyparsing-2.4.6-1.el7.src.rpm
checksum_type: sha256
description:
  PyParsing -- A Python Parsing Module
  ====================================

  |Build Status|

  Introduction
  ============

  The pyparsing module is an alternative approach to creating and
  executing simple grammars, vs. the traditional lex/yacc approach, or the
  use of regular expressions. The pyparsing module provides a library of
  classes that client code uses to construct the grammar directly in
  Python code.

  *[Since first writing this description of pyparsing in late 2003, this
  technique for developing parsers has become more widespread, under the
  name Parsing Expression Grammars - PEGs. See more information on PEGs at*
  https://en.wikipedia.org/wiki/Parsing_expression_grammar *.]*

  Here is a program to parse ``"Hello, World!"`` (or any greeting of the form
  ``"salutation, addressee!"``):

  .. code:: python

      from pyparsing import Word, alphas
      greet = Word(alphas) + "," + Word(alphas) + "!"
      hello = "Hello, World!"
      print(hello, "->", greet.parseString(hello))

  The program outputs the following::

      Hello, World! -> ['Hello', ',', 'World', '!']

  The Python representation of the grammar is quite readable, owing to the
  self-explanatory class names, and the use of '+', '|' and '^' operator
  definitions.

  The parsed results returned from ``parseString()`` can be accessed as a
  nested list, a dictionary, or an object with named attributes.

  The pyparsing module handles some of the problems that are typically
  vexing when writing text parsers:

  - extra or missing whitespace (the above program will also handle ``"Hello,World!"``, ``"Hello , World !"``, etc.)
  - quoted strings
  - embedded comments

  The examples directory includes a simple SQL parser, simple CORBA IDL
  parser, a config file parser, a chemical formula parser, and a four-
  function algebraic notation parser, among many others.

  Documentation
  =============

  There are many examples in the online docstrings of the classes
  and methods in pyparsing. You can find them compiled into online docs
  at https://pyparsing-docs.readthedocs.io/en/latest/. Additional
  documentation resources and project info are listed in the online
  GitHub wiki, at https://github.com/pyparsing/pyparsing/wiki. An
  entire directory of examples is at
  https://github.com/pyparsing/pyparsing/tree/master/examples.

  License
  =======

  MIT License. See header of pyparsing.py

  History
  =======

  See CHANGES file.

  .. |Build Status| image:: https://travis-ci.org/pyparsing/pyparsing.svg?branch=master
     :target: https://travis-ci.org/pyparsing/pyparsing


pkgId: 380920a50c9287e05ed151d2d3d3d466665e2871e8063c837312e97d3acfc64e
name: python-notario
arch: src
version: 0.0.16
epoch: 0
release: 1.el7
summary: A dictionary validator
url: https://github.com/alfredodeza/notario
rpm_license: MIT
rpm_vendor: CentOS
rpm_group: Unspecified
rpm_buildhost: c1bj.rdu2.centos.org
rpm_packager: CBS <cbs@centos.org>
location_href: SRPMS/python-notario-0.0.16-1.el7.src.rpm
checksum_type: sha256
description:
  Notario is flexible and succinct Python dictionary validator with the ability
  to validate against both keys and values. Schemas are smaller and readable
  representations of data being validated.


pkgId: 190684d659c0717609b8c54ebab643e5ff0aa8474bfc30b78b9dd8e2fa9e35ad
name: tcmu-runner
arch: src
version: 1.5.2
epoch: 0
release: .el7
summary: A daemon that handles the userspace side of the LIO TCM-User backstore
url: https://github.com/open-iscsi/tcmu-runner
rpm_license: ASL 2.0 or LGPLv2+
rpm_group: System Environment/Daemons
rpm_buildhost: rpmbuild.45lab.com
location_href: SRPMS/tcmu-runner-1.5.2-.el7.src.rpm
checksum_type: sha256
description:
  A daemon that handles the userspace side of the LIO TCM-User backstore.

  LIO is the SCSI target in the Linux kernel. It is entirely kernel code, and
  allows exported SCSI logical units (LUNs) to be backed by regular files or
  block devices. But, if we want to get fancier with the capabilities of the
  device we're emulating, the kernel is not necessarily the right place. While
  there are userspace libraries for compression, encryption, and clustered
  storage solutions like Ceph or Gluster, these are not accessible from the
  kernel.

  The TCMU userspace-passthrough backstore allows a userspace process to handle
  requests to a LUN. But since the kernel-user interface that TCMU provides
  must be fast and flexible, it is complex enough that we'd like to avoid each
  userspace handler having to write boilerplate code.

  tcmu-runner handles the messy details of the TCMU interface -- UIO, netlink,
  pthreads, and DBus -- and exports a more friendly C plugin module API. Modules
  using this API are called "TCMU handlers". Handler authors can write code just
  to handle the SCSI commands as desired, and can also link with whatever
  userspace libraries they like.


pkgId: 7a97c484df25f81344dee4ecc6e8681ff2022d769277ff266b9dfc8d84143357
name: vdo
arch: src
version: 6.2.2.117
epoch: 0
release: 1.el7
summary: Management tools for Virtual Data Optimizer
url: http://github.com/dm-vdo/vdo
rpm_license: GPLv2
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
location_href: SRPMS/vdo-6.2.2.117-1.el7.src.rpm
checksum_type: sha256
description:
  Virtual Data Optimizer (VDO) is a device mapper target that delivers
  block-level deduplication, compression, and thin provisioning.

  This package provides the user-space management tools for VDO.


pkgId: 1c6251840e609b0fccec1bbd2bcb1b05d24a249934a71dc83f6e76a497b37e12
name: zfs-auto-snapshot
arch: src
version: 1.2.4
epoch: 0
release: 1.el7
url: https://github.com/45drives/zfs-auto-snapshot
rpm_license: GPL 2.0
rpm_group: Development/Tools
rpm_buildhost: rpmbuild.45lab.com
location_href: SRPMS/zfs-auto-snapshot-1.2.4-1.el7.src.rpm
checksum_type: sha256
summary:
  An alternative implementation of the zfs-auto-snapshot service for Linux that is compatible with zfs-linux and zfs-fuse.

description:
  Automatically create, rotate, and destroy periodic ZFS snapshots. This is
  the utility that creates the @zfs-auto-snap_frequent, @zfs-auto-snap_hourly,
  @zfs-auto-snap_daily, @zfs-auto-snap_weekly, and @zfs-auto-snap_monthly
  snapshots if it is installed.

  This program is a posixly correct bourne shell script.  It depends only on
  the zfs utilities and cron, and can run in the dash shell.


pkgId: ca5567087951019cfc0555a98fdad28e019079d747d5754193d2899bede46dcc
name: zfswatcher
arch: src
version: 0.4.6
epoch: 0
release: 1
summary: ZFS pool monitoring and notification daemon
url: http://zfswatcher.damicon.fi/
rpm_license: GPLv3+
rpm_vendor: Damicon Kraa Oy <http://www.damicon.fi/>
rpm_group: Applications/System
rpm_buildhost: tank.homenet.rouben.net
rpm_packager: Rouben <rouben@rouben.net>
location_href: SRPMS/zfswatcher-0.4.6-1.src.rpm
checksum_type: sha256
description:
  Zfswatcher is ZFS pool monitoring and notification daemon
  with the following main features:
   * Periodically inspects the zpool status.
   * Sends configurable notifications on status changes.
   * Controls the disk enclosure LEDs.
   * Web interface for displaying status and logs.


pkgId: 0a988b73addc64e44aa1eff7b105f6610ad09bf594e2d86586820de7051f8358
name: ansible
arch: noarch
version: 2.9.16
epoch: 0
release: 1.el7.ans
summary: SSH-based configuration management, deployment, and task execution system
url: http://ansible.com
rpm_license: GPLv3+
rpm_group: Development/Libraries
rpm_buildhost: jenkins-jnlp-agent-xhp44
rpm_sourcerpm: ansible-2.9.16-1.el7.ans.src.rpm
location_href: noarch/ansible-2.9.16-1.el7.ans.noarch.rpm
checksum_type: sha256
description:
  Ansible is a radically simple model-driven configuration management,
  multi-node deployment, and remote task execution system. Ansible works
  over SSH and does not require any software or daemons to be installed
  on remote nodes. Extension modules can be written in any language and
  are transferred to managed machines automatically.


pkgId: 63efe54a839648172f2c284c1313e1e40739cf279866d42707687d634909ee0e
name: ceph-iscsi
arch: noarch
version: 3.4
epoch: 0
release: 1.el7
summary: Python modules for Ceph iSCSI gateway configuration management
url: https://github.com/ceph/ceph-iscsi
rpm_license: GPLv3+
rpm_group: System/Filesystems
rpm_buildhost: 640ff9b4f595467ab4eb0449784db39d
rpm_sourcerpm: ceph-iscsi-3.4-1.el7.src.rpm
location_href: noarch/ceph-iscsi-3.4-1.el7.noarch.rpm
checksum_type: sha256
description:
  Python package providing the modules used to handle the configuration of an
  iSCSI gateway, backed by Ceph RBD. The RPM installs configuration management
  logic (ceph_iscsi_config modules), an rbd-target-gw systemd service, and
  a CLI-based management tool 'gwcli', replacing the 'targetcli' tool.

  The configuration management modules may be are consumed by custom Ansible
  playbooks and the rbd-target-gw daemon.

  The rbd-target-gw service is responsible for startup and shutdown actions,
  replacing the 'target' service used in standalone LIO implementations.
  In addition, rbd-target-gw also provides a REST API utilized by the Ceph
  dashboard and gwcli tool, and a prometheus exporter for gateway LIO
  performance statistics, supporting monitoring and visualisation tools like
  Grafana.


pkgId: 1761571607c0a0a693e859d1a0089986c1ee75d54726d4d1936a0f2223184f65
name: cephfs-shell
arch: noarch
version: 15.2.5
epoch: 0
release: 1
summary: Interactive shell for Ceph file system
url: https://github.com/ceph/ceph
rpm_license: LGPLv2+
rpm_vendor: Ceph
rpm_group: Development/Libraries
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cephfs-shell-15.2.5-1.src.rpm
rpm_packager: Brett Kelly <bkelly@45drives.com>
location_href: noarch/cephfs-shell-15.2.5-1.noarch.rpm
checksum_type: sha256
description:
  CephFS Shell provides shell-like commands that directly interact with the Ceph File System.

  This tool can be used in interactive mode as well as in non-interactive mode. In former mode, cephfs-shell opens a shell session and after the given command is finished, it prints the prompt string and waits indefinitely. When the shell session is finished, cephfs-shell quits with the return value of last executed command. In non-interactive mode, cephfs-shell issues a command and exits right after the command’s execution is complete with the command’s return value.

  Behaviour of CephFS Shell can be tweaked using cephfs-shell.conf. CephFS Shell looks for it by default at the path provided in environment variable CEPHFS_SHELL_CONF and then in user’s home directory (~/.cephfs-shell.conf).

  Usage :
      cephfs-shell [options] [command] cephfs-shell [options] – [command, command,…]

  Options :
      -c, --config FILE
          Path to cephfs-shell.conf
      -b, --batch FILE
          Path to batch file.
      -t, --test FILE
          Path to transcript(s) in FILE for testing


pkgId: 3b47090d5ccd4486dacec01fc882c9c9144b93c4dc141547dd7b55c5e851f0b1
name: cockpit-doc
arch: noarch
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Cockpit deployment and developer guide
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: noarch/cockpit-doc-195.12-1.45d.el7.noarch.rpm
checksum_type: sha256
description:
  The Cockpit Deployment and Developer Guide shows sysadmins how to
  deploy Cockpit on their machines as well as helps developers who want to
  embed or extend Cockpit.


pkgId: 3ce7c6434b7aaf9d2b151aa9a06f511b96861683efd8701a21a6296af8a807ab
name: cockpit-machines
arch: noarch
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Cockpit user interface for virtual machines
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: noarch/cockpit-machines-195.12-1.45d.el7.noarch.rpm
checksum_type: sha256
description:
  The Cockpit components for managing virtual machines.

  If "virt-install" is installed, you can also create new virtual machines.


pkgId: 04eac4f20653c8103ec633e78ca61b9aaf6a4653077a5aa6a8f60bfb7c98ef34
name: python3-cmd2
arch: noarch
version: 1.3.10
epoch: 0
release: 1.el7
summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
url: https://github.com/python-cmd2/cmd2
rpm_license: MIT
rpm_vendor: Catherine Devlin <catherine.devlin@gmail.com>
rpm_group: Development/Libraries
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python3-cmd2-1.3.10-1.el7.src.rpm
rpm_packager: Brett Kelly <bkelly@45drives.com>
location_href: noarch/python3-cmd2-1.3.10-1.el7.noarch.rpm
checksum_type: sha256
description:
  cmd2: a tool for building interactive command line apps
  =======================================================
  [![Latest Version](https://img.shields.io/pypi/v/cmd2.svg?style=flat-square&label=latest%20stable%20version)](https://pypi.python.org/pypi/cmd2/)
  [![Build status](https://img.shields.io/travis/python-cmd2/cmd2.svg?style=flat-square&label=unix%20build)](https://travis-ci.org/python-cmd2/cmd2)
  [![Appveyor build status](https://img.shields.io/appveyor/ci/FedericoCeratto/cmd2.svg?style=flat-square&label=windows%20build)](https://ci.appveyor.com/project/FedericoCeratto/cmd2)
  [![Azure Build status](https://python-cmd2.visualstudio.com/cmd2/_apis/build/status/python-cmd2.cmd2?branch=master)](https://python-cmd2.visualstudio.com/cmd2/_build/latest?definitionId=1&branch=master)
  [![codecov](https://codecov.io/gh/python-cmd2/cmd2/branch/master/graph/badge.svg)](https://codecov.io/gh/python-cmd2/cmd2)
  [![Documentation Status](https://readthedocs.org/projects/cmd2/badge/?version=latest)](http://cmd2.readthedocs.io/en/latest/?badge=latest)
  <a href="https://discord.gg/RpVG6tk"><img src="https://img.shields.io/badge/chat-on%20discord-7289da.svg" alt="Chat"></a>

  cmd2 is a tool for building interactive command line applications in Python. Its goal is to make it
  quick and easy for developers to build feature-rich and user-friendly interactive command line
  applications.  It provides a simple API which is an extension of Python's built-in
  [cmd](https://docs.python.org/3/library/cmd.html) module.  cmd2 provides a wealth of features on top
  of cmd to make your life easier and eliminates much of the boilerplate code which would be necessary
  when using cmd.

  Click on image below to watch a short video demonstrating the capabilities of cmd2:
  [![Screenshot](cmd2.png)](https://youtu.be/DDU_JH6cFsA)

  Main Features
  -------------
  - Searchable command history (`history` command and `<Ctrl>+r`) - optionally persistent
  - Text file scripting of your application with `run_script` (`@`) and `_relative_run_script` (`@@`)
  - Python scripting of your application with ``run_pyscript``
  - Run shell commands with ``!``
  - Pipe command output to shell commands with `|`
  - Redirect command output to file with `>`, `>>`
  - Bare `>`, `>>` with no filename send output to paste buffer (clipboard)
  - `py` enters interactive Python console (opt-in `ipy` for IPython console)
  - Option to display long output using a pager with ``cmd2.Cmd.ppaged()``
  - Multi-line commands
  - Special-character command shortcuts (beyond cmd's `?` and `!`)
  - Command aliasing similar to bash `alias` command
  - Macros, which are similar to aliases, but they can contain argument placeholders
  - Ability to run commands at startup from an initialization script
  - Settable environment parameters
  - Parsing commands with arguments using `argparse`, including support for subcommands
  - Unicode character support
  - Good tab completion of commands, subcommands, file system paths, and shell commands
  - Automatic tab completion of `argparse` flags when using one of the `cmd2` `argparse` decorators
  - Support for Python 3.5+ on Windows, macOS, and Linux
  - Trivial to provide built-in help for all commands
  - Built-in regression testing framework for your applications (transcript-based testing)
  - Transcripts for use with built-in regression can be automatically generated from `history -t` or `run_script -t`
  - Alerts that seamlessly print while user enters text at prompt
  - Colored and stylized output using `ansi.style()`

  Python 3.5 support ending soon
  ------------------------------
  `cmd2` will end support for Python 3.5 on August 31, 2020.  Python 3.5 was [released](https://docs.python.org/3/whatsnew/3.5.html)
  on Sept. 13, 2015 and its [end-of-life](https://devguide.python.org/#status-of-python-branches) is planned for September 2020.

  New versions of `cmd2` will stop supporting Python 3.5 in a few months. We are very much looking forward to being able to use
  [features added in Python 3.6](https://docs.python.org/3/whatsnew/3.6.html) such as [f-strings](https://realpython.com/python-f-strings/).

  Installation
  ------------
  On all operating systems, the latest stable version of `cmd2` can be installed using pip:

  ```bash
  pip install -U cmd2
  ```

  cmd2 works with Python 3.5+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.

  For information on other installation options, see
  [Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the cmd2
  documentation.


  Documentation
  -------------
  The latest documentation for cmd2 can be read online here: https://cmd2.readthedocs.io/en/latest/

  It is available in HTML, PDF, and ePub formats.


  Feature Overview
  ----------------
  Instructions for implementing each feature follow.

  - Extension of the `cmd` module.  So capabilities provided by `cmd` still exist
      - Your applicaiton inherits from `cmd2.Cmd`, let's say you call this class `MyApp`
      ```Python
      import cmd2
      class MyApp(cmd2.Cmd):
        pass
      ```
      - Define a command named **foo** by creating a method named **do_foo**
      ```Python
      class MyApp(cmd2.Cmd):
          def do_foo(self, args):
              """This docstring is the built-in help for the foo command."""
              self.poutput(cmd2.style('foo bar baz', fg=cmd2.fg.red))
      ```
      - By default the docstring for your **do_foo** method is the help for the **foo** command
          - NOTE: This doesn't apply if you use one of the `argparse` decorators mentioned below
      - Can provide more custom help by creating a **help_foo** method (except when using `argparse` decorators)
      - Can provide custom tab completion for the **foo** command by creating a **complete_foo** method
      - Easy to upgrade an existing `cmd` app to `cmd2`
      - Run your `cmd2` app using the built-in REPL by executing the **cmdloop** method

  - Searchable command history
      - Readline history using `<Ctrl>+r`, arrow keys, and other [Readline Shortcut keys](http://readline.kablamo.org/emacs.html)
      - `cmd2` `history` command provides flexible and powerful search
          - If you wish to exclude some of your custom commands from the history, append their names to the list at `Cmd.exclude_from_history`.
          - Do `help history` in any `cmd2` application for more information
      - Both of the above types of history can be optionally persistent between application runs
          - Via optional `persistent_history_file` argument to `cmd2.Cmd` initializer

  - Simple scripting using text files with one command + arguments per line
      - See the [Command Scripts](https://cmd2.readthedocs.io/en/latest/features/scripting.html#command-scripts) section of the `cmd2` docs for more info
      - See [script.txt](https://github.com/python-cmd2/cmd2/blob/master/examples/scripts/script.txt) for a trivial example script that can be
      used in any `cmd2` application with the `run_script` command (or `@` shortcut)

  - Powerful and flexible built-in Python scripting of your application using the `run_pyscript` command
      - Run arbitrary Python scripts within your `cmd2` application with the ability to also call custom `cmd2` commands
      - No separate API for your end users to learn
          - Syntax for calling `cmd2` commands in a `run_pyscript` is essentially identical to what they would enter on the command line
      - See the [Python Scripts](https://cmd2.readthedocs.io/en/latest/features/scripting.html#python-scripts) section of the `cmd2` docs for more info
      - Also see the [python_scripting.py](https://github.com/python-cmd2/cmd2/blob/master/examples/python_scripting.py)
      example in conjunction with the [conditional.py](https://github.com/python-cmd2/cmd2/blob/master/examples/scripts/conditional.py) script

  - Parsing commands with `argparse`
      - Two decorators provide built-in capability for using `argparse.ArgumentParser` to parse command arguments
          - `cmd2.with_argparser` - all arguments are parsed by the `ArgumentParser`
          - `cmd2.with_argparser_and_unknown_args` - any arguments not parsed by the `ArgumentParser` get passed as a list

      ```Python
      import argparse
      from cmd2 import with_argparser

      argparser = argparse.ArgumentParser()
      argparser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
      argparser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
      argparser.add_argument('words', nargs='+', help='words to say')

      @with_argparser(argparser)
      def do_speak(self, args):
          """Repeats what you tell me to."""
          words = []
          for word in args.words:
              if args.piglatin:
                  word = '%s%say' % (word[1:], word[0])
              if args.shout:
                  word = word.upper()
              words.append(word)
          self.stdout.write('{}\n'.format(' '.join(words)))
      ```

      See [Argument Processing](https://cmd2.readthedocs.io/en/latest/features/argument_processing.html) in the docs for more details

      NOTE: `cmd2` also provides the `Cmd2ArgumentParser` customization of `argparse.ArgumentParser` for prettier formatting
      of help and error messages.

  - `cmd2` applications function like a full-featured shell in many ways (and are cross-platform)
      - Run arbitrary shell commands by preceding them with `!` or `shell`
      - Redirect the output of any command to a file with `>` for overwrite or `>>` for append
          - If no file name provided after the `>`/`>>`, then output goes to the clipboard/pastebuffer
      - Pipe the output of any command to an arbitrary shell command with `|`
      - Create your own custom command aliases using the `alias` command
      - Create your own custom macros using the `macro` command (similar to aliases, but allow arguments)
      - Settable environment parameters that users can change during execution supported via `set` command
      - Option to display long output using a pager with ``cmd2.Cmd.ppaged()``
      - Optionally specify a startup script that end users can use to customize their environment

  - Top-notch tab completion capabilities which are easy to use but very powerful
      - For a command **foo** implement a **complete_foo** method to provide custom tab completion for that command
          - But the helper methods within `cmd2` discussed below mean you would rarely have to implement this from scratch
      - Commands which use one of the `argparse` decorators have automatic tab completion of `argparse` flags
          - And also provide help hints for values associated with these flags
          - Experiment with the [argprint.py](https://github.com/python-cmd2/cmd2/blob/master/examples/arg_print.py) example
          using the **oprint** and **pprint** commands to get a feel for how this works
      - `basic_complete` helper method for tab completion against a list
      - `path_complete` helper method provides flexible tab completion of file system paths
          - See the [paged_output.py](https://github.com/python-cmd2/cmd2/blob/master/examples/paged_output.py) example for a simple use case
          - See the [python_scripting.py](https://github.com/python-cmd2/cmd2/blob/master/examples/python_scripting.py) example for a more full-featured use case
      - `delimiter_complete` helper method for tab completion against a list but each match is split on a delimiter
          - See the [basic_completion.py](https://github.com/python-cmd2/cmd2/blob/master/examples/basic_completion.py) example for a demonstration of how to use this feature
      - `flag_based_complete` helper method for tab completion based on a particular flag preceding the token being completed
      - `index_based_complete` helper method for tab completion based on a fixed position in the input string
          - See the [basic_completion.py](https://github.com/python-cmd2/cmd2/blob/master/examples/basic_completion.py) example for a demonstration of how to use these features
          - `flag_based_complete()` and `index_based_complete()` are basic methods and should only be used if you are not
          familiar with argparse. The recommended approach for tab completing positional tokens and flags is to use
          argparse-based completion
      - `cmd2` in combination with `argparse` also provide several advanced capabilities for automatic tab completion
          - See the [argparse_completion.py](https://github.com/python-cmd2/cmd2/blob/master/examples/argparse_completion.py) example for more info

  - Multi-line commands

      Any command accepts multi-line input when its name is listed the `multiline_commands` optional argument to
      `cmd2.Cmd.__init`. The program will keep expecting input until a line ends with any of the characters listed in the
      `terminators` optional argument to `cmd2.Cmd.__init__()`  .  The default terminators are `;` and `\n` (empty newline).

  - Special-character shortcut commands (beyond cmd's "@" and "!")

      To create a single-character shortcut for a command, update `Cmd.shortcuts`.

  - Asynchronous alerts based on events happening in background threads
      - `cmd2` provides the following helper methods for providing information to users asynchronously even though the `cmd2`
      REPL is a line-oriented command interpreter:
          - `async_alert` - display an important message to the user while they are at the prompt in between commands
              - To the user it appears as if an alert message is printed above the prompt
          - `async_update_prompt` - update the prompt while the user is still typing at it
              - This is good for alerting the user to system changes dynamically in between commands
          - `set_window_title` - set the terminal window title
              - This changes the window title of the terminal that the user is running the `cmd2` app within


  Tutorials
  ---------

  * PyOhio 2019 presentation:
      * [video](https://www.youtube.com/watch?v=pebeWrTqIIw)
      * [slides](https://github.com/python-cmd2/talks/blob/master/PyOhio_2019/cmd2-PyOhio_2019.pdf)
      * [example code](https://github.com/python-cmd2/talks/tree/master/PyOhio_2019/examples)


  Example Application
  -------------------

  Example cmd2 application (**examples/example.py**):

  ```python


  """
  A sample application for cmd2.
  """
  import argparse
  import random
  import sys
  import cmd2

  class CmdLineApp(cmd2.Cmd):
      """ Example cmd2 application. """

      
      
      MUMBLES = ['like', '...', 'um', 'er', 'hmmm', 'ahh']
      MUMBLE_FIRST = ['so', 'like', 'well']
      MUMBLE_LAST = ['right?']

      def __init__(self):
          self.maxrepeats = 3
          shortcuts = dict(cmd2.DEFAULT_SHORTCUTS)
          shortcuts.update({'&': 'speak'})

          
          super().__init__(use_ipython=False, multiline_commands=['orate'], shortcuts=shortcuts)

          
          self.add_settable(cmd2.Settable('maxrepeats', int, 'max repetitions for speak command'))

      speak_parser = argparse.ArgumentParser()
      speak_parser.add_argument('-p', '--piglatin', action='store_true', help='atinLay')
      speak_parser.add_argument('-s', '--shout', action='store_true', help='N00B EMULATION MODE')
      speak_parser.add_argument('-r', '--repeat', type=int, help='output [n] times')
      speak_parser.add_argument('words', nargs='+', help='words to say')

      @cmd2.with_argparser(speak_parser)
      def do_speak(self, args):
          """Repeats what you tell me to."""
          words = []
          for word in args.words:
              if args.piglatin:
                  word = '%s%say' % (word[1:], word[0])
              if args.shout:
                  word = word.upper()
              words.append(word)
          repetitions = args.repeat or 1
          for i in range(min(repetitions, self.maxrepeats)):
              
              self.poutput(' '.join(words))

      do_say = do_speak  # now "say" is a synonym for "speak"
      do_orate = do_speak  # another synonym, but this one takes multi-line input

      mumble_parser = argparse.ArgumentParser()
      mumble_parser.add_argument('-r', '--repeat', type=int, help='how many times to repeat')
      mumble_parser.add_argument('words', nargs='+', help='words to say')

      @cmd2.with_argparser(mumble_parser)
      def do_mumble(self, args):
          """Mumbles what you tell me to."""
          repetitions = args.repeat or 1
          for i in range(min(repetitions, self.maxrepeats)):
              output = []
              if (random.random() < .33):
                  output.append(random.choice(self.MUMBLE_FIRST))
              for word in args.words:
                  if (random.random() < .40):
                      output.append(random.choice(self.MUMBLES))
                  output.append(word)
              if (random.random() < .25):
                  output.append(random.choice(self.MUMBLE_LAST))
              self.poutput(' '.join(output))

  if __name__ == '__main__':
      app = CmdLineApp()
      sys.exit(app.cmdloop())
  ```

  The following is a sample session running example.py.
  Thanks to Cmd2's built-in transcript testing capability, it also serves as a test
  suite for example.py when saved as *transcript_regex.txt*.
  Running

  ```bash
  python example.py -t transcript_regex.txt
  ```
  will run all the commands in the transcript against `example.py`, verifying that the output produced
  matches the transcript.

  example/transcript_regex.txt:

  ```text




  (Cmd) set
  allow_style: '/(Terminal|Always|Never)/'
  always_show_hint: False
  debug: False
  echo: False
  editor: /.*?/
  feedback_to_output: False
  maxrepeats: 3
  quiet: False
  timing: False
  ```

  Regular expressions can be used anywhere within a transcript file simply by enclosing them within forward slashes, `/`.


  Found a bug?
  ------------

  If you think you've found a bug, please first read through the open [Issues](https://github.com/python-cmd2/cmd2/issues). If you're confident it's a new bug, go ahead and create a new GitHub issue. Be sure to include as much information as possible so we can reproduce the bug.  At a minimum, please state the following:

  * ``cmd2`` version
  * Python version
  * OS name and version
  * What you did to cause the bug to occur
  * Include any traceback or error message associated with the bug


  Open source projects using cmd2
  -------------------------------

  Here are a few examples of open-source projects which use `cmd2`:

  * [Jok3r](http://www.jok3r-framework.com)
      * Network & Web Pentest Automation Framework
  * [CephFS Shell](http://docs.ceph.com/docs/master/cephfs/cephfs-shell/)
      * [Ceph](https://ceph.com/) is a distributed object, block, and file storage platform
  * [JSShell](https://github.com/Den1al/JSShell)
      * An interactive multi-user web JavaScript shell
  * [psiTurk](https://psiturk.org)
      * An open platform for science on Amazon Mechanical Turk
  * [Poseidon](https://github.com/CyberReboot/poseidon)
      * Leverages software-defined networks (SDNs) to acquire and then feed network traffic to a number of machine learning techniques
  * [Unipacker](https://github.com/unipacker/unipacker)
      * Automatic and platform-independent unpacker for Windows binaries based on emulation
  * [FLASHMINGO](https://github.com/fireeye/flashmingo)
      * Automatic analysis of SWF files based on some heuristics. Extensible via plugins.
  * [tomcatmanager](https://github.com/tomcatmanager/tomcatmanager)
      * A command line tool and python library for managing a tomcat server
  * [Expliot](https://gitlab.com/expliot_framework/expliot)
      * Internet of Things (IoT) exploitation framework
  * [mptcpanalyzer](https://github.com/teto/mptcpanalyzer)
      * Tool to help analyze mptcp pcaps
  * [clanvas](https://github.com/marklalor/clanvas)
      * Command-line client for Canvas by Instructure


pkgId: a9f1c68f4d3baf615e5b06fe4254004eca74c1703c2720a355a8a2dc93e7c502
name: python3-colorama
arch: noarch
version: 0.4.3
epoch: 0
release: 1.el7
summary: Cross-platform colored terminal text.
url: https://github.com/tartley/colorama
rpm_license: BSD
rpm_vendor: Arnon Yaari <tartley@tartley.com>
rpm_group: Development/Libraries
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python3-colorama-0.4.3-1.el7.src.rpm
rpm_packager: Brett Kelly <bkelly@45drives.com>
location_href: noarch/python3-colorama-0.4.3-1.el7.noarch.rpm
checksum_type: sha256
description:
  .. image:: https://img.shields.io/pypi/v/colorama.svg
      :target: https://pypi.org/project/colorama/
      :alt: Latest Version

  .. image:: https://img.shields.io/pypi/pyversions/colorama.svg
      :target: https://pypi.org/project/colorama/
      :alt: Supported Python versions

  .. image:: https://travis-ci.org/tartley/colorama.svg?branch=master
      :target: https://travis-ci.org/tartley/colorama
      :alt: Build Status

  Download and docs:
      https://pypi.org/project/colorama/
  Source code & Development:
      https://github.com/tartley/colorama
  Colorama for Enterprise:
      https://github.com/tartley/colorama/blob/master/ENTERPRISE.md

  Description
  ===========

  Makes ANSI escape character sequences (for producing colored terminal text and
  cursor positioning) work under MS Windows.

  ANSI escape character sequences have long been used to produce colored terminal
  text and cursor positioning on Unix and Macs. Colorama makes this work on
  Windows, too, by wrapping ``stdout``, stripping ANSI sequences it finds (which
  would appear as gobbledygook in the output), and converting them into the
  appropriate win32 calls to modify the state of the terminal. On other platforms,
  Colorama does nothing.

  Colorama also provides some shortcuts to help generate ANSI sequences
  but works fine in conjunction with any other ANSI sequence generation library,
  such as the venerable Termcolor (https://pypi.org/project/termcolor/)
  or the fabulous Blessings (https://pypi.org/project/blessings/).

  This has the upshot of providing a simple cross-platform API for printing
  colored terminal text from Python, and has the happy side-effect that existing
  applications or libraries which use ANSI sequences to produce colored output on
  Linux or Macs can now also work on Windows, simply by calling
  ``colorama.init()``.

  An alternative approach is to install ``ansi.sys`` on Windows machines, which
  provides the same behaviour for all applications running in terminals. Colorama
  is intended for situations where that isn't easy (e.g., maybe your app doesn't
  have an installer.)

  Demo scripts in the source code repository print some colored text using
  ANSI sequences. Compare their output under Gnome-terminal's built in ANSI
  handling, versus on Windows Command-Prompt using Colorama:

  .. image:: https://github.com/tartley/colorama/raw/master/screenshots/ubuntu-demo.png
      :width: 661
      :height: 357
      :alt: ANSI sequences on Ubuntu under gnome-terminal.

  .. image:: https://github.com/tartley/colorama/raw/master/screenshots/windows-demo.png
      :width: 668
      :height: 325
      :alt: Same ANSI sequences on Windows, using Colorama.

  These screengrabs show that, on Windows, Colorama does not support ANSI 'dim
  text'; it looks the same as 'normal text'.


  License
  =======

  Copyright Jonathan Hartley & Arnon Yaari, 2013. BSD 3-Clause license; see LICENSE file.


  Dependencies
  ============

  None, other than Python. Tested on Python 2.7, 3.5, 3.6, 3.7 and 3.8.

  Usage
  =====

  Initialisation
  --------------

  Applications should initialise Colorama using:

  .. code-block:: python

      from colorama import init
      init()

  On Windows, calling ``init()`` will filter ANSI escape sequences out of any
  text sent to ``stdout`` or ``stderr``, and replace them with equivalent Win32
  calls.

  On other platforms, calling ``init()`` has no effect (unless you request other
  optional functionality; see "Init Keyword Args", below). By design, this permits
  applications to call ``init()`` unconditionally on all platforms, after which
  ANSI output should just work.

  To stop using colorama before your program exits, simply call ``deinit()``.
  This will restore ``stdout`` and ``stderr`` to their original values, so that
  Colorama is disabled. To resume using Colorama again, call ``reinit()``; it is
  cheaper to calling ``init()`` again (but does the same thing).


  Colored Output
  --------------

  Cross-platform printing of colored text can then be done using Colorama's
  constant shorthand for ANSI escape sequences:

  .. code-block:: python

      from colorama import Fore, Back, Style
      print(Fore.RED + 'some red text')
      print(Back.GREEN + 'and with a green background')
      print(Style.DIM + 'and in dim text')
      print(Style.RESET_ALL)
      print('back to normal now')

  ...or simply by manually printing ANSI sequences from your own code:

  .. code-block:: python

      print('\033[31m' + 'some red text')
      print('\033[39m') # and reset to default color

  ...or, Colorama can be used happily in conjunction with existing ANSI libraries
  such as Termcolor:

  .. code-block:: python

      from colorama import init
      from termcolor import colored

      
      init()

      
      print(colored('Hello, World!', 'green', 'on_red'))

  Available formatting constants are::

      Fore: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
      Back: BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE, RESET.
      Style: DIM, NORMAL, BRIGHT, RESET_ALL

  ``Style.RESET_ALL`` resets foreground, background, and brightness. Colorama will
  perform this reset automatically on program exit.


  Cursor Positioning
  ------------------

  ANSI codes to reposition the cursor are supported. See ``demos/demo06.py`` for
  an example of how to generate them.


  Init Keyword Args
  -----------------

  ``init()`` accepts some ``**kwargs`` to override default behaviour.

  init(autoreset=False):
      If you find yourself repeatedly sending reset sequences to turn off color
      changes at the end of every print, then ``init(autoreset=True)`` will
      automate that:

      .. code-block:: python

          from colorama import init
          init(autoreset=True)
          print(Fore.RED + 'some red text')
          print('automatically back to default color again')

  init(strip=None):
      Pass ``True`` or ``False`` to override whether ansi codes should be
      stripped from the output. The default behaviour is to strip if on Windows
      or if output is redirected (not a tty).

  init(convert=None):
      Pass ``True`` or ``False`` to override whether to convert ANSI codes in the
      output into win32 calls. The default behaviour is to convert if on Windows
      and output is to a tty (terminal).

  init(wrap=True):
      On Windows, colorama works by replacing ``sys.stdout`` and ``sys.stderr``
      with proxy objects, which override the ``.write()`` method to do their work.
      If this wrapping causes you problems, then this can be disabled by passing
      ``init(wrap=False)``. The default behaviour is to wrap if ``autoreset`` or
      ``strip`` or ``convert`` are True.

      When wrapping is disabled, colored printing on non-Windows platforms will
      continue to work as normal. To do cross-platform colored output, you can
      use Colorama's ``AnsiToWin32`` proxy directly:

      .. code-block:: python

          import sys
          from colorama import init, AnsiToWin32
          init(wrap=False)
          stream = AnsiToWin32(sys.stderr).stream

          
          print >>stream, Fore.BLUE + 'blue text on stderr'

          
          print(Fore.BLUE + 'blue text on stderr', file=stream)


  Installation
  =======================
  colorama is currently installable from PyPI:

      pip install colorama

  colorama also can be installed by the conda package manager:

      conda install -c anaconda colorama


  Status & Known Problems
  =======================

  I've personally only tested it on Windows XP (CMD, Console2), Ubuntu
  (gnome-terminal, xterm), and OS X.

  Some presumably valid ANSI sequences aren't recognised (see details below),
  but to my knowledge nobody has yet complained about this. Puzzling.

  See outstanding issues and wishlist:
  https://github.com/tartley/colorama/issues

  If anything doesn't work for you, or doesn't do what you expected or hoped for,
  I'd love to hear about it on that issues list, would be delighted by patches,
  and would be happy to grant commit access to anyone who submits a working patch
  or two.


  Recognised ANSI Sequences
  =========================

  ANSI sequences generally take the form:

      ESC [ <param> ; <param> ... <command>

  Where ``<param>`` is an integer, and ``<command>`` is a single letter. Zero or
  more params are passed to a ``<command>``. If no params are passed, it is
  generally synonymous with passing a single zero. No spaces exist in the
  sequence; they have been inserted here simply to read more easily.

  The only ANSI sequences that colorama converts into win32 calls are::

      ESC [ 0 m       # reset all (colors and brightness)
      ESC [ 1 m       # bright
      ESC [ 2 m       # dim (looks same as normal brightness)
      ESC [ 22 m      # normal brightness

      
      ESC [ 30 m      # black
      ESC [ 31 m      # red
      ESC [ 32 m      # green
      ESC [ 33 m      # yellow
      ESC [ 34 m      # blue
      ESC [ 35 m      # magenta
      ESC [ 36 m      # cyan
      ESC [ 37 m      # white
      ESC [ 39 m      # reset

      
      ESC [ 40 m      # black
      ESC [ 41 m      # red
      ESC [ 42 m      # green
      ESC [ 43 m      # yellow
      ESC [ 44 m      # blue
      ESC [ 45 m      # magenta
      ESC [ 46 m      # cyan
      ESC [ 47 m      # white
      ESC [ 49 m      # reset

      
      ESC [ y;x H     # position cursor at x across, y down
      ESC [ y;x f     # position cursor at x across, y down
      ESC [ n A       # move cursor n lines up
      ESC [ n B       # move cursor n lines down
      ESC [ n C       # move cursor n characters forward
      ESC [ n D       # move cursor n characters backward

      
      ESC [ mode J    # clear the screen

      
      ESC [ mode K    # clear the line

  Multiple numeric params to the ``'m'`` command can be combined into a single
  sequence::

      ESC [ 36 ; 45 ; 1 m     # bright cyan text on magenta background

  All other ANSI sequences of the form ``ESC [ <param> ; <param> ... <command>``
  are silently stripped from the output on Windows.

  Any other form of ANSI sequence, such as single-character codes or alternative
  initial characters, are not recognised or stripped. It would be cool to add
  them though. Let me know if it would be useful for you, via the Issues on
  GitHub.


  Development
  ===========

  Help and fixes welcome!

  Running tests requires:

  - Michael Foord's ``mock`` module to be installed.
  - Tests are written using 2010-era updates to ``unittest``

  To run tests::

     python -m unittest discover -p *_test.py

  This, like a few other handy commands, is captured in a ``Makefile``.

  If you use nose to run the tests, you must pass the ``-s`` flag; otherwise,
  ``nosetests`` applies its own proxy to ``stdout``, which confuses the unit
  tests.


  Professional support
  ====================

  .. |tideliftlogo| image:: https://cdn2.hubspot.net/hubfs/4008838/website/logos/logos_for_download/Tidelift_primary-shorthand-logo.png
     :alt: Tidelift
     :target: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme

  .. list-table::
     :widths: 10 100

     * - |tideliftlogo|
       - Professional support for colorama is available as part of the
         `Tidelift Subscription`_.
         Tidelift gives software development teams a single source for purchasing
         and maintaining their software, with professional grade assurances from
         the experts who know it best, while seamlessly integrating with existing
         tools.

  .. _Tidelift Subscription: https://tidelift.com/subscription/pkg/pypi-colorama?utm_source=pypi-colorama&utm_medium=referral&utm_campaign=readme


  Thanks
  ======
  * Marc Schlaich (schlamar) for a ``setup.py`` fix for Python2.5.
  * Marc Abramowitz, reported & fixed a crash on exit with closed ``stdout``,
    providing a solution to issue #7's setuptools/distutils debate,
    and other fixes.
  * User 'eryksun', for guidance on correctly instantiating ``ctypes.windll``.
  * Matthew McCormick for politely pointing out a longstanding crash on non-Win.
  * Ben Hoyt, for a magnificent fix under 64-bit Windows.
  * Jesse at Empty Square for submitting a fix for examples in the README.
  * User 'jamessp', an observant documentation fix for cursor positioning.
  * User 'vaal1239', Dave Mckee & Lackner Kristof for a tiny but much-needed Win7
    fix.
  * Julien Stuyck, for wisely suggesting Python3 compatible updates to README.
  * Daniel Griffith for multiple fabulous patches.
  * Oscar Lesta for a valuable fix to stop ANSI chars being sent to non-tty
    output.
  * Roger Binns, for many suggestions, valuable feedback, & bug reports.
  * Tim Golden for thought and much appreciated feedback on the initial idea.
  * User 'Zearin' for updates to the README file.
  * John Szakmeister for adding support for light colors
  * Charles Merriam for adding documentation to demos
  * Jurko for a fix on 64-bit Windows CPython2.5 w/o ctypes
  * Florian Bruhin for a fix when stdout or stderr are None
  * Thomas Weininger for fixing ValueError on Windows
  * Remi Rampin for better Github integration and fixes to the README file
  * Simeon Visser for closing a file handle using 'with' and updating classifiers
    to include Python 3.3 and 3.4
  * Andy Neff for fixing RESET of LIGHT_EX colors.
  * Jonathan Hartley for the initial idea and implementation.


pkgId: a528812f60685f419467217ab4af2f7cd2bf8918412653ae9a5dd75de821ea72
name: python3-importlib_metadata
arch: noarch
version: 2.0.0
epoch: 0
release: 2.el7
summary: Read metadata from Python packages
url: http://importlib-metadata.readthedocs.io/
rpm_license: Apache Software License
rpm_vendor: Jason R. Coombs <jaraco@jaraco.com>
rpm_group: Development/Libraries
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python3-importlib_metadata-2.0.0-2.el7.src.rpm
rpm_packager: Brett Kelly <bkelly@45drives.com>
location_href: noarch/python3-importlib_metadata-2.0.0-2.el7.noarch.rpm
checksum_type: sha256
description:
  =========================
   ``importlib_metadata``
  =========================

  ``importlib_metadata`` is a library to access the metadata for a Python
  package.  It is intended to be ported to Python 3.8.


  Usage
  =====

  See the `online documentation <https://importlib_metadata.readthedocs.io/>`_
  for usage details.

  `Finder authors
  <https://docs.python.org/3/reference/import.html#finders-and-loaders>`_ can
  also add support for custom package installers.  See the above documentation
  for details.


  Caveats
  =======

  This project primarily supports third-party packages installed by PyPA
  tools (or other conforming packages). It does not support:

  - Packages in the stdlib.
  - Packages installed without metadata.

  Project details
  ===============

   * Project home: https://gitlab.com/python-devs/importlib_metadata
   * Report bugs at: https://gitlab.com/python-devs/importlib_metadata/issues
   * Code hosting: https://gitlab.com/python-devs/importlib_metadata.git
   * Documentation: http://importlib_metadata.readthedocs.io/


pkgId: 50e8a74875ebb1ef0e997bb6c92b30fa9eb2fea61500f69f8a1a4e3ffcd8a33c
name: python3-jwt
arch: noarch
version: 1.6.1
epoch: 0
release: 2.el7
summary: JSON Web Token implementation in Python
url: https://github.com/jpadilla/pyjwt
rpm_license: MIT
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python-jwt-1.6.1-2.el7.src.rpm
location_href: noarch/python3-jwt-1.6.1-2.el7.noarch.rpm
checksum_type: sha256
description:
  A Python implementation of JSON Web Token draft 01. This library provides a
  means of representing signed content using JSON data structures, including
  claims to be transferred between two parties encoded as digitally signed and
  encrypted JSON objects.


pkgId: c840c960fe762aa85b58456660efcaf3d5e715d0727e2ab7796df9fe06433cca
name: python3-pyperclip
arch: noarch
version: 1.8.0
epoch: 0
release: 1.el7
summary: A cross-platform clipboard module for Python. (Only handles plain text for now.)
url: https://github.com/asweigart/pyperclip
rpm_license: BSD
rpm_vendor: Al Sweigart <al@inventwithpython.com>
rpm_group: Development/Libraries
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python3-pyperclip-1.8.0-1.el7.src.rpm
rpm_packager: Brett Kelly <bkelly@45drives.com>
location_href: noarch/python3-pyperclip-1.8.0-1.el7.noarch.rpm
checksum_type: sha256
description:
  Pyperclip is a cross-platform Python module for copy and paste clipboard functions. It works with Python 2 and 3.

  `pip install pyperclip`

  Al Sweigart al@inventwithpython.com
  BSD License

  Example Usage
  =============

      >>> import pyperclip
      >>> pyperclip.copy('The text to be copied to the clipboard.')
      >>> pyperclip.paste()
      'The text to be copied to the clipboard.'


  Currently only handles plaintext.

  On Windows, no additional modules are needed.

  On Mac, this module makes use of the pbcopy and pbpaste commands, which should come with the os.

  On Linux, this module makes use of the xclip or xsel commands, which should come with the os. Otherwise run "sudo apt-get install xclip" or "sudo apt-get install xsel" (Note: xsel does not always seem to work.)

  Otherwise on Linux, you will need the gtk or PyQt4 modules installed.


pkgId: bf0d50029aab80bf0b337b5ea118679da08a4a87493a557057d53e2d1f768612
name: python3-repoze-lru
arch: noarch
version: 0.7
epoch: 0
release: 6.el7
summary: A tiny LRU cache implementation and decorator
url: http://pypi.python.org/pypi/repoze.lru
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python-repoze-lru-0.7-6.el7.src.rpm
location_href: noarch/python3-repoze-lru-0.7-6.el7.noarch.rpm
checksum_type: sha256
description:
  repoze.lru is a LRU (least recently used) cache implementation. Keys and values
  that are not used frequently will be evicted from the cache faster than keys
  and values that are used frequently.


pkgId: 4911293f8aa67f02eee326bf854aabf5e70ba16db7d7278f3c837a488366dfd3
name: python3-routes
arch: noarch
version: 2.4.1
epoch: 0
release: 12.el7
summary: Rails-like routes for Python3
url: http://routes.groovie.org/
rpm_license: BSD
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python-routes-2.4.1-12.el7.src.rpm
location_href: noarch/python3-routes-2.4.1-12.el7.noarch.rpm
checksum_type: sha256
description:
  Routes is a Python re-implementation of the Rails routes system for mapping
  URL's to Controllers/Actions and generating URL's. Routes makes it easy to
  create pretty and concise URL's that are RESTful with little effort.

  This package contains the module built for python3.


pkgId: 3b2cba78985d390af35b413d2ff47052dfee1b1e502f628d3142bbdb8a633202
name: samba-pidl
arch: noarch
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Perl IDL compiler
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: noarch/samba-pidl-4.10.16-9.el7_9.noarch.rpm
checksum_type: sha256
description:
  The samba-pidl package contains the Perl IDL compiler used by Samba
  and Wireshark to parse IDL and similar protocols


pkgId: 3509a7b104beeb11dfe60e6e854c8a8ea35a1f780973315932a21798cdc56d09
name: alertmanager
arch: x86_64
version: 0.20.0
epoch: 0
release: 2.el7
summary: Prometheus Alertmanager.
url: https://github.com/prometheus/alertmanager
rpm_license: ASL 2.0
rpm_group: Unspecified
rpm_buildhost: 7d7e42203b9c
rpm_sourcerpm: alertmanager-0.20.0-2.el7.src.rpm
location_href: x86_64/alertmanager-0.20.0-2.el7.x86_64.rpm
checksum_type: sha256
description:
  The Alertmanager handles alerts sent by client applications such as the
  Prometheus server. It takes care of deduplicating, grouping, and routing them to
  the correct receiver integration such as email, PagerDuty, or OpsGenie. It also
  takes care of silencing and inhibition of alerts.


pkgId: 3ad1d3558cfa59ea1dbd5deca24efdf53cc306b6556a47c583d246a388b4fb59
name: cockpit-bridge
arch: x86_64
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Cockpit bridge server-side component
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: x86_64/cockpit-bridge-195.12-1.45d.el7.x86_64.rpm
checksum_type: sha256
description:
  The Cockpit bridge component installed server side and runs commands on the
  system on behalf of the web based user interface.


pkgId: 2b01c3c141e57bd9b85a3413cb44e45c6d344b9b77f1e7a1230d4847fd7b6e50
name: cockpit-dashboard
arch: x86_64
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Cockpit remote servers and dashboard
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: x86_64/cockpit-dashboard-195.12-1.45d.el7.x86_64.rpm
checksum_type: sha256
description:
  Cockpit support for connecting to remote servers (through ssh),
  bastion hosts, and a basic dashboard.


pkgId: ab6c9cb4f58c34f8c2009bbe600e9ee14a091598e8413f563a6cd5c5aca1dc2e
name: cockpit-debuginfo
arch: x86_64
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Debug information for package cockpit
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Development/Debug
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: x86_64/cockpit-debuginfo-195.12-1.45d.el7.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package cockpit.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 107e1d11acceece1ea28df920ce0143c134d3e4f865fe28a29b354a44c38ee02
name: cockpit-docker
arch: x86_64
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Cockpit user interface for Docker containers
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: x86_64/cockpit-docker-195.12-1.45d.el7.x86_64.rpm
checksum_type: sha256
description:
  The Cockpit components for interacting with Docker and user interface.
  This package is not yet complete.


pkgId: bb4c60160f9835147afb1200ea7dbc7022b04d62cde4442c4842d4873670d89c
name: cockpit-kubernetes
arch: x86_64
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Cockpit user interface for Kubernetes cluster
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: x86_64/cockpit-kubernetes-195.12-1.45d.el7.x86_64.rpm
checksum_type: sha256
description:
  The Cockpit components for visualizing and configuring a Kubernetes
  cluster. Installed on the Kubernetes master. This package is not yet complete.


pkgId: 91e454491a453e6ba8295dbb9b6e43d1a40eda46be7337ba4065b2ac43367d9f
name: cockpit-tests
arch: x86_64
version: 195.12
epoch: 0
release: 1.45d.el7
summary: Tests for Cockpit
url: https://cockpit-project.org/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: x86_64/cockpit-tests-195.12-1.45d.el7.x86_64.rpm
checksum_type: sha256
description:
  This package contains tests and files used while testing Cockpit.
  These files are not required for running Cockpit.


pkgId: 9963f406423c7513f5b32a42a8ee27fc004c8d93fca39507ec472659f7fbef56
name: ctdb
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: A Clustered Database based on Samba's Trivial Database (TDB)
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/ctdb-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  CTDB is a cluster implementation of the TDB database used by Samba and other
  projects to store temporary data. If an application is already using TDB for
  temporary data it is very easy to convert that application to be cluster aware
  and use CTDB instead.


pkgId: f191b4ddc20d2e1905ef6c383644c66268566e418bb9dd5470eaaad5f4704f31
name: ctdb-tests
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: CTDB clustered database test suite
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/ctdb-tests-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  Test suite for CTDB.
  CTDB is a cluster implementation of the TDB database used by Samba and other
  projects to store temporary data. If an application is already using TDB for
  temporary data it is very easy to convert that application to be cluster aware
  and use CTDB instead.


pkgId: 3c526ebb7e0955413a6d4e084461c3a16c29d14a7ba631abaa317c0aa30e2872
name: jc
arch: x86_64
version: 1.13.4
epoch: 0
release: 1
url: https://github.com/kellyjonbrazil/jc
rpm_license: MIT
rpm_vendor: kellyjonbrazil@gmail.com
rpm_group: default
rpm_buildhost: kbrazil-mac.attlocal.net
rpm_sourcerpm: jc-1.13.4-1.src.rpm
rpm_packager: kellyjonbrazil@gmail.com
location_href: x86_64/jc-1.13.4-1.x86_64.rpm
checksum_type: sha256
summary:
  This tool serializes the output of popular gnu linux command line tools and file types to structured JSON output

description:
  This tool serializes the output of popular gnu linux command line tools and file types to structured JSON output


pkgId: 94a0374622a460b4b67be85c693e849497dd57c719b6184d4aaf29b611ae6b63
name: libsmbclient-devel
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Developer tools for the SMB client library
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/libsmbclient-devel-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The libsmbclient-devel package contains the header files and libraries needed
  to develop programs that link against the SMB client library in the Samba
  suite.


pkgId: 26eb87a8226286323a322333a22438dc3dbca159e3c8cd5f1940d68f21f8551d
name: libtcmu
arch: x86_64
version: 1.5.2
epoch: 0
release: 1.el7
summary: A library supporting LIO TCM-User backstores processing
url: https://github.com/open-iscsi/tcmu-runner
rpm_license: ASL 2.0 or LGPLv2+
rpm_group: Development/Libraries
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: tcmu-runner-1.5.2-1.el7.src.rpm
location_href: x86_64/libtcmu-1.5.2-1.el7.x86_64.rpm
checksum_type: sha256
description:
  libtcmu provides a library for processing SCSI commands exposed by the
  LIO kernel target's TCM-User backend.


pkgId: b867ca10cd224547607ce483074c4126a8ed1d8ec861e328ac340da9588cc22f
name: node_exporter
arch: x86_64
version: 1.0.0
epoch: 0
release: 1.el7
summary: Prometheus exporter for machine metrics, written in Go with pluggable metric collectors.
url: https://github.com/prometheus/node_exporter
rpm_license: ASL 2.0
rpm_group: Unspecified
rpm_buildhost: f174b1852ab6
rpm_sourcerpm: node_exporter-1.0.0-1.el7.src.rpm
location_href: x86_64/node_exporter-1.0.0-1.el7.x86_64.rpm
checksum_type: sha256
description:
  Prometheus exporter for hardware and OS metrics exposed by *NIX kernels,
  written in Go with pluggable metric collectors.


pkgId: 062b5ed5c1d2ba8a7c91ee39d1a83613f0fc48070a3db8dbda6f65dbd4249545
name: open-cas-linux
arch: x86_64
version: 20.03.0.0286
epoch: 0
release: 1.el7
summary: Open Cache Acceleration Software
url: https://open-cas.github.io/
rpm_license: BSD-3-Clause
rpm_group: System
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: open-cas-linux-20.03.0.0286-1.el7.src.rpm
location_href: x86_64/open-cas-linux-20.03.0.0286-1.el7.x86_64.rpm
checksum_type: sha256
description:
  Open Cache Acceleration Software (Open CAS) is an open source project
  encompassing block caching software libraries, adapters, tools and more.
  The main goal of this cache acceleration software is to accelerate a
  backend block device(s) by utilizing a higher performance device(s).
  This package contains tools and utilities for managing CAS and monitor
  running cache instances.


pkgId: 6f80ff3bd7467b63106f90e0070b57e4ceb4b11a4697d483ed92fa0c9f5826a0
name: prometheus2
arch: x86_64
version: 2.18.1
epoch: 0
release: 1.el7
summary: The Prometheus 2.x monitoring system and time series database.
url: https://prometheus.io
rpm_license: ASL 2.0
rpm_group: Unspecified
rpm_buildhost: 1ed66a67a5eb
rpm_sourcerpm: prometheus2-2.18.1-1.el7.src.rpm
location_href: x86_64/prometheus2-2.18.1-1.el7.x86_64.rpm
checksum_type: sha256
description:
  Prometheus is a systems and service monitoring system. It collects metrics from
  configured targets at given intervals, evaluates rule expressions, displays the
  results, and can trigger alerts if some condition is observed to be true.


pkgId: 64074ef5730d136d0f4a9bce0aba9af47c562b87005779472b95076f8266299b
name: samba-client
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba client programs
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-client-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-client package provides some SMB/CIFS clients to complement
  the built-in SMB/CIFS filesystem in Linux. These clients allow access
  of SMB/CIFS shares and printing to SMB/CIFS printers.


pkgId: 21008189706d84b1924210e61db1f76e8fc46e872bbec4a9795ba7c895e42f7f
name: samba-dc-libs
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba AD Domain Controller Libraries
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-dc-libs-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-dc-libs package contains the libraries needed by the DC to
  link against the SMB, RPC and other protocols.


pkgId: 5ac843e4d1a57fc2224700f860df01a27e5d4ac585872d56091a123b5d385771
name: samba-debuginfo
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Debug information for package samba
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Development/Debug
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-debuginfo-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package samba.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


pkgId: 84fcd383a7be1111a7aa383dfe172b75e652149dd4d2f76975c83d54c5d03eb3
name: samba-devel
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Developer tools for Samba libraries
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-devel-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-devel package contains the header files for the libraries
  needed to develop programs that link against the SMB, RPC and other
  libraries in the Samba suite.


pkgId: 17b8ba650ccb1bfd83fad3af2aaddff37cf27c39ea0e32f0d1a95cff771454a9
name: samba-krb5-printing
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba CUPS backend for printing with Kerberos
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-krb5-printing-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  If you need Kerberos for print jobs to a printer connection to cups via the SMB
  backend, then you need to install that package. It will allow cups to access
  the Kerberos credentials cache of the user issuing the print job.


pkgId: c8e1ebb95ebc6ce4a4502acc016e8e73c5ff6b38dc83d30b5899c32b74f5ca8d
name: samba-libs
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba libraries
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-libs-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-libs package contains the libraries needed by programs that link
  against the SMB, RPC and other protocols provided by the Samba suite.


pkgId: 75fb0d3c5483ad5b86a8858a50e693375b1c6d8894ca81abf02c2fea8ca35ea5
name: samba-python
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba Python libraries
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-python-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-python package contains the Python libraries needed by programs
  that use SMB, RPC and other Samba provided protocols in Python programs.


pkgId: f7ac5af70bafcec4381e69fb07ebbc94253bf8049741124c2de2be6d26089835
name: samba-python-test
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba Python libraries
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-python-test-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-python-test package contains the Python libraries used by the test suite of Samba.
  If you want to run full set of Samba tests, you need to install this package.


pkgId: 6668d5b29b013424710ec85ef74cd9614f652a42ec82e9dc4a11b37aa13763c6
name: samba-winbind
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba winbind
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-winbind-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-winbind package provides the winbind NSS library, and some client
  tools.  Winbind enables Linux to be a full member in Windows domains and to use
  Windows user and group accounts on Linux.


pkgId: 113063e895a3f4d555e9ebb0354ba1a9d35ff9fbab45afb9e65669924277e333
name: samba-winbind-krb5-locator
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba winbind krb5 locator
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-winbind-krb5-locator-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The winbind krb5 locator is a plugin for the system kerberos library to allow
  the local kerberos library to use the same KDC as samba and winbind use


pkgId: a35944cdb5ff202837d392aca46320946a2f9fcff25743c17239a538c57a41ed
name: samba-winbind-modules
arch: x86_64
version: 4.10.16
epoch: 0
release: 9.el7_9
summary: Samba winbind modules
url: http://www.samba.org/
rpm_license: GPLv3+ and LGPLv3+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: samba-4.10.16-9.el7_9.src.rpm
location_href: x86_64/samba-winbind-modules-4.10.16-9.el7_9.x86_64.rpm
checksum_type: sha256
description:
  The samba-winbind-modules package provides the NSS library and a PAM module
  necessary to communicate to the Winbind Daemon


pkgId: 844782c3e6964437bdec3e5ba6d6590501e38dee3cc5640137c88577bbd174bd
name: vdo-debuginfo
arch: x86_64
version: 6.2.2.117
epoch: 0
release: 1.el7
summary: Debug information for package vdo
url: http://github.com/dm-vdo/vdo
rpm_license: GPLv2
rpm_group: Development/Debug
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: vdo-6.2.2.117-1.el7.src.rpm
location_href: x86_64/vdo-debuginfo-6.2.2.117-1.el7.x86_64.rpm
checksum_type: sha256
description:
  This package provides debug information for package vdo.
  Debug information is useful when developing applications that use this
  package or when debugging this package.


