semvec/pypi-packages huggingface dataset:
wf-pose-tracking-3d 0.1.0
Classes and methods for performing 3D pose tracking from 2D poses
Keywords: cv

# wf-pose-tracking-3d

Classes and methods for performing 3D pose tracking from 2D poses:

* Functions which load 2D pose data from Wildflower S3 directories

* Functions which perform very basic 3D pose reconstruction from multi-camera 2D pose data

* Functions which support basic visualization of 2D and 3D pose data

## Testing

To run tests, change working directory to `/tests` and run one of the following.

`python 3d_reconstruction_example.py` pulls a single frame of 2D pose data from S3 and performs a simple 3D pose reconstruction

`python 3d_pose_tracking_example.py` pulls multiple frames of 2D pose data from a local file and builds a set of 3D pose tracks

These scripts pull camera calibration parameter files and sample 2D pose data from `tests/data`

To run these scripts (and to use any of the functions data from S3), you need to set the `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` environment variables to keys belonging to an account that is a member of the Wildflower `cameras` group.
wf-smc-kalman 0.1.0
Sequential Monte Carlo modeling for linear Gaussian systems
Keywords: smc

# smc_kalman

Sequential Monte Carlo modeling for linear Gaussian systems

## Installation

* Clone this repo to any convenient location on your local drive

* From within your Python development environment (base environment or a virtual environment), run `pip install -e LOCAL_PATH_TO_REPO`

* `pip` will install the `smc_kalman` package in your Python development environment (along with all dependencies)

* You can then import the modules like any other Python package (e.g., `import smc_kalman`)
wf-cv-datetime-utils 0.1.0
Miscellaneous utilities for working with datetimes when processing images
Keywords: cv,datetime

# cv-datetime-utils

Miscellaneous utilities for working with datetimes when processing images

Contains functions to convert various datetime formats (native Python, numpy, pandas; timezone-naive or timezone-aware; timezones in dateutil format or pytz format) into known timezone-naive formats in UTC
basic-auth 0.0.2
A package for read and writing auth

[![Build Status](https://github.com/rorymurdock/basic_auth/workflows/Pytest/badge.svg)](https://github.com/rorymurdock/basic_auth/actions)
[![Coverage Status](https://coveralls.io/repos/github/rorymurdock/basic_auth/badge.svg?branch=master)](https://coveralls.io/github/rorymurdock/basic_auth?branch=master)

# Basic

A package for creating and reading config files for basic authentication.

# Purpose
A lot of APIs use basic authentication, this is where you concatenate `username` and `password` separated by a `:` and encode them with base64 then prefix with `Basic`. So `username:password` encoded with base64 becomes `Basic dXNlcm5hbWU6cGFzc3dvcmQ=`. This package manages the encoding and storing of this configuration so it can be easily retrieve and used.

# Usage
Getting started is easy, first install the package using `pip install basic`

Next you can create your auth dict

```python
form basic_auth import Auth
```

```python
CONFIG = Auth().basic_config("url", Auth().encode("username", "password"))
```

Write it to file
```python
Auth().create_config("basic_config.json", CONFIG)
```

To read it in your own scripts
```
CONFIG = Auth().read_config("basic_config.json")
```

Have a read of `simple.py`

There's some examples in the Examples directory
`general.py` supports both interactive input and arguments.

```shell
python3 Examples/general.py -url example.com -username user1 -password hunter2
```

and

```shell
python3 Examples/general.py
```

WSO.py shows how to use it and insert your own custom fields too.

# Details
This will create a folder called config and store the config in a json file with the following structure

```json
{
    "url": "url",
    "authorization": "Basic dXNlcm5hbWU6cGFzc3dvcmQ="
}
```
py-apollo 0.0.3
pyapollo from filamoon

PyApollo - Python Client for Ctrip's Apollo
================

[![License](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)

方便Python接入配置中心框架 [Apollo](https://github.com/ctripcorp/apollo) 所开发的Python版本客户端。
Tested with python 2.7 & 3.6

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

``` shell
python setup.py install
```

# Features
* 实时同步配置
* 灰度配置

# Missing Features
* 客户端容灾

# Usage

- 启动客户端长连接监听

``` python
client = ApolloClient(app_id=<appId>, cluster=<clusterName>, config_server_url=<configServerUrl>)
client.start()
```

- 获取Apollo的配置
  ```
  client.get_value(Key, DefaultValue)
  ```

# Contribution
  * Source Code: https://github.com/filamoon/pyapollo/
  * Issue Tracker: https://github.com/filamoon/pyapollo/issues

# License
The project is licensed under the [Apache 2 license](https://github.com/zouyx/agollo/blob/master/LICENSE).

# Reference
Apollo : https://github.com/ctripcorp/apollo
cilantro-ee 0.0.4
Lamden Blockchain
Requires Python: >=3.6.5

<p align="center">  <img src="../dev/logo500.png" width="40%">
</p>

## Running your RCNet node
### Get a computer with Ubuntu 18.04.
* DigitalOcean droplets are our favorites if you are new.

* * *

### Install prerequisites:
Install Git if your OS doesn't have it preinstalled

##### Cent OS
```
sudo yum install git
```
##### Ubuntu
```
sudo apt-get install git-core
```

### Install Node requirements
```
sudo apt update
sudo apt install -y python3-pip redis-server mongodb
```
* * *

### Open your ports:
```
sudo ufw allow 443/tcp
sudo ufw allow 8080/tcp
sudo ufw allow 10000:10999/tcp
```
* * *

### Download Cilantro
```
git clone https://github.com/Lamden/cilantro-enterprise.git
cd cilantro-enterprise
git checkout demo
```
* * *
### Install Cilantro
```
sudo python3 setup.py develop
sudo make install
```
NOTE: Capnproto takes a *very* long time to install because it compiles from source. Please be patient!!

* * *
### Setup Node Configuration
```
python3 scripts/setup_node.py
```
### Enter your Signing Key (Private Key) as a Hex String
Find your Signing Key / Private Key in the Lamden Vault Chrome Plugin. If you don't have a wallet yet, get one by following the instructions here: [https://docs.lamden.io/lamden-vault/](https://docs.lamden.io/lamden-vault/)

![Image](../dev/wallet.png?raw=true)

Enter your wallet password to expose your Private Key, as shown above.

### Enter Constitution File Name
This is the file name of the initial configuration. Constitution files are located in the `constitutions` folder. If you don't know which one to use, ask an admin.

Example names: `rcnet.json`, `nojan.json`, `nohup.json`.

If you are not part of the constitution, this step will fail. You can't join the network if you are not a participant.

### Start your node
```
make stop-db
make start-db
python3 scripts/bootstrap.py
```

If you want to leave your node up and running while you log out of `ssh`, add `nohup` and `&` like this:
```
make stop-db
make start-db
nohup python3 scripts/bootstrap.py &
```

Your node is now up and running!
DS-OOP-Review 0.1.2
two modules
Requires Python: >=3.5

# LSDS Object Oriented Programming Review Assignment

Inside the `football` directory, you will find several files, including a blank `__init__.py`. Don't worry about that one right now. These files together can model several aspects of a football season including a player's statisctics, an individual football game, and a season.

As is, these modules are fully functional (well, they run without errors). You can generate a season report by running `season.py`, and you can run the tests using `football_test.py`.

That being said...

Each file (`game.py`, `players.py`, `season.py`, `possible_values.py`, and `football_test.py`) contains at least one `TODO` inside a comment. That is where you can add things and try them out to see if you're understanding how this is all done.

It makes the most sense to begin with `players.py` and `game.py` because they explain the class foundations for the rest of the files (`game.py` more so--since it is used in `season.py`).

To run anything here or in your own, edited version, clone the repo and navigate to the `football` directory in your terminal.
If you would like to run the tests or generate a season report, run `python filename.py` or `python3 filename.py` depending on your configuration with the appropriate choice of `football_test.py` or `season.py`.
If you would like to interactively create instances of the `Player`, `Quarterback`, `Game`, or your own, added, classes and run different methods on them, run `python` or `python3` in terminal and `import` the appropriate module (file name without the `.py`) on the python shell (when you see `>>>`, for example).


_Originally created by Joanne Jordan for Lambda School's Data Science program_
https://github.com/jojordan3/LSDS-OOP-assignment
broadcastify-archtk 1.0.2
The Broadcastify Archive Tool Kit
Requires Python: >=3.7

# The Broadcastify Archive Tool Kit (broadcastify-archtk)

The Broadcastify Archive Tool Kit (broadcastify-archtk) for python automates downloading audio archives from [Broadcastify](www.broadcastify.com), "the world's largest source of Public Safety, Airline, Rail, and Marine live audio streams".

broadcastify-archtk was initially developed as part of a group project during the summer 2019 [General Assembly Data Science Immersive program](https://generalassemb.ly/education/data-science-immersive/), in response to a client's need to visualize where first responders were being dispatched during emergencies. We sought out a large repository of emergency radio dispatches to train our audio-to-text-to-geolocation algorithm. Although Broadcastify was the clear winner in terms of breadth and depth, the lack of an API for downloading archived audio meant that the process for acquiring the data was highly manual and time-consuming.

broadcastify-archtk solves that problem.

## Resources

- View the package at [pyPI.org](https://pypi.org/project/broadcastify-archtk/)

- Check out [the docs](https://ljhopkins2.github.io/broadcastify-archtk/)

- View the repo at https://github.com/ljhopkins2/broadcastify-archtk/
pdfjinja 1.1.0
Use jinja templates to fill and sign pdf forms.

pdfjinja
========

.. image:: https://img.shields.io/badge/License-MIT%20License-blue.svg
  :target: https://raw.githubusercontent.com/rammie/pdfjinja/master/LICENSE

.. image:: https://api.travis-ci.org/rammie/pdfjinja.png?branch=master
  :target: https://travis-ci.org/rammie/pdfjinja


Use jinja templates to fill and sign PDF forms.

You can use this library to fill out a PDF form using data from an external
source such as a database or an excel file. Use a PDF editing software to edit
the form and specifiy a jinja template in the tooltip property of the form
field.


Dependencies
------------

You'll need the pdftk library. If you want to paste images, you'll need whatever
dependencies are necessary for Pillow to load your preferred image format.
Most of the packages below are taken from the Pillow documentation. You don't
need all of them. In most cases, just pdftk will do.


Ubuntu::

    apt-get install python-dev python-pip libtiff5-dev libjpeg8-dev \
        zlib1g-dev libfreetype6-dev liblcms2-dev libwebp-dev tcl8.6-dev \
        tk8.6-dev python-tk pdftk libmagickwand-dev


OSX::

  * Install pdftk (https://www.pdflabs.com/tools/pdftk-server/).
  * Install dependencies for Pillow if you want to paste images.


Windows::

  * Install pdftk (https://www.pdflabs.com/tools/pdftk-server/).
  * Install dependencies for Pillow if you want to paste images.


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

You can install pdfjinja with pip::

    $ pip install pdfjinja
    $ pdfjinja -h


Usage:
------

See examples/sample.pdf for an example of a pdf file with jinja templates.
The template strings are placed in the tooltip property for each form field
in the pdf.

See examples/output.pdf for the output. The data that the form is filled with
comes from examples/sample.json.


Basic::


    $ pdfjinja -j examples/simple.json examples/sample.pdf examples/output.pdf

Attachments::

    $ pdfjinja --font examples/open-sans/regular.ttf \
               --json examples/sample.json \
               examples/sample.pdf \
               examples/output.pdf


Python::

    from pdfjinja import PdfJinja

    pdfjinja = PdfJinja('form.pdf')
    pdfout = pdfjinja(dict(firstName='Faye', lastName='Valentine'))
    pdfout.write(open('filled.pdf', 'wb'))


If you are using this with Flask as a webserver::

    from flask import current_app
    from pdfjinja import PdfJinja
    pdf = PdfJinja('form.pdf', current_app.jinja_env)


See examples/example.py for a more detailed python example. It might also be
helpful to example the sample pdf template in examples/sample.pdf.
schedpy 0.1.0
A cron or job scheduler in python
Requires Python: >=3.6

SchedPy
=======

.. image:: https://img.shields.io/badge/Gitter-Join_chat-brightgreen.svg
    :target: https://gitter.im/schedpy/community

.. image:: https://mybinder.org/badge_logo.svg
 :target: https://mybinder.org/v2/gh/schedpy/schedpy/master?filepath=schedpy.ipynb

Advanced Cron or Job Scheduler in Python


SchedPy API
===========

>>> schedule.___1___(2).___3___.of(4).___5___.every(6).___7___.on(8).at(9).do(10)

1. first/last
2. value (default: 1)
3. days/weeks/months
4. value (default: 1)
5. weeks/months
6. value (default: 1)
7. minute/hour/day
8. days (monday, tuesday..) # todo
9. time (24 hour clock "22:00")# todo
10. Job/Function to run

References
==========

https://github.com/dbader/schedule