semvec/pypi-packages huggingface dataset:
requests-paginator 0.2.0
A generator for iterating over paginated API responses
License: MIT

# requests-paginator

![PyPI Version](https://img.shields.io/pypi/v/requests-paginator.svg)
![License](https://img.shields.io/pypi/l/requests-paginator.svg)

A generator for iterating over paginated API responses

## Installation

```
pip install requests-paginator
```

## Usage

Instantiate `RequestsPaginator` with:

* A URL to page 1 of the API output
* A function (or lambda) `get_nextpage(page)` which describes how to get the next page:
    * Return `None` to stop iteration.
    * `page` is an instance of [`requests.models.Response`](http://docs.python-requests.org/en/master/user/quickstart/#response-content)

Examples:

```py
from requests_paginator import RequestsPaginator

BASE = 'https://galaxy.ansible.com'

def get_next_page(page):
    body = page.json()
    if body['next_link']:
        return BASE +  body['next_link']
    return None

# instantiate the paginator
pages = RequestsPaginator(
    BASE + '/api/v1/categories/?page=1',
    get_next_page
)

# iterate over the pages
for page in pages:
    print("calling %s" % (page.url))
    page.raise_for_status()
    print("found %s results" % (len(page.json()['results'])))
```

```py
from requests_paginator import RequestsPaginator

def get_next_page(page):
    links = {}
    if "Link" in page.headers:
        linkHeaders = page.headers["Link"].split(", ")
        for linkHeader in linkHeaders:
            (url, rel) = linkHeader.split("; ")
            url = url[1:-1]
            rel = rel[5:-1]
            if rel == 'next':
                return url
    return None

# instantiate the paginator
pages = RequestsPaginator(
    'https://api.github.com/users/github/repos?page=1',
    get_next_page
)

# iterate over the pages
for page in pages:
    print("calling %s" % (page.url))
    page.raise_for_status()
    print("found %s results" % (len(page.json())))
```
mebo 0.1.0b1
Simple python interface to control the mebo toy robot
License: MIT

mebo
----

Mebo is a python package to control the `Mebo Robot <https://meborobot.com>`_ with Python. It is currently in active development, so there might be breaking changes. Some basic usage is defined below, but more extensive `documentation is available at ReadTheDocs <https://python-mebo.readthedocs.io/en/latest/>`_.

.. note::
    This project is not associated with the official Mebo project or its owners, Skyrocket LLC.

.. note::

    This package and the associated modules have been tested on Mebo version 1 *only*.


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

.. code:: 

   pip install mebo




Quickstart
----------

Some basic usage is below. The API will change and limited documentation exists, but it works for getting started.

.. code:: python

    from mebo import Mebo
    m = Mebo(auto_connect=True) # discover and connect automatically!
    m.move('n', speed=255, dur=1000)  # move forward at max speed for 1 second
    m.arm.up(dur=1000) # move the arm up for one second
    m.claw.open(dur=1000) # open the claw for one second


Development
-----------

Requirements:
~~~~~~~~~~~~~
* python >= 3.6

To get started with the project:

.. code:: 

    git clone https://github.com/crlane/python-mebo.git
    python -m venv mebo-venv
    . mebo-venv/bin/actvate
    pip install -r requirements.txt
    pip install -e .

To run the tests:

.. code::

    pip install -r test_requirements.txt
    py.test

Todo
~~~~

* [ ] Cleaner API (better subclasses, kwargs for component methods, no metaprogramming)
* [ ] Clean up kwargs inconsistency
* [ ] Better documentation
* [ ] Better tests
* [ ] Media stream (multithreading or asyncio, http with <video> tag)
pmark 0.0.9
PMark - Python Benchmark, A Simple yet intuitive python process benchmarking utility
License: MIT
Keywords: benchmark monitor python

pmark
=====

python benchmarking utility

Requirements
^^^^^^^^^^^^

1. **OS:** macOS Maverics+ or Ubuntu 14.04+
2. **Python:** v3.6.0+
3. **Tensorflow:** v1.4.0+

What is pmark?
^^^^^^^^^^^^^^

Pmark - “Python Benchmark” is a simple yet intutive process monitoring
tool, which can monitor, 1. CPU Usage 2. RAM Usage 3. GPU Usage
(Supports only NVidia for now)

Architecture:
^^^^^^^^^^^^^

.. figure:: https://github.com/kingspp/pmark/blob/master/pmark.png
   :alt: Architecture

   Architecture

1. A function with required arguments is sent to the utility.
2. The function is sent as a target for a python Process, which shares
   statistics using a BaseManager.
3. Required Monitors (CPU/GPU/RAM) are attached to the current process
   as threads.
4. The attached monitors are given the main process ``pid`` which helps
   us in extracting consumption of resources by the process, thereby
   increasing the accuracy of monitoring process.
5. Each of the monitors supports interval configuration which can be
   overridden by benchmark interval.
6. The threads for each monitor continues to run, untill main process is
   completed, once done, all the threads, including the main process are
   closed.
cw_msgpack_coder 1.1.8
Simple and fast Python any object serialization with use msgpack.
License: MIT
Keywords: msgpack serialization streaming object encoding decoding

CW Msgpack Coder
================

Introduction
------------

Simple pure Python object encoder and decoder using msgpack (u-msgpack-python package at bottom).

It allows encode Python object with high speed and compression since we using msgpack at bottom.

It reduce code overhead to minimum and allow you focus on algorithms.

How to use it
-------------

It is very simple:

.. code-block:: python

    from cw_msgpack_coder.umsgpack_coder import UmsgpackCoder


    class YourNestedClass:
        pass


    class YourClass:
        def __init__(name, nested)
            self.name = name
            self.nested = nested


    # create coder
    coder = UmsgpackCoder()

    # register your classes
    # required because of security reasons
    coder.set_default_coder_for_class(self.YourClass)
    coder.set_default_coder_for_class(self.YourNestedClass)

    # register old modules and classes names
    # required if you renamed some modules or classes and want load old data
    # not need for this example
    coder.set_old_module_and_class_name_to_current(
        'old_module_name', 'YourClass',
        '__main__', 'YourClass')

    # now create some objects to test
    o = YourClass('hello world!', YourNestedClass())

    # encode to bytes
    encoded = coder.dumps(o)

    # decode bytes to objects
    o2 = coder.decode(encoded)

    # o == o2!