semvec/pypi-packages huggingface dataset:
gravity-falls 0.0.2
Implementation of famous ancient ciphers and encryption techniques
Requires Python: >=3.6

## gravity-falls
Implementation of famous ancient ciphers and encryption techniques.

Inspired by [this](https://www.freecodecamp.org/news/how-gravity-falls-can-help-you-teach-your-kids-basics-of-cryptography-18e1c6f9ac39/) article on freecodecamp.org.
async-okta-jwt 1.3.5.1
Okta JWT Access Token verifier

# Async Okta Jwt

Async Okta JWT Access Token verifier for Python using cached JWKs.

Based on [okta_jwt](https://github.com/adithyasampatoor/okta_jwt) by Adithya Sampatoor

Link to PyPi - click [here](https://pypi.org/project/async-okta-jwt/)

## Installation

```python
	pip install async_okta_jwt
```

### Usage

To generate a token, you need to pass in `issuer`, `client_id`, `client_secret`, `username` and `password` as parameters
```python
	>>> from async_okta_jwt.jwt import generate_token
	>>> await generate_token(issuer, client_id, client_secret, username
, password)
```

This generates and returns Okta Access Token.


To Validate the Access Token, you need to pass in the `access_token`, `issuer`, `audience` and `client_ids` as parameters. You can pass in multiple Client IDs
```python
	>>> from async_okta_jwt.jwt import validate_token
	>>> await validate_token(access_token, issuer, audience, client_ids)
```

If the token is valid then it will return the payload.


## Running the tests

To run the unit tests, run

	$ python -m unittest

### Break down into tests

The unit tests pretty much covers all the main functionality of the package, like generating the token, Validating the token and Verifying Claims.

## Contributing

Bug reports and Pull Requests(PR's) are welcome on GitHub at
https://github.com/ypukhta/async_okta_jwt. This project is intended to be a safe, welcoming
 space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.

## Authors

* **Adithya Sampatoor**
* **Yevgen Pukhta**

## License

The Library is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT)
probe-basic 0.4.0
Probe Basic - A QtPyVCP based Virtual Control Panel for LinuxCNC

![](probe_basic/images/probe_basic_icon.png)


## Documentation

### installation

https://kcjengr.github.io/probe_basic/quick_start.html

### Development installation 

https://kcjengr.github.io/probe_basic/dev_install.html

### QtPyVCP use documentation

https://qtpyvcp.com


## Resources

* [Development](https://github.com/kcjengr/Probe_Basic/)
* [Documentation](https://kcjengr.github.io/probe_basic/)
* [Freenode IRC](http://webchat.freenode.net/?channels=%23hazzy) (#hazzy) (isolated)
* [The Matrix](https://riot.im/app/#/room/#qtpyvcp:matrix.org) (#qtpyvcp:matrix.org) (bridged)
* [Gitter](https://gitter.im/kcjengr/qtpyvcp) (bridged)
* [Discord](https://discord.gg/463hMhd) (bridged)
* [Issue Tracker](https://github.com/kcjengr/Probe_Basic/issues)


## Dependencies

* [LinuxCNC](https://linuxcnc.org)
* Python 2.7
* PyQt5 or PySide2
* [QtPyVCP](https://qtpyvcp.com/)

Probe Basic is developed and tested using the LinuxCNC Debian 9 x64 (stretch)
[Live ISO](http://www.linuxcnc.org/testing-stretch-rtpreempt/) and Ubuntu 18.10 x64 SIM. It should run
on any system that can have PyQt5 installed, but Debian 9 x64 is the only OS
that is officially supported.


## DISCLAIMER

THE AUTHORS OF THIS SOFTWARE ACCEPT ABSOLUTELY NO LIABILITY FOR
ANY HARM OR LOSS RESULTING FROM ITS USE.  IT IS _EXTREMELY_ UNWISE
TO RELY ON SOFTWARE ALONE FOR SAFETY.  Any machinery capable of
harming persons must have provisions for completely removing power
from all motors, etc, before persons enter any danger area.  All
machinery must be designed to comply with local and national safety
codes, and the authors of this software can not, and do not, take
any responsibility for such compliance.

This software is released under the GPLv2.
opaclient 0.1.0
Module pdp implements a client for making authz requests to a Policy Decision Point (OPA)

# opa-python-client

<p align="center"><img src="logo-build.png" class="center" alt="build-logo" width="30%"/></p>

## Abstract
[build.security](https://docs.build.security/) provides simple development and management for your organization's authorization policy.
*opa-python-client* is a Python 3 package that performs authorization requests against build.security PDPs (Policy Decision Point)/[OPA](https://www.openpolicyagent.org/).

## Data Flow
<p align="center"> <img src="data-flow.png" alt="drawing" width="60%"/></p>

## Usage
Before you start we recommend completing the onboarding tutorial.

---
**Important note**

To simplify the setup process, the following example uses a local [build.security PDP instance](https://docs.build.security/policy-decision-points-pdp/pdp-deployments/standalone-docker-1).
If you are already familiar with how to run your PDP, You can also run a PDP on your environment (Dev/Prod, etc).

In that case, don't forget to change the **hostname** and **port** in your code.

---
### Simple usage

Initialize the client, initialize some input for the PDP, and make a request:

```
from from opaclient import PolicyDecisionPointClient, PolicyDecisionPointInput, AuthzException

client = PolicyDecisionPointClient(hostname='http://some.host', port=8181,
             policy_path='mypolicy', read_timeout_milliseconds=100, connection_timeout_milliseconds=100,
             retry_max_attempts=5, retry_backoff_milliseconds=1000)

input = PolicyDecisionPointInput(schema='http', method='POST', more_authz_context=some_value,
             even_more_authz_context=some_other_value=some_other_value)

try:
    authz = client.authorize(input)
except AuthzException as e:
    raise

if authz:
    print('The request has been authorized!')
```
   
 ### Mandatory configuration to initialize the client 

 1. `hostname` - The hostname of the Policy Decision Point (PDP)
 2. `port` - The port at which the PDP service is serving authz decisions
 3. `policy_path` - Full path to the policy (including the rule) that decides whether requests should be authorized
 
 [How to get your pdp's hostname and port?](https://docs.build.security/policy-decision-points-pdp#pdp-instances-section)

  ### Optional configuration
 1. `retry_max_attempts` - the maximum number of retry attempts in case a failure occurs. **Default is 2**.
 2. `read_timeout_milliseconds` - Read timeout for requests in milliseconds. **Default is 5000**
 3. `connection_timeout_milliseconds` - Connection timeout in milliseconds. **Default is 5000**
 4. `retry_backoff_milliseconds` - The number of milliseconds to wait between two consecutive retry attempts. **Default is 250**
vt2geojson 0.2.1
Dump vector tiles to GeoJSON from remote URLs or local system files.

# python-vt2geojson [![Build Status](https://travis-ci.org/Amyantis/python-vt2geojson.svg?branch=master)](https://travis-ci.org/Amyantis/python-vt2geojson)
Dump vector tiles to GeoJSON from remote URLs or local system files.

Inspired from https://github.com/mapbox/vt2geojson.

## Installation
```
pip install vt2geojson
```

## Usage
Using the CLI:
```
vt2geojson --help
```

Making a GeoDataframe from a PBF vector tile file:
```python
import geopandas as gpd
import requests

from vt2geojson.tools import vt_bytes_to_geojson

MAPBOX_ACCESS_TOKEN = "*****"

x = 150
y = 194
z = 9

url = f"https://api.mapbox.com/v4/mapbox.mapbox-streets-v6/{z}/{x}/{y}.vector.pbf?access_token={MAPBOX_ACCESS_TOKEN}"
r = requests.get(url)
assert r.status_code == 200, r.content
vt_content = r.content

features = vt_bytes_to_geojson(vt_content, x, y, z)
gdf = gpd.GeoDataFrame.from_features(features)
```

## Todos:
* Add more test using `vector-tile/test/fixtures/*.vector.pbf` data files.

## Notes
This library has only been tested against **Python 3.6**.

Feel free to [submit your issues](https://github.com/Amyantis/python-vt2geojson/issues).
FRETlines 0.0.5
Package for the calculation of FRET-lines

# FRET-lines generator

This is a small Python3 package for the calculation of FRET-lines for use in single-molecue FRET experiments using multiparameter fluorescence detection<sup>[1]</sup>. These experiments are analyzed using two-dimensional histograms of the FRET efficiency, *E*, and the intensity-weighted average donor fluorescence lifetime, <&tau;<sub>D(A)</sub>><sub>F</sub>. FRET-lines define relationships between these two observables for different physical models of the system that can be overlayed on the plot for comparison to the experimental data<sup>[2]</sup>.

For an ideal system, the two observables are related by the *ideal static FRET-line*:

*E* = 1- <&tau;<sub>D(A)</sub>><sub>F</sub>/&tau;<sub>D(0)</sub>
  
where &tau;<sub>D(0)</sub> is the donor only fluorescence lifetime. To model the influence of the flexible dye linkers, static FRET-lines can be generated based on a normal or &chi; distribution for the interdye distance. In addition, two polymer models are implemented: the random coil (or Gaussian chain) and the worm-like chain (WLC).

Dynamic FRET-lines characterize the exchange between distinct conformations and show as a curve connecting two points on the static FRET-line. An example is given below.

![Example of a dynamic FRET-line](/docs/dynamic_FRET_line.png)
 
 # Usage
 
 The usage of the package is demonstrated in the associated [Jupyter Notebook.](https://github.com/AndersBarth/FRETlines/blob/master/FRETlines.ipynb)

# Installation

The FRETlines package can either be run from the root folder, or be installed to your local Python installation by `python setup.py install`. It is also available through PyPI by `pip install FRETlines`.

## Dependencies

numpy, numba
(for the interactive notebook: ipywidgets)

# References

[1] Eggeling C, et al. (2001) Data registration and selective single-molecule analysis using multi-parameter fluorescence detection. Journal of Biotechnology 86(3):163–180.

[2] Kalinin S, Valeri A, Antonik M, Felekyan S, Seidel CAM (2010) Detection of structural dynamics by FRET: a photon distribution and fluorescence lifetime analysis of systems with multiple states. J Phys Chem B 114(23):7983–7995.

FRETlines generator - A python library for the calcualtion of FRETlines
    Copyright (C) 2020  Anders Barth