semvec/pypi-packages huggingface dataset:
SpoofMailer 1.0.0
By ussing SpoofMailer you can send unlimited spoof email or make your own mailing server API

# SpoofMailer

This is a python pip module that is use for sending spoof mail without need to create any server. Or you can create your own email API.

## Step 1 :-

```
import SpoofMailer as sp
```

## Step 2 :-

```
sp.set_sender_name("Name")
```

## Step 3 :-

```
sp.set_sender_email("email@example.com")
```

## Step 4 :-

```
sp.set_receiver_email("receviver@example.com")
```

## Step 5 :-

```
sp.set_subject("Subject of the mail")
```

## Step 6 :-

```
sp.set_body("Body of the email")
```

## Final step

```
rq = sp.send()

if ( rq == 200 ):
    print("Mail sent!")
else:
    print("Error :"+rq)
```
Your mail was successfully sent!


Don't use this service for illegal purpose. **We are not responsible for your crimes**.

[@DipankerShah](https://www.facebook.com/dipankar.shah.5)
Contact me
jaffle 0.2.4
Python app and process orchestration tool for development environment
Keywords: orchestration interactive process test pytest watchdog

Jaffle is an automation tool for Python software development, which does:

- Instantiate Python applications in a Jupyter kernel and allows them to call
  each other
- Launch external processes
- Combine log messages of all Python applications and external processes
  enabling filtering and reformatting

Jaffle contains WatchdogApp that can watch filesystem events and call
arbitrary code or command. That allows you to automate testing, reloading
applications, etc.

Examples
========

- `Auto-testing with pytest`_
- `Automatic Sphinx Document Build`_
- `Web Development with Tornado and React`_
- `Jupyter Extension Development`_

.. _`Auto-testing with pytest`: http://jaffle.readthedocs.io/en/latest/cookbook/pytest.html
.. _`Automatic Sphinx Document Build`: http://jaffle.readthedocs.io/en/latest/cookbook/sphinx.html
.. _`Web Development with Tornado and React`: http://jaffle.readthedocs.io/en/latest/cookbook/tornado_spa.html
.. _`Jupyter Extension Development`: http://jaffle.readthedocs.io/en/latest/cookbook/jupyter_ext.html

GitHub Respository
==================

`yatsu/jaffle`_

.. _`yatsu/jaffle`: https://github.com/yatsu/jaffle

Documentation
=============

`Jaffle documentation`_

.. _`Jaffle documentation`: http://jaffle.readthedocs.io
hellp 0.0.1
Python Pipe Operator

# HellP: Python Hell Pipe Helper

`pip install HellP` then:

Instead of `f(x)` Write `x | p(f)`

Instead of `p(lambda x: x.attr[item])` Write `px.attr[item]`

Instead of

```python
from pathlib import Path

print(' '.join(list(map(str, filter((lambda x: x.is_dir()), Path('/etc').glob('*'))))))
```

Write:

```
from pathlib import Path
from thep import p, px

Path('/etc') | p.filter(px.is_dir) | p.map(str) | p(list) | p(' '.join) | p(print)
```
pyzub 0.1.6
A small package and CLI for manipulating and creating subtitles (SubRip, .srt, etc.)
Requires Python: >=3.0

## Pyzub: Manipulate subtitles

Pyzub is a small package and CLI for manipulating subtitles

**Suported Formats:**

- SubRip [.srt].

**Plans to Support:**

- SubStation Alpha [.ssa]
- SubViewer [.sub]
- Universal Subtitle Format [.usf]

### Installation:

Run `pip install pyzub`

### Command Line Interface:

At the moment only the *slide* command is available (arguably the most important feature).
The *slide* command of *pyzub* lets you move your subtitles so you can synchronize them manually.

```
$ pyzub slide -h
Usage: pyzub slide [OPTIONS] FILEPATH

Options:
  --hours FLOAT
  --minutes FLOAT
  --seconds FLOAT
  --milliseconds FLOAT
  --microseconds FLOAT
  --overwrite           Modifies the subtitle file in place.
  --verbose             Displays a progress bar and a message when finished.
  --help, -h            Show this message and exit.
```

**Example:**

This will move your subtitles by 2.5 seconds (you can also give negative values):

```bash
$ pyzub slide Game_of_Thrones_s03ep09.srt --seconds 2 --milliseconds 500
```

By default *pyzub* will generate an output file named *Game_of_Thrones_s03ep09_MODIFIED.srt*, unless ```--overwrite``` is used. The output file will always be in *utf-8* encoding and use your system new line character.

This is OK too:

```bash
$ pyzub slide Game_of_Thrones_s03ep09.srt --seconds -70.5 --milliseconds 5000
```
 This would move your subtitles 65.5 seconds back ~~in time~~.

### Package:

You can read a subtitle file:

```python
from pyzub.subfiles import SRTFile

filepath = '/home/user/mysubtitle.srt'
subfile = SRTFile(filepath)
```

Iterate over the file:
```
for subtitle in subfile:
	print(subtitle)
```

Print a SRTFile:

```python
print(subfile)
```

```
Relative Path: /home/user/mysubtitle.srt
Codec: ISO-8859-1
No. of Subtitles: 451
```

Get a subtitle:

```python
# idx could be a number from 1 to 451 in this case
subtitle = subfile.get_subtitle(idx)
```

Print the subtitle:

```python
print(subtitle)
```

```
Index: 1
Start Time: 00:00:04,605
End Time: 00:00:06,105
Text: En un día cualquiera,
```

An of course modify anything you want directly:

```python
# modify the text
subtile.text = 'modified subtitle'

# times use timedelta from the datetime package
subtitle.start_time = timedelta(minutes=10)
# also, you can assign directly a string
subtitle.end_time = '01:25:59,650'

# write the changes to disk
subfile.dump('/home/user/mysubtitle_modified.srt')
```

And finally:

```
print(len(subfile))
# output: 451 (i.e, the number of subtitles in the file)
```

```
print(len(subtitle))
# output: 21 (i.e, the number of chars in the subtitle's text attribute)
```

### Planned features:
- Insert, delete subtitles, etc.
- Automatic grammar and syntax correction

### License

MIT
binance-db 0.0.2
Binance data cache
Keywords: binance data cache

# Binance DB

A local cache for Binance data, stored in Postgres

## Setup

### Server

On the server you wish to run the Postgres DB on.

```bash
git clone https://github.com/StoicPerlman/binance-db.git
export BDB_POSTGRES_PASS=supersecret
docker-compose up -d
```

This will pull all available 1 minute candles from Binance and store them in a Postgres DB container. This container has a persistant volume configured for the data, meaning it can be deleted and restarted as much as you want.

When started it will check if there is any existing data in the DB. If not it will fetch all. This takes less than 15 mintes and takes up about 250 MB at the time of this writing. If there is existing data it will pull just the data starting from the newest entry in the DB.

A thread is started and connected to the Binance web socket. This will add new data as it is available. If you do not want continuously updating data you can run both containers then just kill the binance-db one.

### Client

You can pip install this package to connect to DB and have a sqlalchemy session started for use in your own app.

```bash
pip3 install binance-db
```

```python
# if you did not override any settings on the server 
# all you have to supply is url and password
from binance_db.db import BinanceDB
from binance_db.candle import Candle

bdb = BinanceDB(user=pguser, password=pgpass, url=pgurl, port=pgport, db=pgdb)

# this is a normal sqlalchemy session
# see binance_db.candle.Candle for schema
db = bdb.get_session()

new = db.query(Candle).filter_by(pair='BTCUSDT').order_by(Candle.close_time.desc()).first()

print(new.pair)
print(new.open_time)
print(new.close_time)
print(new.open_price)
print(new.close_price)
print(new.high)
print(new.low)
print(new.volume)
print(new.qav) # Quote asset volume
print(new.trades) # Number of trades
print(new.tbbav) # Taker buy base asset volume
print(new.tbqav) # Taker buy quote asset volume
```