semvec/pypi-packages huggingface dataset:
biblio 0.0.4
an extremely fast and simple documentation generator
License: MIT

# biblio

biblio is an extremely fast and simple documentation generator for Python. At its core, biblio is just a wrapper that transalates Pythons native AST into a structure that can then be formatted and outputted.

## Architecture

Unlike Sphinx, biblio does not run any of your code, only parse it. This results in a much faster and more reliable documentation generation process. Using the AST also allows biblio to generate rich and in-depth output.

## TODO

biblio is fukin wip man

- Implement methdology for linking/parsing out types in data
  - We need to somehow extract types and modify the parsed docstrings to include links
- Proper HTML output
  - Theme
  - Search
- Write docs
  - Hightlight metaprogramming struggle
- Allow for live outputting w/ inotify
- Multiprocessing
voiceads 0.0.5
VoiceAds.ai Python SDK
License: MIT
Keywords: voiceads,voiceads.ai,alexasdk

voiceads
---------

# Install the package

you can install the package locally in the current folder by using the following command: 

#from main public PIP repo

pip install -t ./ voiceads

----------

## SDK usage: 

from voiceads import VoiceAdsAI

appToken = '<YOUR APP TOKEN>'

appType = '<YOUR APP TYPE>'

va = VoiceAdsAI()

params = {
    'appName' : '<YOUR APP NAME>',

    'appId': '<YOUR APP ID>',

    'appType': '<YOUR APP TYPE>',

    'appCategory' : '<YOUR APP CATEGORY>'
}

va.initialize(appToken, appType, params)

resp = va.getAd()
sumproduct 0.0.7
The sum-product algorithm. (Loopy) Belief Propagation (message passing) for factor graphs
License: MIT

`sumproduct <https://pypi.python.org/pypi/sumproduct>`__
========================================================

|Build Status| |Downloads|

An implementation of Belief Propagation for factor graphs, also known as
the sum-product algorithm
(`Reference <http://web4.cs.ucl.ac.uk/staff/D.Barber/pmwiki/pmwiki.php?n=Brml.HomePage>`__).

::

    pip install sumproduct

.. figure:: http://f.cl.ly/items/2P021j2y3A2Q191F451h/unnamed0.png
   :alt: Simple factor graph

   Simple factor graph
The factor graph used in ``test.py`` (image made with
`yEd <http://www.yworks.com/en/products_yed_applicationfeatures.html>`__).

Basic Usage
-----------

Create a factor graph
~~~~~~~~~~~~~~~~~~~~~

::

    from sumproduct import Variable, Factor, FactorGraph
    import numpy as np

    g = FactorGraph(silent=True) # init the graph without message printouts
    x1 = Variable('x1', 2) # init a variable with 2 states
    x2 = Variable('x2', 3) # init a variable with 3 states
    f12 = Factor('f12', np.array([
      [0.8,0.2],
      [0.2,0.8],
      [0.5,0.5]
    ])) # create a factor, node potential for p(x1 | x2)
    # connect the parents to their children
    g.add(f12)
    g.append('f12', x2) # order must be the same as dimensions in factor potential!
    g.append('f12', x1) # note: f12 potential's shape is (3,2), i.e. (x2,x1)

Run Inference
~~~~~~~~~~~~~

sum-product algorithm
^^^^^^^^^^^^^^^^^^^^^

::

    >>> g.compute_marginals()
    >>> g.nodes['x1'].marginal()
    array([ 0.5,  0.5])

Brute force marginalization and conditioning
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

The sum-product algorithm can only compute exact marginals for acyclic
graphs. Check against the brute force method (at great computational
expense) if you have a loopy graph.

::

    >>> g.brute_force()
    >>> g.nodes['x1'].bfmarginal
    array([ 0.5,  0.5])

Condition on Observations
^^^^^^^^^^^^^^^^^^^^^^^^^

::

    >>> g.observe('x2', 2) # observe state 1 (middle of above f12 potential)
    >>> g.compute_marginals(max_iter=500, tolerance=1e-6)
    >>> g.nodes['x1'].marginal()
    array([ 0.2,  0.8])
    >>> g.brute_force()
    >>> g.nodes['x1'].bfmarginal
    array([ 0.2,  0.8])

Additional Information
^^^^^^^^^^^^^^^^^^^^^^

``sumproduct`` implements a parallel message passing schedule: Message
passing alternates between Factors and Variables sending messages to all
their neighbors until the convergence of marginals.

Check ``test.py`` for a detailed example.

Implementation Details
----------------------

See block comments in the code's methods for details, but the
implementation strategy comes from Chapter 5 of `David Barber's
book <http://web4.cs.ucl.ac.uk/staff/D.Barber/pmwiki/pmwiki.php?n=Brml.HomePage>`__.

.. |Build Status| image:: https://travis-ci.org/ilyakava/sumproduct.svg?branch=master
   :target: https://travis-ci.org/ilyakava/sumproduct
.. |Downloads| image:: https://pypip.in/download/sumproduct/badge.svg
   :target: https://pypi.python.org/pypi/sumproduct/
bunqclient 2017.7.17
Python client for the bunq public API
License: MIT
Keywords: bunq,client,bank,api,bunqclient

# bunqclient
Python client for the bunq public API

![Code Climate](https://codeclimate.com/github/bartbroere/bunqclient.svg)
![BCH compliance](https://bettercodehub.com/edge/badge/bartbroere/bunqclient?branch=master)
![Release](https://img.shields.io/pypi/v/bunqclient.svg)
![Licence](https://img.shields.io/pypi/l/bunqclient.svg)
![Versions](https://img.shields.io/pypi/pyversions/bunqclient.svg)

## Installation
Installing the latest release can be done from PyPi:
```
pip install bunqclient
```

The latest unreleased version can be installed from GitHub:
```
git clone https://github.com/bartbroere/bunqclient/
cd ./bunqclient
python setup.py install
```

## Usage
Before using it, make sure that you understand the cost scheme of this API. 
Replace the value of the parameter ``secret`` with the API key generated in
the bunq app.

```python
from bunqclient import BunqClient
bunq = BunqClient(secret="")
```

To use the sandbox version change the ``base`` parameter. Note that you should
use a separate API key for this. A sandbox key can be acquired by asking bunq
support.

```python
from bunqclient import BunqClient
bunq_sandbox = BunqClient(base="https://sandbox.public.api.bunq.com/v1", 
                          secret="")
```

``LIST`` requests are basically ``GET`` requests without a specified key. The 
first two API calls have the same effect. The third requests a specific 
``monetary-account``. Due to the way Python interprets variable names, dashes
(``-``) in API methods and keys should be replaced with underscores (``_``).

```python
bunq.request(method="LIST", monetary_account="", user=1)
bunq.request(method="GET", monetary_account="", user=1)
bunq.request(method="GET", monetary_account=11, user=1)
```

These API calls return a python dictionary with the query's result.

## Contributing
To report bugs and submit feature requests, please open an issue on GitHub.
Pull requests that resolve issues or TODO's are also greatly appreciated.
os_nova_ha_utils 1.2.3
Python Openstack utils package
License: MIT

# Simple module for Python level access to OS information.

This module is used as part of NOVA HA module used in OpenStack Deployment at CRA.

## Development

Running tests

```console
python -m pytest
```

## Release

Before release bump version number in setup.py and then push it to pypi servers.

##### Test release upload first

```console
python setup.py sdist upload -r pypitest
```

##### Release upload
```console
python setup.py sdist upload -r pypi
```
footballdata 0.3.1
A collection of wrappers over football (soccer) data from various websites / APIs. You get: Pandas dataframes with sensible, matching column names and identifiers across datasets. Data is downloaded when needed and cached locally. Example Jupyter Notebooks are in the Github repo.
License: MIT
Keywords: football,soccer,metrics,sports,statistics

Football Data Analysis Toolkit
==============================

.. image:: https://img.shields.io/pypi/v/footballdata.svg
    :target: https://pypi.python.org/pypi/footballdata
    :alt: Latest PyPI version

.. image:: https://travis-ci.org/skagr/footballdata.png
   :target: https://travis-ci.org/skagr/footballdata
   :alt: Latest Travis CI build status


A collection of wrappers over football [*]_ data from various websites / APIs. You get: Pandas dataframes with sensible, matching column names and identifiers across datasets. Data is downloaded when needed and cached locally. Example Jupyter Notebooks are in the Github repo.

.. [*] Soccer, if you're a heathen

Data sources:
-------------

fivethirtyeight.com
~~~~~~~~~~~~~~~~~~~
(https://projects.fivethirtyeight.com/soccer-predictions)

Season 2016-17 predictions and results for the top European and American leagues.

football-data.co.uk
~~~~~~~~~~~~~~~~~~~
(http://www.football-data.co.uk/)

Historical results, betting odds and match statistics for English, Scottish, German, Italian, Spanish, French, Dutch, Belgian, Portuguese, Turkish and Greek leagues, including a number of lower divisions. Level of detail depends on league.

clubelo.com
~~~~~~~~~~~
(http://clubelo.com)

First team relative strengths, for all (?) European leagues. Recalculated after every round, includes history.

Roadmap:
--------

Add player stats, transfers, injuries and suspensions.


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

.. code:: bash

    $ pip install footballdata

Dependencies
~~~~~~~~~~~~

- `Numpy <http://www.numpy.org/>`_
- `Pandas <http://pandas.pydata.org/>`_
- `Requests <http://docs.python-requests.org/en/master/>`_
- `Unidecode <https://pypi.python.org/pypi/Unidecode>`_

Usage
-----

.. code:: python

    import footballdata as foo

    # Create class instances
    five38 = foo.FiveThirtyEight()
    elo = foo.ClubElo()
    mhist = foo.MatchHistory('ENG-Premier League', '2016-17')

    # Create dataframes
    matches = five38.read_games()
    forecasts = five38.forecasts()
    current_elo = elo.read_by_date()
    team_elo_history = elo.read_team_history('Barcelona')
    epl_2016 = mhist.read_games()

See the Jupyter Notebooks here for more elaborate examples: https://github.com/skagr/footballdata/tree/master/notebooks

Compatibility
-------------

Tested against Python 2.7 and 3.4-3.6

Licence
-------

MIT
rezparser 1.0.0
A pure Python library for parsing Macintosh Rez source files
License: MIT
Requires Python: >=3.6
Keywords: rez resource macintosh mac macos

``rezparser``
=============

A pure Python library for parsing Macintosh Rez source files, which are used by the legacy ``Rez`` and ``DeRez`` tools to compile, modify and decompile Macintosh resource fork data.

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

Python 3.6 or later, as well as `PLY`__ (tested with version 3.10, but older and newer versions probably work too).

__ https://pypi.python.org/pypi/ply

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

``rezparser`` is available `on PyPI`__ and can be installed using ``pip``: 

.. code-block:: sh

	python3 -m pip install rezparser

Alternatively you can install a local copy:

.. code-block:: sh

	python3 -m pip install -e .

__ https://pypi.python.org/pypi/rsrcfork

Changelog
---------

Version 1.0.0
`````````````

* Initial release version
srp-ext 1.0.7.1
Secure Remote Password
License: MIT



This package provides an implementation of the Secure Remote Password
protocol (SRP). SRP is a cryptographically strong authentication
protocol for password-based, mutual authentication over an insecure
network connection.

Unlike other common challenge-response autentication protocols, such
as Kerberos and SSL, SRP does not rely on an external infrastructure
of trusted key servers or certificate management. Instead, SRP server
applications use verification keys derived from each user's password
to determine the authenticity of a network connection.

SRP provides mutual-authentication in that successful authentication
requires both sides of the connection to have knowledge of the
user's password. If the client side lacks the user's password or the
server side lacks the proper verification key, the authentication will
fail.

Unlike SSL, SRP does not directly encrypt all data flowing through
the authenticated connection. However, successful authentication does
result in a cryptographically strong shared key that can be used
for symmetric-key encryption.

For a full description of the pysrp package and the SRP protocol,
please refer to the `srp module documentation`_.

.. _`srp module documentation`: http://packages.python.org/srp