semvec/pypi-packages huggingface dataset:
rabbot 0.3.4
A small utility for testing RabbitMQ connections.
License: MIT
Requires Python: >=3.7,<4.0
Keywords: tools,rabbitmq

# Rabbot

![Rabbot Logo](./assets/rabbot.png "Rabbot")

[![Build Status](https://cloud.drone.io/api/badges/dsudduth/rabbot/status.svg)](https://cloud.drone.io/dsudduth/rabbot)

A utility for validating connections to RabbitMQ servers.

## Installing Rabbot

```bash
pip install rabbot
```

## Development

This project relies on [Poetry](https://poetry.eustace.io/) for development, packaging, and publishing. You will need to have this tool installed on your machine before you can properly develop against Rabbot.

```bash
curl -sSL https://raw.githubusercontent.com/sdispater/poetry/master/get-poetry.py | python
```

Please see the [installation](https://poetry.eustace.io/docs/#installation) guide for other options.


## Contributing

See [CONTRIBUTING.md](CONTRIBUTING.md).

## Versioning

This project uses semantic versioning ([SemVer 2.0.0](https://semver.org/)). Incrementing versions is managed by [bumpversion](https://github.com/peritus/bumpversion).

To ensure that the repo is properly versioned, you will need to install `bumpversion`.

```bash
pip install bumpversion
```

Once installed, bump the version before pushing your code or created a pull request.

```bash
# Examples

# Bumping the major version to indicate a backwards incompatible change
bumpversion major

# Bumping the minor version
bumpversion minor

# Bumping the subminor due to a hotfix
bumpversion patch
```

*Note: Bumpversion is configured to automatically create a commit when executed.*
withtimer 0.1.0.dev1
Simple Python Timer class you can wrap around blocks of code you want to benchmark
License: MIT
Requires Python: >=2.7

# WITHTIMER

## Description

WithTimer is a Python module for benchmarking your code. It has the following features:

- Simple use
  - Just create a timer object, and it times execution until it goes out of scope
- Arbitrarily nested timers
  - Create as many nested timers as you want
  - Each timer pushes itself to a stack, and pops itself off when destroyed

## Example usage

```Python
with Timer(name="Something slow"):
  do_something_slow()
```

Timing is turned off by default, and can be optionally turned on. You can instrument your code with timers, and leave them in when you're not using them:

```Python
if args.enable_timing:
  Timer.enable_timing(args.enable_timing)
with Timer(name="Timers are a sometimes treat"):
  do_something()
```

You can nest timers:

```Python
with Timer(name="Outer timer"):
  for i in range(0, 100000):
    with Timer(name="Hope this isn't O(n^2)"):
      do_something_critical()
```

Here's a complete example:

```Python
from time import sleep
from withtimer.withtimer import Timer


def func1(count):
    for i in range(0, 3):
        with Timer(name="Calling func2"):
            func2(2)
    print("func1 sleeping {}".format(count))
    sleep(count)


def func2(count):
    print("func2 sleeping {}".format(count))
    sleep(count)


if __name__ == "__main__":
    Timer.enable_timing(True)
    with Timer(name="main"):
        for i in range(0, 3):
            if i % 2 > 0:
                func1(i+1)

```

Output:

```console
$ python3  ./example.py
[main] start
    [Calling func2] start
func2 sleeping 2
    [Calling func2] end	Elapsed time: 2.003 seconds

    [Calling func2] start
func2 sleeping 2
    [Calling func2] end	Elapsed time: 2.003 seconds

    [Calling func2] start
func2 sleeping 2
    [Calling func2] end	Elapsed time: 2.003 seconds

func1 sleeping 2
[main] end	Elapsed time: 8.015 seconds
$
```
remotedata 0.1.0
Accessing and caching remote data.
License: MIT
Requires Python: >=3.4,<4.0

# remotedata

Accessing and caching remote data for python.
May be used in the cases that:
1. The remote data is being updated frequently
2. You don't want to sync all the data but just per your request
3. You want to cache the data locally for some time
4. Especially, when the files are used for testing

## Installation

```shell
pip install remotedata
```

## Usage

Currently, data from `github` and `dropbox` are supported

### Github

```python
from remotedata import remotedata
rdata = remotedata(dict(
	source = 'github',
	cachedir = '/tmp/cached/',
	## if branch is not master: pwwang/remotedata/branch
	repos  = 'pwwang/remotedata',
	## optional, default is first part of repos
	# user = 'pwwang',
	## github token, in case you have > 60 requests per hours to github API
	# token = 'xxx',
))
readme = rdata.get('README.md')
# README.md is downloaded to /tmp/cache/github/pwwang.remotedata@master/README.md
# Now you can use it as a local file

# readme will be cached, we don't have to download it again,
# until it has been changed remotely.

# remove cached file
rdata.remove('README.md')
# clear up all caches
rdata.clear()
```

### Dropbox

```python
from remotedata import remotedata
rdata = remotedata(dict(
	source = 'dropbox',
	cachedir = '/tmp/cached/',
	dropbox_token = 'xxx'
))
rdata.get('/somefile') # or
rdata.get('somefile')
```
astc-codec 1.0.2
ASTC decoder for PIL
License: MIT

# ASTC_Codec
An ASTC decoder for PIL.

The decoder uses [Google/astc-codec](https://github.com/google/astc-codec) to decompress the data.


## Installation
- Cython required
### PIP
```
pip install astc_codec
```
### Manual
```cmd
python setup.py install
```


## Usage
### valid block_sizes

|block size | footprint | footprint id |
|---|---|---|
| (4, 4) | k4x4 | 0 |
| (5, 4) | k5x4 | 1 |
| (5, 5) | k5x5 | 2 |
| (6, 5) | k6x5 | 3 |
| (6, 6) | k6x6 | 4 |
| (8, 5) | k8x5 | 5 |
| (8, 6) | k8x6 | 6 |
| (10, 5) | k10x5 | 7 |
| (10, 6) | k10x6 | 8 |
| (8, 8) | k8x8 | 9 |
| (10, 8) | k10x8 | 10 |
| (10, 10) | k10x10 | 11 |
| (12, 10) | k12x10 | 12 |
| (12, 12) | k12x12 | 13 |

### PIL.Image decoder
```python
from PIL import Image
import astc_codec 
#needs to be imported once in the active code, so that the codec can register itself

raw_astc_image_data : bytes
block_size = (int, int) # see valid block_sizes
img = Image.frombytes('RGBA', size, raw_astc_image_data, 'astc', block_size)
```

### raw decoder
```python
from astc_codec import decompress_astc, ASTCDecompressToRGBA

# ASTC to RGBA
rgba_data = decompress_astc(astc_data : bytes, block_size : (int, int), width : int, height : int)

# ASTC to RGBA, direct mapping to the C++ function
# footprint = footprint id from valid block_sizes
rgba_data = ASTCDecompressToRGBA(astc_data : bytes, astc_data_size : int,
    width : int, height : int, footprint : int, out_buffer_size : int,
    out_buffer_stride : int)
```
axonbot-slack 1.0.16
Axonius Slack Bot
License: MIT
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
Keywords: axonius,slack,bot

[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
[![made-with-python](https://img.shields.io/badge/Made%20with-Python-1f425f.svg)](https://www.python.org/)
[![Code Style: Black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![Documentation Status](https://readthedocs.org/projects/axonbot-slack/badge/?version=latest)](https://axonbot-slack.readthedocs.io/en/latest/?badge=latest)

# Axonius Slack Bot

This is a [Slack bot](https://api.slack.com/bot-users) for [Axonius](https://www.axonius.com/). It enables users in Slack to interact with an Axonius instance in a number of ways:

* Get a report of objects in JSON format sent to you in a new thread.
* You can search for user objects by username, email (using regex or not).
* You can search for device objects by hostname, IP address, or MAC address (using regex or not).
* You can search for user or device objects by a query built in the Query Wizard of the Axonius GUI.
* You can add or remove labels in the thread that is started up for returned objects.

Documentation can be found [here](https://axonbot-slack.readthedocs.io/en/latest/).

For questions, feature requests, or bug reports, you can:
* File an issue on the [Issue Tracker](https://github.com/Axonius/axonbot_slack/issues)
* Email apiclient@axonius.com

This is publicly available in a few places:
* [GitHub](https://github.com/Axonius/axonbot_slack)
* [Docker](https://hub.docker.com/r/axonius/axonbot_slack)
* [PyPi](https://pypi.org/project/axonbot-slack/)