semvec/pypi-packages huggingface dataset:
amqpclient 0.1.0
Simple AMQP python CLI applications for receiving/sending
License: MIT
Keywords: script helper AMQP CLI text console

# amqpclient [![Build Status](https://travis-ci.org/okurz/amqpclient.svg?branch=master)](https://travis-ci.org/okurz/amqpclient)
Simple AMQP python CLI applications for receiving/sending


## Communication

If you have questions, contact me (*okurz*) irc.freenode.net, e.g. in
[#opensuse-factory](irc://chat.freenode.net/opensuse-factory).


## Contribute

This project lives in https://github.com/okurz/amqpclient

Feel free to add issues in github or send pull requests.

TODOs and ideas are tracked in the file `TODO` as well as github issues.

### Rules for commits

* Every commit is checked by [Travis CI](https://travis-ci.org/travis) as soon as
  you create a pull request but you *should* run `tox` locally,

* It would be nice to keep the test coverage or increase it, e.g. by adding
  test reference data for new scenarios. TDD is advised :-)

* For git commit messages use the rules stated on
  [How to Write a Git Commit Message](http://chris.beams.io/posts/git-commit/) as
  a reference

If this is too much hassle for you feel free to provide incomplete pull
requests for consideration or create an issue with a code change proposal.

## License

This project is licensed under the MIT license, see LICENSE file for details.
minoshiro 0.1.9
An async Python3.6 library to search for anime, manga andlight novel using various web apis.
License: MIT

# Minoshiro [![Build Status](https://travis-ci.org/Mino-shiro/Minoshiro.svg?branch=master)](https://travis-ci.org/Mino-shiro/Minoshiro) [![Documentation Status](https://readthedocs.org/projects/minoshiro/badge/?version=latest)](http://minoshiro.readthedocs.io/en/latest/?badge=latest)

Inspired by the Roboragi [Reddit bot](https://github.com/Nihilate/Roboragi), Minoshiro is an async Python library that brings various web APIs for anime, manga, and light novel into one place.

## Features
* Simple and modern Pythonic API using `async/await` syntax
* Fetches search results from up to 9 different websites
* Cached search results for faster access
* Integrates with existing databases

## Requirements
Requires [Python3.6](https://www.python.org/downloads/) or above. Python3.5 and below is not supported.

## Install
To install the base version, simply install from PyPi:
```
pip install minoshiro
```

This library also comes with a PostgreSQL support, to use this feature you will need a PostgreSQL version 9.6 or above instance hosted.

To install with the built in PostgreSQL support, use:
```
pip install minoshiro[postgres]
```

This installs [asyncpg](https://github.com/MagicStack/asyncpg) alongside of the base requirements.

## Documentation
Documentation can be found at https://minoshiro.readthedocs.io/en/latest/

You can also find some quick examples in this [file](https://github.com/Mino-shiro/Minoshiro/blob/master/example.py).

## License
Minoshiro is released under the MIT license. See the license [file](https://github.com/Mino-shiro/Minoshiro/blob/master/LICENSE) for more details.
slacktory 1.0.5
Simple Slack interface
License: MIT

# Slacktory

A decorator which is called using:
```python
@slacktory.watch('the text to watch for')
``` 
...that watches a specified Slack channel for **new** Slack message posts whose ['text'] value is equivalent to the provided string argument

Requires **Python 3.7**
## Installation



```sh
pip install slacktory
```
For this decorator to work, you must first create a [Slack App](https://api.slack.com/apps)

Then create a **local_settings.py** file in your project's root directory with the following content:

```python
name = '<your Slack channel name>'
channel = '<your Slack channel id>'
token = '<your Slack API token>'
webhook = '<your Slack channel webhook>'

```

---------------------------------------------------

All of the above information can be obtained when setting up your [Slack App](https://api.slack.com/apps)

## Usage example

```python
>>> import slacktory
>>> @slacktory.watch('do the thing') # the decorator 
>>> def the_thing():

        # do something here...

```
In the above example, the_thing() will be called once the @slacktory.watch decorator has detected the text '_do the thing_' in a new Slack message in the Slack channel (specified in **local_settings.py**).



## Release History


* 1.0.0
    * first release
* 1.0.1
    * minor README changes
* 1.0.2
    * minor README changes
* 1.0.3
    * use nonlocal variables to remove the need for a recursive call on decorated function
    * remove polling, add while True
* 1.0.4
    * Add try/except with error message for import local_settings
    * Add license copy
* 1.0.5
    * add exception handling

## Meta

James Coleman – jamescoleman@me.com

Distributed under the MIT license. See ``LICENSE`` for more information.

[gitlab.com/jamescoleman/slacktory](https://gitlab.com/j9mes/slacktory)

## Contributing

1. Fork it (<https://gitlab.com/j9mes/slacktory/forks/new>)
2. Create your feature branch (`git checkout -b feature/fooBar`)
3. Commit your changes (`git commit -am 'Add some fooBar'`)
4. Push to the branch (`git push origin feature/fooBar`)
5. Create a new Pull Request
django-admin-related 0.2
The "Django Admin Related" prevents you from deleting your models if you have related items
License: MIT
Requires Python: >=3.3

Django Admin Related
====================

this project makes it impossible for the user to delete objects that contain other objects related by django admin.

Obs: this project works only in django admin

# Install:
    pip install django-admin-related

# Usage:

1. Add to your INSTALLED_APPS, in settings.py:
    ```
    INSTALLED_APPS = [  
        ...
        'django_admin_related',
        ...
    ]  
    ```

2. Create admin for your model:
    ```
    from django.contrib.admin import register
    from django_admin_related.admin import VerifyRelated

    @register(YouModel)
    class YouModelAdmin(VerifyRelated):
        """
            from best performance use `verify_related_fields`
            because this check all fields is a point to other model
            and `verify_related_fields` is a direct way.
        """
        pass
    ```

3. Test:

        try this: create a simple model, and simple related model, and exclude a first model.

# Advanced:

1. if you need to specify relationships, you can do so :
    ```
    from django.contrib.admin import register
    from django_admin_related.admin import VerifyRelated

    @register(YouModel)
    class YouModelAdmin(VerifyRelated):
        """
            from best performance use `verify_related_fields`
            because this check all fields is a point to other model
            and `verify_related_fields` is a direct way.
        """
        verify_related_fields = ('field', 'field2', ...)
    ```
dtreeplt 0.1.43
Visualize Decision Tree without Graphviz.
License: MIT

# dtreeplt
it draws Decision Tree not using Graphviz, but only matplotlib.  
If `interactive == True`, it draws Interactive Decision Tree on Notebook.

## Output Image using proposed method: dtreeplt (using only matplotlib)
![graphviz](output/result.png)

## Output Image using conventional method: export_graphviz (Using Graphviz)
![graphviz](output/using_graphviz.png)

## Output Image using dtreeplt Interactive Decision Tree  

![graphviz](output/idt_demo.gif)

## Installation
If you want to use the latest version, please use them on git.  

`pip install git+https://github.com/nekoumei/dtreeplt.git`

when it comes to update, command like below. 

 `pip install git+https://github.com/nekoumei/dtreeplt.git -U`


Requirements: see requirements.txt    
Python 3.6.X.

## Usage
### Quick Start
```python
from dtreeplt import dtreeplt
dtree = dtreeplt()
dtree.view()
# If you want to use interactive mode, set the parameter like below.
# dtree.view(interactive=True)

```
### Using trained DecisionTreeClassifier
```python
# You should prepare trained model,feature_names, target_names.
# in this example, use iris datasets.
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from dtreeplt import dtreeplt

iris = load_iris()
model = DecisionTreeClassifier()
model.fit(iris.data, iris.target)

dtree = dtreeplt(
    model=model,
    feature_names=iris.feature_names,
    target_names=iris.target_names
)
fig = dtree.view()
#if you want save figure, use savefig method in returned figure object.
#fig.savefig('output.png')
```
tsvisualize 1.0
Time-series Visualization with the Matrix Profile and Multidimensional Scaling.
License: MIT

# TimeSeriesVisualization
Visualization of Time-Series with the Matrix Profile and Multidimensional Scaling - a Python Implementation.

## Introduction
Multidimensional scaling is an algorithm that projects a set of objects represented by their distance matrix into a lesser dimensional space, such that the pairwise distance is preserved as much as possible. If we project onto a 1-dimensional or a 2-dimensional space, we can even plot the resultant projections, and visually understand the similarity between these objects.  
At a first glance, this seems applicable to time-series as well, where we want to capture similar regions across the entire time-series.  
However, since we do not know apriori where our regions of interest are, we can simply select all subsequences of a given length from the original time-series.  
Let's try this out!


## References
<b>Matrix Profile III: The Matrix Profile Allows Visualization of Salient Subsequences in Massive Time Series</b>.    
Chin-Chia Michael Yeh, Helga Van Herle, and Eamonn Keogh. IEEE ICDM 2016.
future-fstrings 1.2.0
A backport of fstrings to python<3.6
License: MIT
Requires Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*

[![Build Status](https://asottile.visualstudio.com/asottile/_apis/build/status/asottile.future-fstrings?branchName=master)](https://asottile.visualstudio.com/asottile/_build/latest?definitionId=15&branchName=master)
[![Azure DevOps coverage](https://img.shields.io/azure-devops/coverage/asottile/asottile/15/master.svg)](https://dev.azure.com/asottile/asottile/_build/latest?definitionId=15&branchName=master)

future-fstrings
===============

A backport of fstrings to python<3.6.


## Installation

`pip install future-fstrings`


## Usage

Include the following encoding cookie at the top of your file (this replaces
the utf-8 cookie if you already have it):

```python
# -*- coding: future_fstrings -*-
```

And then write python3.6 fstring code as usual!

```python
# -*- coding: future_fstrings -*-
thing = 'world'
print(f'hello {thing}')
```

```console
$ python2.7 main.py
hello world
```

## Showing transformed source

`future-fstrings` also includes a cli to show transformed source.

```console
$ future-fstrings-show main.py
# -*- coding: future_fstrings -*-
thing = 'world'
print('hello {}'.format((thing)))
```

## Transform source for micropython

The `future-fstrings-show` command can be used to transform source before
distributing.  This can allow you to write f-string code but target platforms
which do not support f-strings, such as [micropython].

To use this on modern versions of python, install using:

```bash
pip install future-fstrings[rewrite]
```

and then use `future-fstrings-show` as above.

For instance:

```bash
future-fstrings-show code.py > code_rewritten.py
```

[micropython]: https://github.com/micropython/micropython

## How does this work?

`future-fstrings` has two parts:

1. A utf-8 compatible `codec` which performs source manipulation
    - The `codec` first decodes the source bytes using the UTF-8 codec
    - The `codec` then leverages
      [tokenize-rt](https://github.com/asottile/tokenize-rt) to rewrite
      f-strings.
2. A `.pth` file which registers a codec on interpreter startup.

## you may also like

- [future-breakpoint](https://github.com/asottile/future-breakpoint)