semvec/pypi-packages huggingface dataset:
vgengine 1.0.0
A general purpose game engine using the pygame graphics API and pymunk's physics engine.
License: MIT
Keywords: game engine

# Python Video Game Engine

A Python Video Game Engine powered by Pygame and Pymunk.

Make sure to run `python setup.py install`.

A game engine is essentially an SDL wrapper with a Physics Engine tied together with a robuts API of generalized Game Objects and Components.

Because of this, the component/system implementation of this engine resulted in three main systems:

* Physics
* Graphics
* Control

Coincidentally, this is essentially 

* Model
* View
* Control

the `examples` directory contains a working example of how to use the game engine, the components, and ultimately playing a rendering a simple scene that uses physics and graphics.
huasca 0.2.1
out-of-the-box computer vision
License: MIT
Requires Python: >=3.5
Keywords: computer-vision

# Huasca

##### Computer vision models OOB (out-of-the-bottle).

                     __
                    [__]
       ___        .+'. '+.
       )_(       /:;/ _.+'\
       + +       +:._   .++
     .+'+'+.  _  |:._     |
    /+::_..+_[_]_+:._CV   |
    )_     /_   _\:._     |
    +;:    )_``'_(:._     +
    +;::+..+;:.._++.____.+'
    `+.._..`+...+'

Huasca enables prototyping by prioritizing generalization and rapid development over accuracy.

##### Step into the cellar and select a bottle of computer visions.

  * Face detection & localization
  * Face classification
    * age
    * gender
  * Object detection & localization
  * Object tracking
  * Object classification w/o localization

Face and object localization include convenient cropping and annotation methods to feed classifiers.

## Roadmap

  * v0.3.0 - reduce and combine models to save space
  * v0.4.x - add style transfer
  * v0.4.x - face recognition

## Examples

### Detection

Detection results include:

  * `boxes`: Boxes follow PIL format of (left, upper, right, lower)
    * top-left corner is (0,0) and offsets go down/right from there (physics indexing)
  * `scores`: confidence score for each detected object
  * `labels`: label description of the object e.g. ['dog','person']
  * `portraits`: cropped objects from base image (PIL.Image format)
  * `base_image`: the source image (PIL.Image format)
  * `annotated`: the source image with objects annotated (PIL.Image format)

#### Face & Object Detection

    # Get a PIL image from somewhere:
    image = ...

    # Use PIL image as input:
    import huasca

    faces   = huasca.detect.faces(image)
    objects = huasca.detect.objects(image)

    # Display the first face
    faces.portraits[0].show()

    # Check classes
    print(objects.labels)

    # Retrieve annotated & labeled version of either
    faces.annotated.show()
    objects.annotated.show()

#### Face Demographics

    # Get a PIL image of a face from face detector:
    face = faces.portraits[0]

    gender,age = huasca.classify.demographics(face)


### Object Tracking

    import huasca

    data = json.load(json_data)
    object_log = huasca.object_tracking.track_objects(data)
    output_json = [obj.to_json() for obj in object_log]
python-fly 0.0.2
A python package to run concourse fly
License: MIT

Snakes on a plane
=================

A python package to run concourse fly

Useage
======

..  code:: python

    from fly import Fly
    fly = Fly(
        concourse_url='http://127.0.0.1:8080'
    )
    fly.get_fly()
    fly.login(username='admin', password='admin', team_name='main')
    fly.get_json('pipelines')
    fly.run(
        'set-pipeline',
        '-p', 'concourse-build',
        '-c', '/path/to/resource/pipeline.yaml',
        '-v', 'app-name=app_name',
        '-v', 'github-org=github-org',
        '-v', 'github-repo=https://github.com/ministryofjustice/concourse-build',
        '-n'
    )

Tests
=====

..  code:: bash

    python -m unittest tests.test_commands_run -v
requestspwn 1.0.0
Drop-in replacement for the requests library with random user agents as default.
License: MIT
Keywords: ctf http

# requestspwn
Drop-in replacement for the `requests` library with random user agents as default. Designed for Attack/Defense CTF competitions.

## Installation
```
$ pip install requestspwn
```

## Usage
Just replace the import lines like this:

* `import requests` to `import requestspwn as requests`
* `from requests` to `from requestspwn`

Example:

```python
from requestspwn import get
r = get('https://www.example.com')
```

Additionally, you can provide a list of user agents to choose from:

```python
from requestspwn import get
user_agents = [
	"Mozilla/5.0 (Windows NT 6.3; WOW64;Trident/7.0; rv:11.0) like Gecko",
	"Mozilla/5.0 (Windows NT 6.1; Win64; x64; rv:49.0) Gecko/20100101 Firefox/49.0"
]
r = get('https://www.example.com', user_agents=user_agents)
```

You can also use one of the datasets provided by default:

```python
from requestspwn import get
r = get('https://www.example.com', user_agents='ructfe2017')
```

## Additional notes
`requestspwn` will use a random user agent as default. If you pass a custom User-Agent header in the `headers` parameter, `requestspwn` will NOT replace it.

`requestspwn` wraps the `request`, `head`, `get`, `post`, `put`, `patch`, `delete`, `options` functions, and nothing else.
bresenham 0.2.1
An implementation of Bresenham's line drawing algorithm
License: MIT
Keywords: bresenham,pixel art

The bresenham module
====================

A simple implementation of Bresenham's line drawing algorithm.

See `the Wikipedia entry`_ for details on what that is.

.. _the Wikipedia entry: https://en.wikipedia.org/wiki/Bresenham's_line_algorithm

Note that this is a simple implementation.
It is written in Pure Python (without e.g. `numpy`), so it is relatively slow.

I found some beauty in combining the classic algorithm (whose ingenuity lies in
using only integers – a constraint that isn't really as relevant now)
with a Python generator (a modern device that follows the spirit of
“executable pseudocode”, abstracting away the output subroutine).
I hope others can appreciate the code as well.

For serious use, look at these:

* `skimage.draw.line`_, which solves the same problem *fast*.
* A `Numpy-based recipe`_ that generalizes the solution to <var>N</var>
  dimensions.

.. _`skimage.draw.line`: http://scikit-image.org/docs/dev/api/skimage.draw.html#skimage.draw.line
.. _`Numpy-based recipe`: http://code.activestate.com/recipes/578112-bresenhams-line-algorithm-in-n-dimensions/


Installation
============

In a Python virtual environment, do::

    python -m pip install bresenham

To install from a Git checkout (in editable mode)::

    python -m pip install -e.

To install without a virtual envitonment, add the ``--user`` option.


Usage
=====

The ``bresenham(x0, y0, x1, y1)`` function returns a generator of
the coordinates of the line from ``(x0, y0)`` to ``(x1, y1)``.

For example, the coordinates of a line from (-1, -4) to (3, 2), are::

    >>> from bresenham import bresenham

    >>> list(bresenham(-1, -4, 3, 2))
    [(-1, -4), (0, -3), (0, -2), (1, -1), (2, 0), (2, 1), (3, 2)]


Development
===========

You're welcome to join this project!

If you spot an issue, please report it at the `Issues page`_ on Github.

If you'd like to start changing the code or documentation, check out the code
locally using::

    git clone https://github.com/encukou/bresenham

If you're new to this, please read the `this guide`_ about collaborating
on Github-hosted projects like this one.

If that doesn't make sense, please `e-mail the author <encukou@gmail.com>`_
for clarification. I'd be happy to help you get started.

.. _Issues page: https://github.com/encukou/bresenham/issues
.. _this guide: https://guides.github.com/activities/contributing-to-open-source/
3gpp-citations 1.1.4
This project generates BiBTeX-files for 3GPP specifications.
License: MIT
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, <4

# 3GPP Bibtex entry generator

[![Build Status](https://travis-ci.org/martisak/3gpp-citations.svg?branch=master)](https://travis-ci.org/martisak/3gpp-citations) ![](https://img.shields.io/github/issues-raw/martisak/3gpp-citations.svg?style=flat) ![](https://img.shields.io/github/license/martisak/3gpp-citations.svg?style=flat) [![Coverage Status](https://coveralls.io/repos/github/martisak/3gpp-citations/badge.svg?branch=master)](https://coveralls.io/github/martisak/3gpp-citations?branch=master) [![Gitter chat](https://badges.gitter.im/martisak/3gpp-citations.png)](https://gitter.im/3gpp-citations/community "Gitter chat") [![](https://img.shields.io/pypi/v/3gpp-citations.svg?style=flat)](https://pypi.org/project/3gpp-citations/) ![](https://img.shields.io/pypi/dd/3gpp-citations.svg?style=flat) ![](https://img.shields.io/pypi/pyversions/3gpp-citations.svg?style=flat) [![HitCount](http://hits.dwyl.io/martisak/3gpp-citations.svg)](http://hits.dwyl.io/martisak/3gpp-citations) ![](https://img.shields.io/codeclimate/maintainability/martisak/3gpp-citations.svg?style=flat)

This project aims to generate [BiBTeX](http://www.bibtex.org/) files that
can be used when citing [3GPP](3gpp.org) specifications. The input is a document list exported from the [3GPP Portal](https://portal.3gpp.org/).

## Installation

`pip install 3gpp-citations`

To also install test dependencies run

`pip install 3gpp-citations[test]`

## Instructions

1. Go to the [3GPP Portal](https://portal.3gpp.org/#55936-specifications)
2. Generate the list of specifications you want.
3. Download to Excel and save file
4. Run `python 3gpp-citations.py -i exported.xlsx -o 3gpp.bib`
5. Use in LaTeX.

*Optionally* use the provided `3gpp.bib` directly.

## Things to note

* The output `bibtex` class is set to `@techreport`.
* If you add the option `--xelatex`, break-symbols `\-` will be used in url-fields.
* The version and date are read from 3gpp.org, but it is slow so it takes a while to parse the list. If you find an easy solution to this, let me know.

## Example output

~~~
@techreport{3gpp.36.331,
 author = {3GPP},
 day = {20},
 institution = {{3rd Generation Partnership Project (3GPP)}},
 month = {04},
 note = {Version 14.2.2},
 number = {36.331},
 title = {{Evolved Universal Terrestrial Radio Access (E-UTRA); Radio Resource Control (RRC); Protocol specification}},
 type = {Technical Specification (TS)},
 url = {https://portal.3gpp.org/desktopmodules/Specifications/SpecificationDetails.aspx?specificationId=2440},
 year = {2017}
}
~~~

## Contribute

See our [contribution guidelines](CONTRIBUTING.md) and our [Code of Conduct](CODE_OF_CONDUCT.md).

## Acknowledgment

This project has been updated as part of the [WASP Software and Cloud Technology](http://wasp-sweden.org/graduate-school/courses/software-and-cloud-technology-spring-2019/) course.

This work was partially supported by the Wallenberg AI, Autonomous Systems and Software Program (WASP) funded by the Knut and Alice Wallenberg Foundation.