semvec/pypi-packages huggingface dataset:
py-valid-proxy 0.3.1
Valid proxy server ('alive' or 'dead')
Requires Python: <4.0,>=3.8

# py-valid-proxy

### Installation

```
pip install py-valid-proxy
```

### Usage

``` python
import pprint
from py_valid_proxy import valid_proxy

"""Valid proxy server ('alive' or 'dead')

Parameters
----------
host : str
    IP Address
port : int
    Port
scheme: str, optional
    Scheme (default is 'http')
timeout: int, optional
    Connect timeout is number of seconds (default is 5 sec.)
    Returns
    -------
        None if proxy is 'dead'
        class Proxy if proxy is 'alive'
"""
proxy_info = valid_proxy('8.219.97.248', 80, 'https', 10)
if proxy_info:
	print('is alive')
	pprint(proxy_info)
else:
	print('is dead')
```

```shell
$ valid_proxy -h
usage: valid_proxy [-h] -ip IP -p P [-s {http,https,socks4,socks5}] [-t T] [-V]

Valid the functionality of the proxy server

options:
  -h, --help            show this help message and exit
  -ip IP                IP address of proxy server
  -p P                  PORT of proxy server
  -s {http,https,socks4,socks5}
                        SCHEME of proxy server
  -t T                  The connect timeout is the number of seconds
  -V, --version         show program's version number and exit

$ valid_proxy -ip 12.186.205.120 -p 80 -s http
http://12.186.205.120:80 ... is alive
anonymity: high_anonymous
country: US
response time: 4.71 (secs)

$ valid_proxy -ip 12.186.205.120 -p 80 -s https 
https://12.186.205.120:80 ... is alive
anonymity: transparent
country: US
response time: 0.5 (secs)

$ valid_proxy -ip 2.189.59.54 -p 80
http://2.189.59.54:80 ... is dead
```
memoizelabs 0.0.1.2
Fork, Memoize Labs' API for training and using human-like models.

# Fork, by Memoize Labs (V0.0.1.2)

**_Report bugs and get support at contact@memoizelabs.com_**

## Installation
For first-time users, begin by running:
```console 
foo@user:~$ pip install memoizelabs
``` 
For upgrading to the latest version, upgrade to the latest version by running:
```console 
foo@user:~$ pip install --upgrade memoizelabs
```

## Usage

### Methods

```Fork.fork(id, file_paths, isolated_voice_path, description='')```
* **Parameters:**
  * **id** _(str)_: the user-specified ID of the model. 
  * **file_paths** _(str array)_: a string of file paths containing objects to fine tune on. These can be .txt, .mp3, or .mp4 files. 
  * **isolated_voice_path** _(str)_: a path to a .mp3 file containing a clean recording of the target at least 30 seconds in length, used to pre-process submitted files and identify the target's voice within them before finetuning for better results. 
  * **description** _(str, optional)_: a description of the target (ex: An elderly woman with a deep, soothing voice, a British accent, and a witty sense of humor).

```StateMachine.state()```
* Returns:
  * The current state of the state machine, one of INIT, PRE-OP, OPERATIONAL, or FAULT.

```StateMachine.errors()```
* Returns:
  * Array of errors 


### Classes

```Fork(api_key)``` 
* **Parameters:**
  * **api_key** _(str)_: your Memoize Labs Fork API key. Get one at memoizelabs.com/fork

```StateMachine() ``` : A state machine for using real time interactive features with low latency and continous connection to the server.
* **States:**
 * INIT: the initialization state of the state machine. The state machine performs initial checks to confirm access to an audio device and wi-fi, then transitions to PRE-OP if checks pass or FAULT if an issue is detected.
 * PRE-OP: the state machine is ready to begin live streaming of data upon command. 
 * OPERATIONAL: the state machine is connected and exchanging live streams with the server. 
 * FAULT: the fault state of the state machine. Once the causal errors are resolved, the user must transition the state machine back to INIT state by calling ```StateMachine.transition_state(INIT)``` and initialization checks will be re-run.
docker-harpoon 0.19.0
Opinionated wrapper around docker
Requires Python: >=3.8
Keywords: docker

Harpoon
=======

An opinionated wrapper around the docker-py API that lets you use YAML to define
images and run tasks.

.. image:: https://travis-ci.org/delfick/harpoon.png?branch=master
    :target: https://travis-ci.org/delfick/harpoon

See http://harpoon.readthedocs.io for the full documentation.

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

Just use pip::

    $ pip install docker-harpoon

Configuration
-------------

Before Harpoon can be used, it must be configured. Configuration is obtained
from the following locations in the following order of precedence:

* Provided --harpoon-config value
* HARPOON_CONFIG environment variable
* ./harpoon.yml

Further, you can also define user-wide settings in your home directory at
``~/.harpoonrc.yml``. For example if you want the "dark" theme for the logging:

.. code-block:: yaml

    ---

    term_colors: dark

The contents of the harpoon config has only one mandatory option, ``images``.
This must be a dictionary of ``image_alias`` to ``image_options``:

.. code-block:: yaml

    ---

    images:
      cacafire:
        commands:
          - FROM ubuntu:14.04
          - RUN apt-get update && apt-get -y install caca-utils
          - CMD cacafire

A rough overview of all the options available can be found at
http://harpoon.readthedocs.org/en/latest/docs/configuration.html

Usage
-----

Once harpoon is installed, there will be a new program called ``harpoon``.

When you call harpoon without any arguments it will print out the tasks you
have available.

Unless you don't have a config file, in which case it'll complain you have no
configuration file.

Once you have a valid configuration file and have chosen a task you wish to
invoke, you may use the ``--task`` cli option to invoke that task::

    $ harpoon --task <task>

Most tasks will also require you to specify an image to work with::

    $ harpoon --task <task> --image <image_alias>

Simpler Usage
-------------

To save typing ``--task`` and ``--image`` too much, the first positional argument
is treated as ``task`` (unless it is prefixed with a dash) and the second
positional argument (if also not prefixed with a dash) is taken as the ``image``.

So::

    $ harpoon --task run --image my_amazing_image

Is equivalent to::

    $ harpoon run my_amazing_image

Changelog
---------

https://harpoon.readthedocs.io/en/latest/docs/changelog.html

Tests
-----

Run::

  > ./test.sh
FamzzXMadBypass 0.1.3
A module to bypass Adlink
Requires Python: >=3.6

# FamzzXMadBypass

A module to bypass Adlink.

# Example using

```py
import FamzzXMadBypass as bypasser

password = "Pasword"
url_to_bypass = "https://linkvertise.com/580726/fluxus1"
bypassed_link = bypasser.bypass(url_to_bypass, password)

print(bypassed_link)
```
# Supported
```py
import FamzzXMadBypass as bypasser

support_link = bypasser.supported()
print(support_link)
```
pbsc 0.2.0
High-Level API Client for Public Bike System Company
Keywords: data, python

# pbsc
High-Level API Client for Public Bike System Company

## install
```sh
pip install pbsc
```

## basic CLI usage
```sh
pbsc export-trips --base="https://example.publicbikesystem.net/operation/data" --username="jdoe" --password="2c56477e97ab8b2d180a6513" --api-key="8854c5384dd288fb8f0ad8" $PWD/trips.csv

pbsc export-stations --base="https://example.publicbikesystem.net/operation/data" --username="jdoe" --password="2c56477e97ab8b2d180a6513" --api-key="8854c5384dd288fb8f0ad8" $PWD/stations.csv

pbsc export-docks --base="https://example.publicbikesystem.net/operation/data" --username="jdoe" --password="2c56477e97ab8b2d180a6513" --api-key="8854c5384dd288fb8f0ad8" $PWD/docks.csv
```

## basic Python usage
```python
from pbsc import PBSC

client = PBSC(
    base ="https://example.publicbikesystem.net/operation/data",
    username = "jdoe",
    password = "2c56477e97ab8b2d180a6513",
    api_key = "8854c5384dd288fb8f0ad8"
)

## download csv of all trips to a file
client.export_trips("trips.csv")

## download csv of all stations to a file
client.export_stations("stations.csv")

## download csv of all docks to a file 
client.export_docks("docks.csv")
```