semvec/pypi-packages huggingface dataset:
jacc-hammer 0.0.1
Python library for fuzzy matching large data sets.
License: MIT
Requires Python: >=3.6.1,<4.0.0

Jacc-hammer
===========

[![Tests](https://github.com/nestauk/jacc-hammer/workflows/Tests/badge.svg)](https://github.com/nestauk/jacc-hammer/actions?workflow=Tests)
[![PyPI](https://img.shields.io/pypi/v/jacc-hammer.svg)](https://pypi.org/project/jacc-hammer/)
[![Documentation Status](https://readthedocs.com/projects/nesta-jacc-hammer/badge/?version=latest&token=88196bd1571cb2234edba8b6aacce27afe14a8533e31c64a9d1b4accb451d426)](https://nesta-jacc-hammer.readthedocs-hosted.com/en/latest/?badge=latest)


Fuzzy matching for larger datasets
snowyowl 2020.11.12
Python library for working with Snowflake data warehouse
License: MIT
Requires Python: ~=3.6
Keywords: database

# *SnowyOwl*

## Usage

```python
from snowyowl import Snowflake
snowflake = Snowflake(
	user='user', 
	password='password', 
	warehouse='warehouse',
	account='account'
)

snowflake.get_data('SELECT * FROM database.schema.table LIMIT 10')
```
slytherin 2020.11.12
Python library of useful but lonely functions and classes
License: MIT
Requires Python: ~=3.6

# Slytherin
Slytherin is a collection of useful but lonely functions and classes 
that don't belong to other libraries.

## Installation
```bash
pip install slytherin
```

## Usage

### `collections`

#### `cross_lists()`

```python
from slytherin.collections import cross_lists
list1 = [1, 2, 3]
list2 = [4, 5]
list3 = [[6, 7], [8, 9]]

cross_lists(list1, list2, list3)
```
outputs:
```
[(1, 4, [6, 7]),
 (1, 4, [8, 9]),
 (1, 5, [6, 7]),
 (1, 5, [8, 9]),
 (2, 4, [6, 7]),
 (2, 4, [8, 9]),
 (2, 5, [6, 7]),
 (2, 5, [8, 9]),
 (3, 4, [6, 7]),
 (3, 4, [8, 9]),
 (3, 5, [6, 7]),
 (3, 5, [8, 9])]
```

```python
cross_lists([list1, list2, list3])
```
also outputs:
```
[(1, 4, [6, 7]),
 (1, 4, [8, 9]),
 (1, 5, [6, 7]),
 (1, 5, [8, 9]),
 (2, 4, [6, 7]),
 (2, 4, [8, 9]),
 (2, 5, [6, 7]),
 (2, 5, [8, 9]),
 (3, 4, [6, 7]),
 (3, 4, [8, 9]),
 (3, 5, [6, 7]),
 (3, 5, [8, 9])]
```


### get_size(obj)
The *get_size()* method calculates the memory footprint of a Python object recursively. 

The *exclude_objects* argument is a list of objects and is optional with the default value
of None. 
Any object in the *exclude_objects* list will be excluded from the recursive search. 
It can be used to avoid double counting the size when objects point to each other. 

```python
from slytherin import get_size
get_size(obj=[1,2,3], exclude_objects=None)

import pandas as pd
get_size(obj=pd.DataFrame({'id': range(1000), 'name':['Godric', 'Helga', 'Rowena', 'Salazar']*250}))
```

### colour(text, text_colour, style, background_colour)
The *colour()* method can be used to add colour to printing text.

The colour are integers from 0 to 7:
* black: 0
* red: 1
* green: 2
* yellow: 3
* blue: 4
* purple: 5
* cyan: 6
* white: 7

The *style* argument is an integer between 0 and 5:
* normal: 0
* bold: 1
* underline: 2
* negative1: 3
* negative2: 5

```python
from slytherin import colour
print(colour(text='Hello world!', text_colour=4))
```
chronometry 2020.11.12
Python library for tracking time and displaying progress bars
License: MIT
Requires Python: ~=3.6

# *Chronometry*

## `ProgressBar`

## `Estimator`
`Estimator` is an object that estimates the running time of a single argument function.
You can use it to avoid running a script for too long. 
For example, if you want to cluster a large dataset and running it might take too long, 
and cost too much if you use cloud computing, 
you can create a function with one argument `x` which takes a sample with `x` rows 
and clusters it; then you can use `Estimator` to estimate how long it takes to run it 
on the full dataset by providing the actual number of rows to the `estimate()` method.

`Estimator` uses a *Polynomial* *Linear Regression* model 
and gives more weight to larger numbers for the training.

### Usage

```python
from chronometry import Estimator
from time import sleep

def multiply_with_no_delay(x, y):
    return (x ** 2 + 0.1 * x ** 3 + 1) * 0.00001 + y * 0.001

def multiply(x, y):
    sleep_time = multiply_with_no_delay(x, y)
    if sleep_time > 30:
        raise
    sleep(sleep_time)
    if y == 6:
        sleep(12)
    elif 7 < y < 15:
        raise Exception()
    return sleep_time

estimator = Estimator(function=multiply, polynomial_degree=3, timeout=5)
# the `unit` argument chooses the unit of time to be used. By default unit='s'

estimator.auto_explore()
estimator.predict_time(x=10000, y=10000)
```
The above code runs for about *53* seconds and then estimates that 
`multiply(10000, 10000)` will take *1002371.7* seconds which is only slightly
smaller than the correct number: *1001010* seconds.

`max_time` is the maximum time allowed for the estimate function to run.

If you are using `Estimator` in *Jupyter*, 
you can plot the measurements with the `plot()` method (no arguments needed) which 
returns a `matplotlib` `AxesSubplot` object and displays it at the same time.

```python
estimator.plot('x')

estimator.plot('y')
```
ceramic 2020.11.12
Python library for defining data tables as tiles
License: MIT
Requires Python: ~=3.6

# *Ceramic*

*Ceramic* is a Python library for turning dataframes into *mosaics* for 
ease of use. For example, you can create a mosaic with *X* and *y* tile columns and 
*training* and *test* tile rows for fitting and testing machine learning models.