semvec/pypi-packages huggingface dataset:
farsi-tools 0.2
Farsi Tools: Tools for processing Farsi (Persian) text
License: MIT
Requires Python: >=3.4

![alt text][pypi_version] ![alt text][licence_version]

# Farsi Tools: tools for processing Farsi (Persian) text

Tested with:
* Python 3.5+

Use the following command to install using pip:
```
pip install farsi-tools
```

## Usage example
### Converting digits

Use `replace_arabic_digits_with_farsi` method to replace arabic digits with farsi digits.
```python
from farsi_tools import replace_arabic_digits_with_farsi

replace_arabic_digits_with_farsi('٤')  # returns ۴
```

Use `replace_ascii_digits_with_farsi` method to replace ASCII digits with farsi digits.
```python
from farsi_tools import replace_ascii_digits_with_farsi

replace_ascii_digits_with_farsi('4')  # returns ۴
```

Use `replace_farsi_digits_with_ascii` method to replace farsi digits with ASCII digits.
```python
from farsi_tools import replace_farsi_digits_with_ascii

replace_farsi_digits_with_ascii('۴')  # returns 4
```

Use `replace_arabic_digits_with_ascii` method to replace farsi digits with ASCII digits.
```python
from farsi_tools import replace_arabic_digits_with_ascii

replace_arabic_digits_with_ascii('٤')  # returns 4
```


### Convert text to Farsi (Persian)
Use `standardize_persian_text` method to convert characters to standard persian form
```python
from farsi_tools import standardize_persian_text

standardize_persian_text('سلام خوبي؟ کمك ﻧميخواي؟') # returns "سلام خوبی؟ کمک نمیخوای؟"
```

### Get Farsi (Persian) stop-words
Use `stopwords` method to retrieve list of persian stop-words
```python
from farsi_tools import stop_words

stop_words()
```


[pypi_version]: https://img.shields.io/pypi/v/farsi_tools.svg "PYPI version"
[licence_version]: https://img.shields.io/badge/license-MIT%20v2-brightgreen.svg "MIT Licence"
annotlib 1.0.0
The package annotlib is a library of techniques to simulate the labeling behaviour of real annotators.
License: MIT
Keywords: active learning machine learning annotator labeling

# annotlib: Simulation of Annotators

authors: Marek Herde and Adrian Calma

![](https://github.com/acalma/annotlib/workflows/annotlib/badge.svg)

# Introduction

*annotlib* is a Python package for simulating annotators in an active learning setting.
Solving classification problems by using supervised machine learning models requires samples assigned to class labels.
However, labeling these samples causes costs (e.g. workload, time, etc.), so that active learning strategies aim at reducing these costs by selecting samples, which are the most useful for training a classifier.

In real-world scenarios, human annotators are often responsible for providing the class labels.
Unfortunately, there is no guaranty for the omniscience of such annotators.
Hence, annotators are prone to error, respectively uncertain, so that the class labels assigned to samples may be false.
The labeling performance of an annotator is affected by many factors, e.g. expertise, experience, concentration, level of fatigue and so on.
Moreover, the difficulty of a sample influences the outcome of a labeling process.

To evaluate an active learning strategy in the setting of uncertain annotators, class labels of these uncertain
annotators are required to be available, but there is a lack of publicly accessible real-world data sets labeled by error-prone annotators.
As a result, recently published active learning strategies are evaluated on simulated annotators where the used simulation techniques are diverse.
Our developed *annotlib* Python package represents a of these techniques and implements additional methods, which simulate realistic characteristics of uncertain annotators.
This way, we establish a library simplifying and standardising the evaluation of active learning strategies coping with uncertain annotators.

For more information go to the [documentation](./docs/_build/html/index.html).
pytweets 0.2
PyTweets: Simple Python Twitter API
License: MIT
Requires Python: >=3.4

![alt text][pypi_version] ![alt text][licence_version]

# PyTweets: Python Twitter Api

Tested with:
* Python 3.6+

Use the following command to install using pip:
```
pip install pytweets
```

## Usage example

Use `TwitterApp` class to start a twitter app
```python
from pytweets import TwitterApp

app = TwitterApp(
    api_key='YOUR_API_KEY', 
    api_secret_key='YOUR_API_SECRET_KEY',
    app_name='YOUR_APP_NAME',
    bearer_token='YOUR_BEARER_TOKEN'
)

app.standard_search_tweets(keywords=['twitter', 'app'])  # search tweets which include 'twitter' and 'app'

user_info = app.get_user_by_username(username='jack')  # get user info for Jack Dorsey

app.get_user_statuses_timeline(user_id=user_info.user_id, count=500)   # retrieve latest 500 tweets of user

```

[pypi_version]: https://img.shields.io/pypi/v/pytweets.svg "PYPI version"
[licence_version]: https://img.shields.io/badge/license-MIT%20v2-brightgreen.svg "MIT Licence"
cli-thesaurus 1.0.0b5
A command-line interface thesaurus
License: MIT
Requires Python: >=3
Keywords: cli command-line terminal thesaurus

# Thesaurus

<p align="center">
    <img src="https://github.com/sheatsley/thesaurus/blob/master/demo.gif?raw=true" alt="Thesaurus in action"
</p>

Thesaurus is a ~~simple~~ _elementary_ and ~~fast~~ _expeditious_ CLI for all
of your ~~wordy~~ _pleonastic_ needs. It supports compound words (for example,
"good day") and even supports ~~sepllcheking~~ spellchecking!

### Installation

Thesaurus requires python 3 and can be installed either through
[pip3](https://pip.pypa.io/en/stable/) or [Homebrew](https://brew.sh):

`$ pip3 install cli-thesaurus` or `$ brew install cli-thesaurus`

--- 
This tool was inspired by other ~~discontinued~~ _antediluvian_
works[\[1\]](https://github.com/davidgu/thesaurus-cli)[\[2\]](https://github.com/empireshades/command-line-thesaurus).
read-only-attributes 1.2
Makes read only attributes for a Python class
License: MIT
Keywords: read,only,attributes,property

# Read Only Attributes
[![Build Status](https://travis-ci.org/tek-shinobi/read-only-attributes.svg?branch=master)](https://travis-ci.org/tek-shinobi/read-only-attributes)
[![codecov](https://codecov.io/gh/tek-shinobi/read-only-attributes/branch/master/graph/badge.svg)](https://codecov.io/gh/tek-shinobi/read-only-attributes)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)

Info:
-------------------
This package makes class attributes read only.

Motivation:
--------------------
We can make read only attributes using `@property`. But this can be verbose. __Worse, the intent is not clear as in these attributes are meant to be read-only.__

Like as below

```
    class MyClass:
        @property
        def x(self):
            return 'immutable 1'
        @property
        def y(self):
            return 'immutable 2'
        @property
        def z(self):
            return 'immutable 3'
        @property
        def w(self):
            return 'immutable '

```

The above can be written like so which is much less verbose and lot more explicit:

```
@read_only_attributes('x','y','z','w')
class MyClass:
    def __init__(self, x, y, z, w):
        self.x = x 
        self.y = y 
        self.z = z 
        self.w = w 
```

Once the instance attributes are assigned in the __\__init____, they cannot be changed. Trying to change them will raise an `AttributeError`.

Installation:
--------------
pipenv install read-only-properties

Usage:
------

import class decorator @read_only_attributes and use like so:

```
from roa import read_only_attributes

@read_only_attributes('x', 'y')
class MyClass:
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z
```
That's it. There us no need to use `@property`.  
'x' and 'y' are now readonly attributes. If we try to change them, `AttributeError` exception will be raised.  
Since 'z' is not in decorator argument list, `self.z` is a mutable instance attribute.
waterz 0.9.4
Simple watershed and agglomeration for affinity graphs.
License: MIT

[![Build Status](https://travis-ci.org/jingpengw/waterz.svg?branch=master)](https://travis-ci.org/jingpengw/waterz)
[![PyPI version](https://badge.fury.io/py/waterzed.svg)](https://badge.fury.io/py/waterzed)

<!--
    the coerage is not working on c++ code, so the coverage is 0 now!
    [![Coverage Status](https://coveralls.io/repos/github/jingpengw/waterz/badge.svg?branch=master)](https://coveralls.io/github/jingpengw/waterz?branch=master)
-->

# waterz

Pronounced *water-zed*. A simple watershed and region agglomeration library for
affinity graphs.

Based on the watershed implementation of [Aleksandar Zlateski](https://bitbucket.org/poozh/watershed) and [Chandan Singh](https://github.com/TuragaLab/zwatershed).

# Installation

Install c++ dependencies:
```
sudo apt install libboost-dev
```

Install from pipy
```
pip install waterzed
```

install manually
```
pip install -r requirements.txt
python setup.py install
```

# Usage

```
import waterz
import numpy as np

# affinities is a [3,depth,height,width] numpy array of float32
affinities = ...

thresholds = [0, 100, 200]

segmentations = waterz.agglomerate(affinities, thresholds)
```

# Development
## Release to pypi
We use travis to create release

upgrade the version number in the `setup.py` file, then
```
git commit -a -m "my comments"
git push origin v0.9.5
```
the travis build system will get a `TRAVIS_TAG` variable, and triger the `twine upload` command.
no-manylinux 3.0.0
Install this package to disable manylinux wheels when dowloading from pip.
License: MIT
Requires Python: >=3.6.1

[![Build Status](https://dev.azure.com/asottile/asottile/_apis/build/status/asottile.no-manylinux?branchName=master)](https://dev.azure.com/asottile/asottile/_build/latest?definitionId=48&branchName=master)

no-manylinux
============

Install this package to disable manylinux wheels when downloading from pip.

## Usage

```
# First install no-manylinux
pip install no-manylinux
# Now subsequent invocations of pip will ignore manylinux wheels
pip install ...
# To restore the original behaviour, simply `pip uninstall no-manylinux`
```

## Note

This package was previously called `no-manylinux1` but now addresses the
following manylinux standards:

- `manylinux1`
- `manylinux2010`
- `manylinux2014`

## What? Why?

The manylinux spec requires compliant packages to vendor binary dependencies
inside the wheel that is distributed.  Take for example a library which would
(prior to manylinux) dynamically link against `libssl`.  As `libssl` received
security patches, the system binaries would received updates from the OS's
package manager.  The python library which dynamically links would receive
these updates for free without need to recompile, reinstall, etc.  Under
manylinux, `libssl` is vendored inside the wheel.  To receive security
updates, you have to wait for the upstream to produce a new wheel and need to
know to install a new version of that library.  There's almost no visibility
about these vendored wheels which makes managing them at scale impossible.  As
such, some may choose to ignore this standard.

## Links

- https://stackoverflow.com/q/37231799/812183
- https://github.com/pypa/pip/issues/3689
- https://github.com/pypa/pip/issues/3689#issuecomment-219437150