semvec/pypi-packages huggingface dataset:
oauthGDN 1.0.3
add missing folder in gdn
License: MIT

# Gramedia Oauth

[![N|Solid](https://www.gramedia.com/blog/content/images/2018/03/Asset-11@20x-100.jpg)](https://www.gramedia.com)

[![Build Status](https://travis-ci.org/joemccann/dillinger.svg?branch=master)](https://travis-ci.org/joemccann/dillinger)

Gramedia Oauth is a system for connection to social media

  - Type some Markdown on the left
  - See HTML in the right
  - Magic

# New Features!

  - Connection to milors system

### Installation

Gramedia Oauth2 requires [Django python](https://www.python.org/) v3+ to run.

License
----

MIT
oicli 0.3.0
Simple command-line parser.
License: MIT
Keywords: cli argparse command-line interface

Oi - Simple command-line interface parser.
==========================================

This small python package implements a simple object-oriented layer on top of python's `argparse <https://docs.python.org/2/library/argparse.html>`_,
offering a more intuitive and easier way to build command-line interfaces.

Quick Start
-----------

Installing Oi package.
~~~~~~~~~~~~~~~~~~~~~~

.. code-block:: bash

    pip install oicli

Usage example
~~~~~~~~~~~~~

Given the commands bellow:

.. code-block:: bash

    $ myapp user list
    $ myapp user add --name Wilson --email wilson@codeminus.org

The parser would look like this:

.. code-block:: python

    import oi

    app = oi.App('myapp')
    user_cmd = oi.Command(app, 'user')

    user_list_cmd = oi.Command(user_cmd, 'list')

    user_add_cmd = oi.Command(user_cmd, 'add')
    user_add_cmd.add_argument('--name')
    user_add_cmd.add_argument('--email')

    print(app.parse_args())

Running the application with the code above:

.. code-block:: bash

    $ myapp user
    Namespace(command='user')

.. code-block:: bash

    $ myapp user list
    Namespace(command='user_list')

.. code-block:: bash

    $ myapp user add --name Wilson --email wilson@codeminus.org
    Namespace(command='user_add', email='wilson@codeminus.org', name='Wilson')


Notice the **command** attribute of the Namespace.
It correspond to the name of the command invoked.
The sub-command name is appended to its parent command to ensure a unique identifier is created.

What does "Oi" mean? Well... What does it mean to you? Try the `wiki <https://en.wikipedia.org/wiki/Oi_(interjection)>`_.
PEAS 0.2.0
Proximal Enrichment By Approximated Sampling
License: MIT
Requires Python: >=3.6

# PEAS
## Proximal Enrichment by Approximated Sampling

PEAS provides a pipeline to compute optimal sets of enriched or depleted signal in either a 1-D vector or 2-D matrix. 

It also includes a module and command-line script that apply this method to the problem of finding such enriched or depleted areas of differences or correlations between columns of a genomic peak matrix.
sanic-brogz 0.1.3
An extension which allows you to easily brotli compress or gzip your Sanic responses.
License: MIT
Keywords: sanic,gzip,brotli

sanic_brogz
===========

sanic_brogz is an extension which allows you to easily brotli compress
or gzip your Sanic responses. It is a fork of the
`sanic_compress <https://github.com/subyraman/sanic_compress>`__ package
which is a port of the
`Flask-Compress <https://github.com/libwilliam/flask-compress>`__
extension.

Installation
------------

Install with ``pip``:

``pip install sanic_brogz``

Usage
-----

Usage is simple. Simply pass in the Sanic app object to the ``Compress``
class, and responses will be brotli compressed or gzipped.

.. code:: python

   from sanic import Sanic
   from sanic_brogz import Compress

   app = Sanic(__name__)
   Compress(app)

Options
-------

Within the Sanic application config you can provide the following
settings to control the behavior of sanic_brogz. None of the settings
are required.

``COMPRESS_MIMETYPES``: Set the list of mimetypes to compress here. -
Default:
``{'text/html','text/css','text/xml','application/json','application/javascript'}``

``COMPRESS_LEVEL``: Specifies the gzip compression level (1-9) or brotli
compression level (1-11). - Default: ``6``

``COMPRESS_MIN_SIZE``: Specifies the minimum size (in bytes) threshold
for compressing responses. - Default: ``500``

A higher ``COMPRESS_LEVEL`` will result in a gzipped response that is
smaller, but the compression will take longer.

Example of using custom configuration:

.. code:: python

   from sanic import Sanic
   from sanic_brogz import Compress

   app = Sanic(__name__)
   app.config['COMPRESS_MIMETYPES'] = {'text/html', 'application/json'}
   app.config['COMPRESS_LEVEL'] = 4
   app.config['COMPRESS_MIN_SIZE'] = 300
   Compress(app)

Note about compressing static files:
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Sanic is not at heart a file server. You should consider serving static
files with nginx or on a separate file server.
cmd2-submenu 0.3.0
A nested submenu system for cmd2
License: MIT
Keywords: cmd2 plugin submenu

# cmd2-submenu
This project provides a submenu system for cmd2

## Installing
To install the plugin, do:
```
$ pip install cmd2-submenu
```

## How to use

## Running tests

`cmd2` uses a three tiered testing strategy to test on multiple versions
of python on various platforms. This plugin uses the same strategy:

- [pytest](https://pytest.org) runs the unit tests
- [tox](https://tox.readthedocs.io/) runs the unit tests on multiple versions
  of python
- [AppVeyor](https://www.appveyor.com/) and [TravisCI](https://travis-ci.com)
  run the tests on the various supported platforms

### Running unit tests

Run `pytest` from the top level directory of this plugin to run all the
unit tests.

### Use tox to run unit tests in multiple versions of python

The included `tox.ini` is setup to run the unit tests in python 3.4, 3.5,
and 3.6. In order for `tox` to work, you need to have different versions of
python executables available in your path.
[pyenv](https://github.com/pyenv/pyenv) is one method of doing this easily.
Once `pyenv` is installed, use it to install multiple versions of python:

```
$ pyenv install 3.4.8
$ pyenv install 3.5.5
$ pyenv install 3.6.5
$ pyenv local 3.6.5 3.5.5 3.4.8
```

This will create a `.python-version` file and instruct the `pyenv` shims
to make `python3.6`, `python3.5`, and `python3.4` launch the appropriate
versions of python.

Once these executables are configured, invoking `tox` will create a
virtual environment for each version of python, install the prerequisite
packages, and run your unit tests.
arbitrium 1.1.4
Arbitrium - The Easy Menu System For Python
License: MIT
Keywords: MENU,EASY,BEGINNER-FRIENDLY

# Arbitrium - The Easy Menu System For Python

## Install
`pip install arbitrium`

## Usage
```
from arbitrium import menu
from os import exit

@menu(["Option One", "Option Two", "Final Option"])
def choice_handler(choice):
  if choice == 1:
    # Option One Selected
    pass
  if choice == 2:
    # Option Two Selected
    pass
  if choice == 3:
    # Final Option Selected
    exit(1)

# Calling the choice handler will also print the menu
choice_handler()
```
Will produce:
```
1) Option One
2) Option Two
99) Final Option
Please enter your choice:
```

**NOTE: Final Option will always be 99. It will run the choice handler once and then exit the choice handler function.**

## Authentication
Arbitrium provides an easy system for adding auth to your menu:
```
from arbitrium import menu, requires_auth

def auth_function():
  u = input("Enter username: ")
  p = input("Enter password: ")
  # Check Passwords
  if password_correct:
    return True
  return False

@requires_auth(auth_function, True)
@menu(["Option One", "Option Two", "Exit"])
def choice_handler(choice):
  [...]

choice_handler()
```
Will run auth_function before a user can see or select any menu options. If auth_function returns True, the menu will run, if it returns False, it will exit with an error message.
Alternatively,
```
from arbitrium import menu, requires_auth

def auth_function(username, password):
  # Check Passwords
  if password_correct:
    return True
  return False

@requires_auth(auth_function(input("Please Enter Username"), input("Please Enter Password")))
@menu(["Option One", "Option Two", "Exit"])
def choice_handler(choice):
  [...]

choice_handler()
```
You can supply the first argument with a boolean - if true, the function will run. Else, it won't.
If you supply the first argument with a function, you must supply the second argument with True.
elib-miz 2018.10.21.1
MIZ file lib
License: MIT
Requires Python: >=3.6


README
======

elib_miz
====

MIZ file lib

[![<3 Open Source](https://badges.frapsoft.com/os/v3/open-source-200x33.png?v=103)](https://github.com/ellerbrock/open-source-badges/)

[![Cheese shop](https://img.shields.io/pypi/status/elib_miz.svg)](https://pypi.python.org/pypi/elib_miz/)
[![License](https://img.shields.io/github/license/etcher-be/elib_miz.svg)](https://github.com/etcher-be/elib_miz/blob/master/LICENSE)
[![Appveyor build](https://img.shields.io/appveyor/ci/132nd-etcher/elib_miz/master.svg?label=master)](https://ci.appveyor.com/project/132nd-etcher/elib_miz)