semvec/pypi-packages huggingface dataset:
puresec-cli 1.2.1
PureSec CLI tools for improving the security of your serverless applications.

Core engine for `serverless-puresec-cli <https://github.com/puresec/serverless-puresec-cli/>`_
..............................................................................................

Requirements
------------

- Python 3.4+

Usage
-----

See Serverless plugin: `serverless-puresec-cli <https://github.com/puresec/serverless-puresec-cli/>`_.

Development
-----------

Install dependencies, run the tests, and run the CLI (without ``pip`` installing).

.. code:: bash

    ./setup.py install
    ./setup.py test
    python3 -m puresec_cli --help

Then fork and pull request!

Release
-------

#. Set ``__version__`` in ``puresec_cli/__init__.py``
#. Commit, and run ``git tag vX.X.X`` replacing ``X.X.X`` with the new version
#. Set ``analytics.write_key`` in ``puresec_cli/stats.py`` **DON'T COMMIT IT**
#. Run ``./setup.py sdist upload``
#. Update version of https://github.com/puresec/serverless-puresec-cli
#. Update backend latest version

Anonymous statistics
--------------------

In order to continue improving this tool, the CLI will be sending anonymous statistics about your usage.
All reported information contains non-personal predictable information from your execution, along with a
random unique identifier that is attach to you. Predictable means that it won't send any local paths, function names, etc.

To opt out of anonymous statistics simply run:

.. code:: bash

    puresec --stats disable # or 'enable' if it's a wonderful day

One final report will be transmitted about your unsubscription, with no further details.
pyhelm 2.11.5
Python bindings for Helm: Kubernetes package manager

======
PyHelm
======

Python bindings for the Helm package manager

How to use PyHelm
-----------------
In order to install a Helm chart using PyHelm, you can perform the following steps:

**Loading a chart using ChartBuilder**

.. code-block:: python

    from pyhelm.chartbuilder import ChartBuilder

    chart = ChartBuilder({"name": "nginx-ingress", "source": {"type": "repo", "location": "https://kubernetes-charts.storage.googleapis.com"}}) 
    
This will cause the chart to cloned locally, and any additional use of ``chart`` will reference the local copy.
You can also used a local chart by using ``"type": "directory"``, as well as cloning from a git repo using ``"type": "git"``

**Installing a chart**

.. code-block:: python

    from pyhelm.chartbuilder import ChartBuilder
    from pyhelm.tiller import Tiller

    tiller = Tiller(TILLER_HOST)
    chart = ChartBuilder({"name": "nginx-ingress", "source": {"type": "repo", "location": "https://kubernetes-charts.storage.googleapis.com"}}) 
    tiller.install_release(chart.get_helm_chart(), dry_run=False, namespace='default')

This snippet will install the ``nginx-ingress`` chart on a Kubernetes cluster where Tiller is installed (assuming ``TILLER_HOST`` points to a live Tiller instance). Take note that in most Helm installations Tiller isn't accessible in such a manner, and you will need to perform a Kubernetes port-forward operation to access Tiller.
The ``Tiller`` class supports other operations other than installation, including release listing, release updating, release uninstallation and getting release contents.

Helm gRPC
---------
The helm gRPC libraries are located in the hapi directory.  They were generated with the grpc_tools.protoc utility against Helm 2.11.  Should you wish to re-generate them you can easily do so:

.. code-block:: shell

    git clone https://github.com/kubernetes/helm ./helm
    python -m grpc_tools.protoc -I helm/_proto --python_out=. --grpc_python_out=. _proto/hapi/chart/*
    python -m grpc_tools.protoc -I helm/_proto --python_out=. --grpc_python_out=. _proto/hapi/services/*
    python -m grpc_tools.protoc -I helm/_proto --python_out=. --grpc_python_out=. _proto/hapi/release/*
    python -m grpc_tools.protoc -I helm/_proto --python_out=. --grpc_python_out=. _proto/hapi/version/*
pfbackup 1.1.1
pfSense config backup tool
Requires Python: >=3.6

# pfBackup

## Summary

Simple utility for backing up pfSense configuration which uses web admin interface.

## Installation
### Create backup user account
It is recommended to create a dedicated user account with limited permissions for backup purposes. This user should have "WebCfg - Diagnostics: Backup & Restore" permission. Please check [pfSense documentation](https://docs.netgate.com/pfsense/en/latest/usermanager/index.html) if you are not sure how to do this. 

### Installation form PyPI:
```
pip3 install pfbackup
```
### Docker
You can download the image from Docker Hub:
```
docker pull mharjac/pfbackup
```
Or build it on your own:
```
docker build -t pfbackup https://github.com/mharjac/pfbackup.git#:docker
```
Create a volume for storing backups:
```
docker volume create pfbackup-firewall-1
```
Create a container:
```
docker run -d --name=pfbackup-firewall-1 -e PF_URL="https://192.168.1.1" -e PF_USER="backusr" -e PF_PASS="somesuperstrongpassword" -e PF_CERT_VERIFY="true" --mount=src=pfbackup-firewall-1,dst=/backup pfbackup:latest
```
And finally, for unattended regular backups, create a cron job which will execute:
```
docker start pfbackup-firewall-1
```
### Install from Snap Store
```
snap install pfbackup
```
## Usage
It can be used as an interactive tool from CLI:
```
pfbackup -U https://192.168.1.1 -u user1 -p passw0rd -f ./backup.xml
```
When used in CLI, it will prompt for password if -p (--password) flag is not provided. Also, without -f (--file) flag, config will be printed to the stdout.  

It can also be used for unattended backups (e.g., in containers), in which case, it requires following environment variables:  
* PF_URL: for storing web admin URL (e.g., https://192.168.1.1/)
* PF_USER: username for making backups
* PF_PASS: password for provided username
* PF_CERT_VERIFY: set to False if self-signed certificate in use  
```
export PF_URL="https://192.168.1.1" PF_USER="user1" PF_PASS="passw0rd" PF_CERT_VERIFY="True"
pfbackup
```
When executed in unattended mode, configuration backup will be saved in execution directory as `config-{time_stamp}.xml`.
tormor 2.5
Database migration helper
Requires Python: ~=3.6

# Tormor Command Line Tool
[![PyPI version](https://badge.fury.io/py/tormor.svg)](https://badge.fury.io/py/tormor)
[![CircleCI](https://circleci.com/gh/Proteus-tech/tormor.svg?style=svg)](https://circleci.com/gh/Proteus-tech/tormor)
[![Coverage Status](https://coveralls.io/repos/github/Proteus-tech/tormor/badge.svg)](https://coveralls.io/github/Proteus-tech/tormor)

Tormor is a command line tool for migrating database. To use Tormor, please first ensure these requirements:

  - Postgresql has been installed
  - Postgresql can be accessed using command :
    ```sh
    $ psql
    ```
- SCHEMA_PATH has been specified
    
## Installation
Tormor requires Python 3.5 or later to run. Tormor can be installed using pip:
```sh
$ pip install git+https://github.com/Proteus-tech/tormor.git@pytest_asyncpg_dryrun
```

## Instruction
    $ tormor [opts] command [args]
For more information, please use command:
```sh
$ tormor --help
```

### Enabling Modules
`enable-modules` command receives module name as a parameter to be enabled and later migrated using `migrate` command.
```
$ tormor enable-modules module-to-be-migrated
```

### Migrate
`migrate` command executes sql files under the enabled modules.
To start migration, use the following command:
```sh
$ tormor migrate
```
To simply output migration sql queries without executing them, use the following command.
```sh
$ tormor migrate --dry-run
```

### Run a Script File
`include` command takes filename as a parameter allows tormor commands to be run in a script, each line at a time.
```sh
$ tormor include filename
```

### Execute SQL File
`sql` command takes filename as a parameter and load and execute the query inside it.
```sh
$ tormor sql filename
```

## Dev

### Requirements
- flit
- PostgreSQL

```bash
pip install flit
flit install
./runtests
```

### Publish to PyPI
```
flit publish
```