# packages

pkgId: ffeb6da1cb76d0f09c38fa89fd0b230b6b82bf128b17d1384109e0f6cfab580e
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: 2506f627e3aa40ae5b33161a914f9f6fd7c7487e61b247ace17f2efb86a8ef30
name: ansible
arch: noarch
version: 2.5.15
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-tgh7d
rpm_sourcerpm: ansible-2.5.15-1.el7.ans.src.rpm
location_href: noarch/ansible-2.5.15-1.el7.ans.noarch.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: 51374a862e4cdb4218bb1cc7371aa0c5d3379363d7e135cb6c51b763edfdf36f
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: 383202869884502b08533d8e9e4aba4ba7fcfacd678a660727d383ed2fc4d73b
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: 812e0ed160fb9988d620b93debf6ab31269e8e6414fcb47ca30499be8f76d0d0
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: 745ca35d511867a15b6774c6ada8fc0aec450592bfb1f6a703622fc89a3d72b7
name: cephgeorep
arch: x86_64
version: 1.1.4
epoch: 0
release: 1.el7
summary: Ceph File System Remote Sync Daemon
url: github.com/45drives/cephgeorep/blob/master/README.md
rpm_license: GPL+
rpm_group: Unspecified
rpm_buildhost: rpmbuild-jb.45lab.com
rpm_sourcerpm: cephgeorep-1.1.4-1.el7.src.rpm
location_href: x86_64/cephgeorep-1.1.4-1.el7.x86_64.rpm
checksum_type: sha256
description:
  Ceph File System Remote Sync Daemon
  For use with a distributed Ceph File System cluster to georeplicate files to a remote backup server.
  This daemon takes advantage of Ceph's rctime directory attribute, which is the value of the highest
  mtime of all the files below a given directory tree. Using this attribute, it selectively recurses
  only into directory tree branches with modified files - instead of wasting time accessing every branch.


pkgId: 72a188845a1a1ec0acaf4a15a2061a80115de5355351fa14846c2d4d542583ed
name: cockpit
arch: x86_64
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
rpm_sourcerpm: cockpit-195.12-1.45d.el7.src.rpm
location_href: x86_64/cockpit-195.12-1.45d.el7.x86_64.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: 8cda2736755e71ddc5c59a99d5ff3705e4f4d2cbcdccfc0cff7225f9f8b1b3f8
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: e825750d9a6d92d47c5c32b7b1a6471635ef394b1fde76677444325e61fe9823
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: 6629f1d0b2c96bd36de171e66c7b2da70c2d5d0020271a8c1a85dc14c628359e
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: 84766e069d8db4550130798ce6b1af3acd812cba5634ab15e4735fec03fcf051
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: 461eaa3abc74e21a8301a0e1ac6a58cb8d02b9ebb10d9200c76655f8da46d23e
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: 61187f5f9f064d322520dbac7bad9bfdee305c43604fde54713da132464fe063
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: d5d5427b5aed57d628cd0a8e3f59f62775b2c153f68c5ec97a148434c3a97f0b
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: 9667ebaec3e0ed8d7b012239802fa534b645386b8572f9b69f98df1f7f4328a7
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: 231b8e8115abe6b5f81f68852197dd3ae694778ce0c827f347fab444bddb72e0
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: 2caf82e6fa6a6c2b8a1f7f7827cc558fd002c11d0f6cc76e4125380875879315
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: 2270234ab80025c2aaa4050777d3e75380b5358492bb13328979fd875364e577
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: 3d567a36fe0326fb120f824a90fe7f9602f34e2b979f97ca36d83a5406fa068d
name: kmod-kvdo
arch: x86_64
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
rpm_sourcerpm: kmod-kvdo-6.2.2.117-1.el7.src.rpm
location_href: x86_64/kmod-kvdo-6.2.2.117-1.el7.x86_64.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: 39856e19e96f96b5e7ba4eb50c07cd83cadb4ef12ec694669e125de601a3288a
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: 355a80c295f5e93f5609a74308152ff597523af78d97a726f577638d65b8f828
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: e08c5b052da617ff62efcca62ae38fd1c160a0eb95462c579d7f16b46f8c0d52
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: 4eaedad19f678ea0d10ca39d848ecb1d56132ce82b6625ade4b7e4f00ccc72db
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: ad84876f2f36f3636ad35b013e2c6bc93a2502c1835b48085e988d00c0fa7094
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: 00ab24cc75734ae76abd308ae2cfb1e430fde4086049751d4219eac90c546fc1
name: pyparsing
arch: noarch
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_sourcerpm: pyparsing-2.4.6-1.el7.src.rpm
rpm_packager: Brett Kelly <bkelly@45drives.com>
location_href: noarch/pyparsing-2.4.6-1.el7.noarch.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: 0bf4500346b6476f9ad2a2c2b6ae245c89809f156d39734e01a3df6ee5ffd67d
name: python2-notario
arch: noarch
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_sourcerpm: python-notario-0.0.16-1.el7.src.rpm
rpm_packager: CBS <cbs@centos.org>
location_href: noarch/python2-notario-0.0.16-1.el7.noarch.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: ae6fd43b91f60e247d4292763c2b325be7f49159864ddcd028da74e15db07cb3
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: 27e0d152a6b0c404c2e2c3c08e4a4a292f90597a43519004822621b9b0a4990e
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: 769ef97bc2bef58d6715b547bb6a3253310d89d37743739bc70e0a2d1e766f25
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: 5b76299db1978a1ead887f1b4fcc573a328b35e0631a90f81eff7bc5300c49bb
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: bcfd22f2b39a2ee344cddf469cda4e1e93ca814b8b2618f7e30032a2c763b093
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: 7a05ee0b4601b7022e98907dc694752f3fbb1d9f95c81d4ddb98b6d2026fe534
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: e7e0511aae345e422dbd4dc0599139101a830a98b172673359e18b14b36b55b9
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: 85a57744d7af7f7f7144015a28bcfdce05f75ee95042ec075d2e5416785a6e95
name: python3-urwid
arch: x86_64
version: 1.3.1
epoch: 0
release: 4.el7
summary: Console user interface library
url: http://excess.org/urwid/
rpm_license: LGPLv2+
rpm_group: Unspecified
rpm_buildhost: rpmbuild.45lab.com
rpm_sourcerpm: python-urwid-1.3.1-4.el7.src.rpm
location_href: x86_64/python3-urwid-1.3.1-4.el7.x86_64.rpm
checksum_type: sha256
description:
  Urwid is a Python library for making text console applications.  It has
  many features including fluid interface resizing, support for UTF-8 and
  CJK encodings, standard and custom text layout modes, simple markup for
  setting text attributes, and a powerful, dynamic list box that handles a
  mix of widget types.  It is flexible, modular, and leaves the developer in
  control.


pkgId: 5fe37d1a10d70aea1d9aa9dad513e868683f8fd50926764acbb22a70e991cee0
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: 8ea0808f6f9e6c33a53c45b08c63f56d0344e5b7f4a459bc7a536801cf28c17b
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: 1bc08a0a54a6446c32eb6a9110f5ddeada9a15f519d39106b5706b485e37bde7
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: 7b9f039b895878b846eb7c6bdbed5e57e75a1fe71c4efe7dcb51759978fe9b26
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: e753ff8937f03c2b74ae7bb7eafeb9a7d7f0a235e8a25b2394180bba50f8d4bc
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: 2ab52def1a961ff6539e08eea3f7b927c60b3957bf2f9afeb647a624b088d164
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: 40501865f913306a07aeef0f3666a94f4ee61264174414ac07b368cd3ce6283f
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: 6291bec388d68f988278b616ddd445b9622f50516b1b2520cca9f02dc598683a
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: 347da7d555fe73cdf4b8d921a42c8ca42d0bdf080b89e6da2eb788f5ab6907db
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: 309d4373c0f736a179931cdb64543d9851730babeff61c0e1d8965fee648ea95
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: 10917e608e48a714f523c31714a0281bbcc4deb257011b970f27cc766c79a6e5
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: 1932ec0d2372ca6695643e5e0158ea910d573b23bb7dacdfec9c677b6d6c776a
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: 5a94ebe17d449ab7f0953f4dc62200503ac124145214520d8c51060ddea74ec4
name: tcmu-runner
arch: x86_64
version: 1.5.2
epoch: 0
release: 1.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
rpm_sourcerpm: tcmu-runner-1.5.2-1.el7.src.rpm
location_href: x86_64/tcmu-runner-1.5.2-1.el7.x86_64.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: e381eccd5e9e59103388bc291b1a92371c2e5ffafbdbc409b4760d2c1b06a347
name: vdo
arch: x86_64
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
rpm_sourcerpm: vdo-6.2.2.117-1.el7.src.rpm
location_href: x86_64/vdo-6.2.2.117-1.el7.x86_64.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: 6523b54020c4db6d34784825cfabf3401c6b18fa9f973f84f8a4c85e85364c65
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.


pkgId: 9b6b4b4c5fec37d69b1bd56873a10edb245d175166157a98e2001dc7ce8c4b58
name: zfs-auto-snapshot
arch: x86_64
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
rpm_sourcerpm: zfs-auto-snapshot-1.2.4-1.el7.src.rpm
location_href: x86_64/zfs-auto-snapshot-1.2.4-1.el7.x86_64.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: dabd536c7fe9051269d409a54013c7026be7e01286c49b244754360c9bfc7b52
name: zfswatcher
arch: x86_64
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_sourcerpm: zfswatcher-0.4.6-1.src.rpm
rpm_packager: Rouben <rouben@rouben.net>
location_href: x86_64/zfswatcher-0.4.6-1.x86_64.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: 5150919f6a46f6555363dd12ac48656ebe1949fa1506ab85f1c4c80a30c7cce0
name: znapzend
arch: x86_64
version: 0.19.1
epoch: 0
release: 1.el7
summary: zfs backup with remote capabilities and mbuffer integration
url: http://www.znapzend.org
rpm_license: GPLv3+
rpm_group: Unspecified
rpm_buildhost: centos-rpm-repo.45lab.com
rpm_sourcerpm: znapzend-0.19.1-1.el7.src.rpm
location_href: x86_64/znapzend-0.19.1-1.el7.x86_64.rpm
checksum_type: sha256
description:
  ZnapZend is a ZFS centric backup tool. It relies on snapshot, send and
  receive to do its work. It has the built-in ability to manage both local
  snapshots as well as remote copies by thinning them out as time
  progresses.


