semvec/pypi-packages huggingface dataset:
mcuuidButWorks 0.3
Getting Minecraft Player Information from Mojang API.

# MCUUID
Getting Minecraft Player Information from Mojang API.

## Usage
1. `pip install mcuuid`
2. Use the module like this:

### API
```
from mcuuid.api import GetPlayerData

player = GetPlayerData(identifier)

if player.valid is True:
    uuid = player.uuid
    name = player.username
```

Identifier can be a username or a UUID.

When `identifier = "gronkh"`:
`uuid` will be `"a2080281c2784181b961d99ed2f3347c"`
and `name` will be `"Gronkh"`


```
player = GetPlayerData(identifier, timestamp)
```

Some names are time-sensitive. (When they are changed)
So you can choose a special time.

It even works with UUIDs. They respond the username at the given time.

### Tools
Syntax check of username
```
from mcuuid.tools import is_valid_minecraft_username

if is_valid_minecraft_username('gronkh'):
  print('Valid')
```

Syntaxcheck of UUID
```
from mcuuid.tools import is_valid_mojang_uuid

if is_valid_mojang_uuid('a2080281c2784181b961d99ed2f3347c'):
  print('Valid')
```

## Test file
Usage
```
$ python test.py gronkh
```
or
```
$ python test.py a2080281c2784181b961d99ed2f3347c
```
or
```
$ python test.py
Please enter a username or UUID:
gronkh
```
or
```
$ python test.py
Please enter a username or UUID:
a2080281c2784181b961d99ed2f3347c
```

Response:
```
UUID: a2080281c2784181b961d99ed2f3347c
correct name: Gronkh
```

## License
This software is licensed under the MIT license. Feel free to use it however you like.
snapchat 0.1
Unofficial SnapChat API

# snapchat
> Unofficial SnapChat API (work in progress)
## Example useage
```python
>>> from snapchat import *
>>> me = SnapChat("sdushantha")
>>> me.check_username()
'sdushantha is already taken!'
>>> # Since the usename is taken, that means it is a valid username
>>> me.get_snapcode(bitmoji=False, size=500)
(..., 'PNG', '500x500')
>>> # The dotted part (...) is the raw data of the image
>>> # You use this data to write it into a file or do whatever you like
```

More features to come. I am trying my best to find endpoints which can be used. 
Feel free to let me know if you find any cool SnapChat endpoints that can be used :)
quiet.py 0.1
Quiet Modem, to transmit data with sound

quiet.py
========

Python ctypes bindings for libquiet to transmit data with sound.

## Usage
1. Encode a message, and then decode it
```
from quiet import Encode, Decoder

def test():
    encoder = Encoder()
    decoder = Decoder()

    for chunk in encoder.encode('hello, world'):
        message = decoder.decode(chunk)
        if message is not None:
            print(message)


test()
```

2. decode messages from recording in realtime

```
import sys
import pyaudio
from quiet import Encode, Decoder

def decode():
    if sys.version_info[0] < 3:
        import Queue as queue
    else:
        import queue

    FORMAT = pyaudio.paFloat32
    CHANNELS = 1
    RATE = 44100
    CHUNK = 16384  # int(RATE / 100)

    p = pyaudio.PyAudio()
    q = queue.Queue()

    def callback(in_data, frame_count, time_info, status):
        q.put(in_data)
        return (None, pyaudio.paContinue)

    stream = p.open(format=FORMAT,
                    channels=CHANNELS,
                    rate=RATE,
                    input=True,
                    frames_per_buffer=CHUNK,
                    stream_callback=callback)

    count = 0
    with Decoder(profile_name='ultrasonic-experimental') as decoder:
        while True:
            try:
                audio = q.get()
                audio = numpy.fromstring(audio, dtype='float32')
                # audio = audio[::CHANNELS]
                code = decoder.decode(audio)
                if code is not None:
                    count += 1
                    print(code.tostring().decode('utf-8', 'ignore'))
            except KeyboardInterrupt:
                break


decode()
```
tseries-featurizer 0.5
A time series featurizer.

# Time-Series Featurizer

This module helps with the time series featurization, providing many tools and a simple interface for custom tools creation.

- Time-Domain Featurization
	- Mean
	- Min / Max
	- Standard deviation
	- Kurtosis
	- Skewness
	- ...

- Frequency-Domain Featurization
	- Peak detection
	- Energy
	- ...

- Auto-regression
	- AR
	- ARMA
	- ARIMA
	- VAR
	- ...

- Wavelet transform
- Hilbert's transform
simple-slackbot 0.1.0
A simple python wrapper for the slack API

# slackbot
A simple python wrapper for the [Slack](https://slack.com) api

## Requirements

* [SlackClient](https://github.com/slackapi/python-slackclient)

## Installation

```
pip install simple-slackbot
```

## Usage

### Generate a slack api token

First you need to get the slack api token for your bot. You can create a bot on the [slack website](https://api.slack.com) and manage permissions.

### Instantiate a SlackBot

```
from slackbot import SlackBot

slackbot = SlackBot()
```

By default, the SlackBot retrieved the slack token from environment variable `SLACK_API_TOKEN`.
You can overwrite the default behaviour by instantiating with the `token` argument. 

If running it in a Jupyter notebook, instantiate with `run_async=True`.

### Send a message

You can send messages to any channel (using the channel name or id), or any user (just set `channel=@<username>`) 
`slackbot.send_message(channel='#general', message='Hello!')`

### Send a file

You can also send files over slack, to any channel or user.

`slackbot.send_file(channel='#general', file='<filepath>', message='Check out this file!')`

### More using the slack api directly

You can access methods from the raw slack client to use them directly.

`slackbot.client.chat_postMessage(...)`