semvec/pypi-packages huggingface dataset:
sku 0.2
scikit-learn Utilities
License: MIT
Requires Python: >=3.6

<h3 align="center">
  <img src="https://raw.githubusercontent.com/mythologic/sku/master/logo/sku.png" width="300px" alt="sku">
</h3>
<p align="center">
  <a href="https://github.com/mythologic/sku/"><img alt="GitHub" src="https://img.shields.io/github/license/mythologic/sku/"></a>
  <a href="https://travis-ci.org/mythologic/sku/"><img alt="Travis" src="https://img.shields.io/travis/mythologic/sku/.svg"></a>
  <a href="https://pypi.python.org/pypi/sku/"><img alt="PyPI" src="https://img.shields.io/pypi/v/sku/.svg"></a>
  <a href="https://pepy.tech/project/sku"><img alt="Downloads" src="https://pepy.tech/badge/sku"></a>
</p>

#### Install

```sh
pip install -U sku
```

#### About

`sku` is a scikit-learn utilities package.

#### Usage

ItemEncoder:

```python
from sku import ItemEncoder

X = ['a', 'b', 'c']
ie = ItemEncoder()
ie.fit_transform(X)
# [0, 1, 2]
```

ItemVectorizer:

```python
from sku import ItemVectorizer

X = ['a,b,c', 'b,c', 'a,c,d,e,f', 'b']
iv = ItemVectorizer()
iv.fit(X)
iv.transform(['c,f'])
# [0, 0, 1, 0, 0, 1]
```

NumberBinarizer:

```python
from sku import NumberBinarizer

X = list(range(10))
nb = NumberBinarizer(bins=4)
nb.fit_transform(X)
# [0, 0, 0, 1, 1, 2, 2, 3, 3, 3]
```

RangeScaler:

```
from sku import RangeScaler

X = [30, 50, 100, 90, 80, 40]
rs = RangeScaler(out_range=(0, 10), floor=0, round=True)
rs.fit_transform(X)
# [3, 5, 10, 9, 8, 4]
```
sargilo 0.1.7
�� Data loader for Humans
License: MIT
Requires Python: >=2.7
Keywords: testing,data,mocking

Sargilo 
=======

�� Data loader for Humans

Sargilo lets you declare your data in a visually pleasing and non-frustrating way and loads it into your environment of choice. YAML usage, validation and auto-completion help you get boring jobs done.

�� Motivation
-------------

The idea for this project came from the testing I had to do at work. Surely, you will need sample data to test the project you currently work on. After some time, two ways how to approach this have been emerged:

- Create a minimal and abstract data sample for each test or group of tests and test against those
- Find a more comphrehensive data set that satisfies most of edge cases and only add to it in rare cases

There are of course advantages and disadvantages to both approaches. However, I prefer the second approach and think of it as telling a little story. I prefer this way since the dataset can be used as a fixture when running your application and after working on it for quite some time, you will get a feeling for the result a function should produce, making it easier to spot errors.

�� Install
----------

```bash
pip install sargilo
```

Or if you prefer an alternative installation method

```bash
poetry add sargilo
pipenv install sargilo
```

�� Integrations
---------------

To know how to load your data, `sargilo` has to know how to deal with your framework or ORM of choice. While `sargilo` provides the interface and basic functionaly, the specifics on how to load the data are up to the integration. Currently, the following integrations are supported:

- Django (ORM)

�� Examples
-----------

```python
# models.py
from django import models
from django.contrib.auth.models import User


class Tag(models.Model):
    name = models.CharField(max_length=255, blank=False, null=False)

class Post(models.Model):
    title = models.CharField(max_length=255)
    content = models.TextField()

    tag = models.ForeignKey(
        Tag,
        verbose_name='Tag',
        related_name='posts',
        on_delete=models.PROTECT
    )

    author = models.ForeignKey(
        User,
        verbose_name='Author',
        related_name='posts',
        on_delete=models.PROTECT
    )
```

```yaml
# dataset.yaml
auth:
  users:
    - &Admin
      username:     "Admin"
      first_name:   "Christoph"
      last_name:    "Smaul"
      email:        "christoph@mail.de"
      password:     "very_secret"
      is_staff:      True
      is_superuser:  True
    - &Editor
      username:     "Editor"
      first_name:   "Wendy"
      last_name:    "Lator"
      email:        "wendy@mail.de"
      password:     "very_secret"
      is_staff:      True
      is_superuser:  False


blog:
  tags:
    - &TestTag
      name: "Test"
    - &BlueTag
      name: "Blue"
  posts:
    - title: "Hello world"
      text: "Lorem ipsum dolor amet sunt"
      tag: *TestTag
      author: *Admin

    - title: "Just a test"
      text: "This is just a test. This is just a test. This is just a test."
      tag: *TestTag
      author: *Editor
```
Flask-AutoIndex 0.6.6
The mod_autoindex for Flask
License: MIT


Flask-AutoIndex
---------------

Flask-AutoIndex generates an index page for your `Flask`_ application
automatically. The result is similar to the one produced by the Apache
module `mod_autoindex`_, but the look is more awesome!

.. _Flask: https://palletsprojects.com/p/flask/
.. _mod_autoindex: http://httpd.apache.org/docs/current/mod/mod_autoindex.html

Links
`````

* `Documentation <https://flask-autoindex.readthedocs.io/>`_
* `Code repository and issue tracker <https://github.com/general03/flask-autoindex>`_
seleniumx 0.1.1
Selenium extension
License: MIT
Requires Python: >=3.6.0


https://setuptools.readthedocs.io/en/latest/setuptools.html#develop-deploy-the-project-source-in-development-mode
https://github.com/navdeep-G/setup.py

`python setup.py develop`
```python
url = 'https://www.google.com'

# Instantiate the class which wraps selenium webdriver base class, with an event listener for debugging
# and an automatic webdriver manager
ws = WebScraper()
# Setup_driver takes care of downloading the latest chrome binary. You must call this to start the chrome browser.
# By default, setup_driver will look for the path to the chrome binary first in an environment variable CHROMEDRIVER_PATH
# This variable is specific to Heroku deployments. If that is not set, it will download the
# latest chrome binary and save it to the project root directory.
# The browser will also not be headless.
ws.setup_driver()

# To override the defaults simply pass it keyword arguments.
# ws.setup_driver(chrome_driver_path='/absolute/path/to/a/directory/to/save/chromedriver/in',
#                 headless=True,
#                 version="2.26")

# If you want to setup a driver the old fashioned way, then you can point to an already installed version of chromedriver to use
# ws.setup_driver(chrome_driver_bin='/absolute/path/to/a/directory/to/save/chromedriver/in/chromedriver')

# ws.setup_driver(chrome_driver_bin='/Users/home/PycharmProjects/seleniumX/seleniumX/drivers/drivers/chromedriver/2.26/mac64/chromedriver')
ws.driver.get(url)

# Avoid bot detections
ws.random_sleep()  # Default is 5 - 10 seconds
ws.random_sleep(sleep_range=(1, 2))  # or you can pass a tuple of a different range.

# Access the driver like normal.
element = ws.driver.find_element_by_name("q")

# Use random key inputs to prevent bot detection
ws.random_send_keys("Hello World", element)
# lucky_btn = ws.driver.find_element_by_name("btnI")
search_btn = ws.driver.find_element_by_name("btnK")
search_btn.click()

# Shortened Webdriver wait class.
ws.wait().until(EC.title_contains("Hello World"))

# Quickly grab all the unique links from a webpage
ws.get_all_unique_links()

# Js Functions
ws.js_scroll_to_bottom()
element = ws.driver.find_element_by_name('g')
ws.js_scroll_into_view(element)

# Save a screenshot, by default will take the page title name as filename
ws.save_screenshot()
# Or pass it a filename
ws.save_screenshot("Googlesearchresults")

# Returns various info about the driver and page.
ws.get_info()

```