semvec/pypi-packages huggingface dataset:
github-report 0.1
Generates a report of metadata about repositories for a GitHub user or organization
Requires Python: >=3.6

Description
-----------

This script helps analyze GitHub repositories for a user or organization. It
fetches a list of repositories owned by a user or organization and generated a
custom report in a number of formats.

In particular, it was designed for showing the size of repositories and the LFS
storage they use. Unfortunately the GitHub API doesn't report the LFS usage,
so this tool with clone the repos in order to get the LFS size. This is slow,
but it is the primary purpose of this tool, since there's no other way to do it.

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

- Python 3.6+
- [requests](https://requests.readthedocs.io/en/master/)
- [GitPython](https://github.com/gitpython-developers/GitPython)
- Git
- [Git LFS](https://git-lfs.github.com/)

Local Development Setup
-----------------------

- Create a virtualenv:
  `virtualenv <path>`
- Activate your virtualenv:
  `source <path>/bin/activate` (on Linux/Mac), `source <path>/Scripts/activate`
  (in bash on Windows), or `<path>\Scripts\activate.bat` (in Windows command
  prompt)
- Use `pip install -r requirements.txt` in your virtualenv to install required
  libraries.
- Run `python github_report.py`. You may need command-line options to
  specify options. See `python github-storage-usage.py -h` for option help.

Authentication
--------------

Without authentication you can generate a report for any user's or organization's
public repos. To include private repos you will need to authenticate as a user
who has permission to see them. To do so, log into GitHub and generate a
[personal access token](https://github.com/settings/tokens) that has at least
the `repo` permission. Pass this token on the command-line to the `--token`
option, or put it in a `.token` file (or some other file that can be read with
the `--token-file` option).
checkerboard 0.2.4
More robust checkerboard detection, similar algorithm to libcbdetect

# Checkerboard

[![PyPI version](https://badge.fury.io/py/checkerboard.svg)](https://badge.fury.io/py/checkerboard)
[![GitHub license](https://img.shields.io/github/license/lambdaloop/checkerboard.svg)](https://github.com/lambdaloop/checkerboard/blob/master/LICENSE)

I could not find any libraries to find checkerboards robustly in Python, except for OpenCV.
However, OpenCV's checkerboard tends to fail when the checkerboard is somewhat blurred or rotated.

Hence, this library was born. It may be slightly slower than OpenCV, but it will **find** that checkerboard.

Comparison of OpenCV vs this library (OpenCV on the left, checkerboard on the right):
![comparison](https://thumbs.gfycat.com/HomelyAccurateBettong.webp)

## Quickstart

You can install checkerboard easily through pip:
```bash
pip install checkerboard
```

Then you can go ahead and detect checkerboards like so:
```python
from checkerboard import detect_checkerboard

size = (9, 6) # size of checkerboard
image = ... # obtain checkerboard
corners, score = detect_checkerboard(image, size)
```

The `corners` returned are in the same format as the
`findChessboardCorners` function from OpenCV, and are already computed
to subpixel precision.

The `score` returned is a metric of the quality of the checkerboard
detection. A perfectly detected checkerboard would have a score of 0,
whereas a bad detection would have a score of 1.


## References

The implementation of checkerboard detection is mainly based on [libcbdetect](http://www.cvlibs.net/software/libcbdetect/) 
and accompanying paper:
```
@INPROCEEDINGS{Geiger2012ICRA,
  author = {Andreas Geiger and Frank Moosmann and Oemer Car and Bernhard Schuster},
  title = {Automatic Calibration of Range and Camera Sensors using a single Shot},
  booktitle = {International Conference on Robotics and Automation (ICRA)},
  year = {2012}
} 
```
db2py 0.0.1
A Python interface to create and edit databases, and to hash passwords.


Usage: <br />
<pre>
    >>> import db2py
    >>> db = db2py.createdb("mydatabase", {"user1": "password1"})
    >>> db = updatedb(db, {"user2": "PWD2"})
    >>> meth = getmeth()
    >>> for username, pwd in getdb(db):
    ...    db = updatedb(db, {username: hashpwd(pwd, meth)})
    >>> savedb(*getdb(db), "database1.db")
    >>> db = opendb("database1.db")
    >>> deldb("database1.db")
</pre>