semvec/pypi-packages huggingface dataset:
captcha-manager 0.0.2.1
CaptchaManager
License: MIT
Keywords: sneaker bot development

captcha-manager
===============

captchamanager abstracts captcha token retrieval.

Motivation
----------

Some programs may require the retrieval of valid captcha tokens. Often,
this is accomplished through services like `2Captcha`_ that return a
valid token given an API key and the challenge site key. captchamanager
abstracts this functionality so programs can receive a single token or
can load a queue of tokens. Tokens are represented by their value,
generation time, and expiration time.

Note
----

Currently, captchamanager only supports 2Captcha.

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

captchamanager is available via pip

::

    $ pip install captcha-manager

Usage
-----

.. code:: python

    from captchamanager import CaptchaManager

    TWO_CAPTCHA_API_KEY = 'ABC123'
    SITE_KEY = 'DEF456'
    PAGE_URL = 'https://example.com'
    captcha_manager = CaptchaManager(TWO_CAPTCHA_API_KEY, SITE_KEY, PAGE_URL)
    token = captcha_manager.get_captcha_token() # Returns a single token ASAP

    captcha_manager.start_captcha_queue()
    # Do something
    token = captcha_manager.wait_for_captcha_token() # Returns one valid token from queue

.. _2Captcha: https://2captcha.com/enterpage
schedulerplus-client 0.0.16
A python schedulerplus client
License: MIT
Keywords: sample setuptools development

example:

1.`export serverIp = xxx export serverPort = xxx`

2.schedulerplus_client.conf
```
[schedulerplus_client]
zk_url = localhost:2181
schedulerplus_url = localhost:8888
job_group = demogroup

```

3.demo_executor.py
```python
from schedulerplus.client.job_executor import JobExecutor
from schedulerplus.client.job_code_messages import *


class DemoExecutor(JobExecutor):

    def execute(self, external_data):
        print external_data
        return SUCCESS_CODE, SUCCESS_MESSAGE
```


4.web_main.py
```python
import cherrypy
from schedulerplus.client.config import Config
Config.instance().load("xxx")

from schedulerplus.client.job_dispatcher import JobDispatcher
from schedulerplus.client.job_register import JobRegister

from demo.demo_executor import DemoExecutor


class JobDispatchController(object):
    job_dispatcher = JobDispatcher()

    @cherrypy.expose
    @cherrypy.tools.json_in()
    def dispatch(self):
        form = cherrypy.request.json
        self.job_dispatcher.dispatch(form)


if __name__ == "__main__":
    JobRegister.instance().register("demo", DemoExecutor())
    cherrypy.quickstart(JobDispatchController())
```
Diophantine 0.2.0
A python package for finding small solutions of systems of diophantine (integer algebra) equations
License: MIT
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, <4
Keywords: mathematics,diophantine,algebra,integer,systems

Diophantine
===========

.. image:: https://travis-ci.org/tclose/Diophantine.svg?branch=master
   :target: https://travis-ci.org/tclose/Diophantine
   :alt: Unit Test Status
.. image:: https://coveralls.io/repos/github/tclose/Diophantine/badge.svg?branch=master
   :target: https://coveralls.io/github/tclose/Diophantine?branch=master
   :alt: Unit Test Coverage

Author: Thomas G. Close (tom.g.close@gmail.com)

Diophantine (http://github.com/tclose/Diophantine) is a Python package for
finding small (integer) solutions of systems of diophantine equations
(see http://en.wikipedia.org/wiki/Diophantine_equation). It is based on  PHP
code by Keith Matthews (see www.number-theory.org) that implements the
algorithm described in https://github.com/tclose/Diophantine/blob/master/algorithm.pdf
(see http://www.numbertheory.org/lll.html for a list of associated publications),
which uses the LLL algorithm to calculate the Hermite-normal-form described in
the paper:

Extended gcd and Hermite normal form algorithms via lattice basis reduction,
G. Havas, B.S. Majewski, K.R. Matthews, Experimental Mathematics, Vol 7 (1998) 125-136

(please cite this paper if you use this code in a scientific publication)

There are two branches of this code in the GitHub repository 
(see https://github.com/tclose/Diophantine.git), 'master', which uses the
sympy library and therefore uses arbitrarily long integer representations, and 
'numpy', which uses the numpy library, which is faster but can suffer from
integer overflow errors despite using int64 representations

To find small solutions to a system of diophantine equations, A x = b, where A
is a M x N matrix of coefficents, b is a M x 1 vector and x is the
N x 1 vector, use the 'solve' method in the module, e.g.

    >>> from sympy import Matrix
    >>> from diophantine import solve
    >>> A = Matrix([[1, 0, 0, 2], [0, 2, 3, 5], [2, 0, 3, 1], [-6, -1, 0, 2],
                    [0, 1, 1, 1], [-1, 2, 0,1], [-1, -2, 1, 0]]).T
    >>> b = Matrix([1, 1, 1, 1])
    >>> solve(A, b)
    [Matrix([
    [-1],
    [ 1],
    [ 0],
    [ 0],
    [-1],
    [-1],
    [-1]])]

The returned solution vector will tend to be one with the smallest norms. If multiple solutions with the same norm are found they will all be returned. If there are no solutions the empty list will be returned.

Diophantine is released under the MIT Licence (see Licence for details)

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

Diophantine is available from the Python Package Index (http://pypi.python.org) and can be installed with the command

    pip install diophantine

Alternatively, the master branch can be installed from using the setuptools install command

    python setup.py install

 from a clone of the GitHub repository (https://github.com/tclose/Diophantine) or simply adding the cloned directory to your PYTHONPATH.