semvec/pypi-packages huggingface dataset:
tensorflow-nearest-neighbours 0.0.1.dev1
Nearest neighbours word embedding computation.
Requires Python: >=3.8
Keywords: tensorflow,custom op

# TensorFlow Nearest Neighbours Op
Given an embedding matrix `EM`, and batch of word embeddings `x` 
find nearest embedding for each token `x_ij` in `EM`.

```python
import tensorflow as tf
from tensorflow_nearest_neighbours import nearest_neighbours
tf.debugging.set_log_device_placement(True)

x = tf.random.uniform(shape=[8, 10, 32])
EM = tf.random.uniform(shape=[500, 32])
result = nearest_neighbours(x, EM)
print(result.shape)
```

#### Instalation
```shell
pip install tensorflow_nearest_neighbours
```
kutoa 2023.6.21
Weave (Finnish: kutoa) annotated json code examples with fill-ins from and to markdown prose.
Requires Python: >=3.9
Keywords: developer-tools,devops

# Kutoa

Weave (Finnish: kutoa) annotated json code examples with fill-ins from and to markdown prose.

[License: MIT](https://git.sr.ht/~sthagen/kutoa/tree/default/item/LICENSE)

Third party dependencies are documented in the folder [third-party](docs/third-party/README.md).

<!--
[![version](https://img.shields.io/pypi/v/kutoa.svg?style=flat)](https://pypi.python.org/pypi/kutoa/)
[![downloads](https://pepy.tech/badge/kutoa/month)](https://pepy.tech/project/kutoa)
[![wheel](https://img.shields.io/pypi/wheel/kutoa.svg?style=flat)](https://pypi.python.org/pypi/kutoa/)
[![supported-versions](https://img.shields.io/pypi/pyversions/kutoa.svg?style=flat)](https://pypi.python.org/pypi/kutoa/)
[![supported-implementations](https://img.shields.io/pypi/implementation/kutoa.svg?style=flat)](https://pypi.python.org/pypi/kutoa/)
-->

## Documentation

User and developer [documentation of vastaanottaa](https://codes.dilettant.life/docs/kutoa).

## Bug Tracker

Any feature requests or bug reports shall go to the [todos of kutoa](https://todo.sr.ht/~sthagen/kutoa).

## Primary Source repository

The main source of `kutoa` is on a mountain in central Switzerland.
We use distributed version control (git).
There is no central hub.
Every clone can become a new source for the benefit of all.
The preferred public clones of `kutoa` are:

* [on codeberg](https://codeberg.org/sthagen/kutoa) - a democratic community-driven, non-profit software development platform operated by Codeberg e.V.
* [at sourcehut](https://git.sr.ht/~sthagen/kutoa) - a collection of tools useful for software development.

## Contributions

Please do not submit "pull requests" (I found no way to disable that "feature" on GitHub).
If you like to share small changes under the repositories license please kindly do so by sending a patchset.
You can either send such a patchset per email using [git send-email](https://git-send-email.io) or
if you are a sourcehut user by selecting "Prepare a patchset" on the summary page of your fork at [sourcehut](https://git.sr.ht/).

# Status

Experimental.

**Note** The default branch is `default`.
espeak-phonemizer 1.3.1
Lightweight International Phonetic Alphabet (IPA) phonemizer that uses libespeak-ng

# eSpeak Phonemizer

Uses [ctypes](https://docs.python.org/3/library/ctypes.html) and [libespeak-ng](https://github.com/espeak-ng/espeak-ng/blob/master/docs/integration.md) to transform text into [IPA](https://en.wikipedia.org/wiki/International_Phonetic_Alphabet) phonemes.

## Installation

First, install libespeak-ng:

```sh
sudo apt-get install libespeak-ng1
```

Next, install espeak_phonemizer:

```sh
pip install espeak_phonemizer
```

If installation was successful, you should be able to run:

```sh
espeak-phonemizer --version
```

## Basic Phonemization

Simply pass your text into the standard input of `espeak-phonemizer`:

```sh
echo 'This is a test.' | espeak-phonemizer -v en-us
ðɪs ɪz ɐ tˈɛst
```

### Separators

Phoneme and word separators can be changed:

```sh
echo 'This is a test.' | espeak-phonemizer -v en-us -p '_' -w '#'
ð_ɪ_s#ɪ_z#ɐ#t_ˈɛ_s_t
```

### Punctuation and Stress

Some punctuation can be kept (.,;:!?) in the output:

```sh
echo 'This: is, a, test.' | espeak-phonemizer -v en-us --keep-punctuation
ðˈɪs: ˈɪz, ˈeɪ, tˈɛst.
```

Stress markers can also be dropped:

```sh
echo 'This is a test.' | espeak-phonemizer -v en-us --no-stress
ðɪs ɪz ɐ tɛst
```

### Delimited Input

The `--csv` flag enables delimited input with fields separated by a '|' (change with `--csv-delimiter`):

```sh
echo 's1|This is a test.' | espeak-phonemizer -v en-us --csv
s1|This is a test.|ðɪs ɪz ɐ tˈɛst
```

Phonemes are added as a final column, allowing you to pass arbitrary metadata through to the output.

### Parallelize with GNU Parallel

```sh
parallel -a /path/to/input.csv --pipepart \
    espeak-phonemizer -v en-us --csv \
    > /path/to/output.csv
```
eds-api-client 0.0.1
API client for Chicago Economic Disclosure Statements (EDS)
Requires Python: >=3.7

# Electronic Disclosure Statement (EDS) API Client

This driver allows other projects to interact with the City of Chicago's EDS system.

## Setup

### Dependencies

* [`lxml`](https://lxml.de/)
* [`scrapelib`](https://jamesturk.github.io/scrapelib/)

### Installation

`eds-api-client` is installable via pip.

## Usage
This driver provides three endpoints. In order to succesfully instantiate the `EDSAPIClient` class, provide values for `client_id`, `client_secret`, and `domain`. If no `domain` is provided, the default value is `https://apiqa.chicago.gov`

This driver provides three main functions:
1. Register a user

```
new_user_response = api_client.register_user(registration_data,
                                             app_username=client_username,
                                             app_password=client_password)
```

2. Log in a user
```
response = api_client._get_access_token(client_username, client_password)
```

3. Submit an EDS
```
response = api_client.submit_eds(submission_data, client_username, client_password)
```

## Development

Clone this repository, create a virtual environment, then install the package and test requirements.

```bash
git clone https://github.com/datamade/eds-api-client.git
python3 -m venv ~/.virtualenvs/python-eds-client
source ~/.virtualends/python-eds-client
pip install -e .
pip install -r test_requirements.txt
```

To run the tests:

```bash
pytest -sv
```

## Copyright and attribution

Copyright (c) 2023 DataMade. Released under the [MIT License](https://github.com/datamade/eds-api-client/blob/main/LICENSE).
sphinx-tags-fork 0.2.0
Sphinx extension to create tags for documentation pages.
Keywords: documentation,sphinx

# sphinx-tags [![sphinx-tags](https://circleci.com/gh/melissawm/sphinx-tags.svg?style=svg)](https://circleci.com/gh/melissawm/sphinx-tags)

A tiny Sphinx extension that implements blog-style tags for documentation.

**🗣 If you use this extension in your project, please drop us a note [in this discussion post](https://github.com/melissawm/sphinx-tags/discussions/32)**

## Installation

After activating a virtual environment manager such as `venv` or `conda`, use

```
python -m pip install sphinx-tags
```
or

```
conda install sphinx-tags -c conda-forge
```

## Usage

Refer to the [documentation](https://sphinx-tags.readthedocs.io/en/latest/) for usage instructions.

## Contributing

Feel free to submit issues or PRs - keep in mind this project is experimental!

### Setup for development

After cloning this repo and activating a virtual environment manager such as
`venv` or `conda`, use

```
python -m pip install -e ".[sphinx]"
```

To build the documentation locally, use

```
sphinx-build docs docs/_build/html
```

`sphinx-tags` uses [pre-commit](https://pre-commit.com/), and code is formatted
according to [black](https://github.com/psf/black)

### Contribution guide

If you want to submit Pull requests to this repository, please follow the [contribution guidelines](https://sphinx-tags.readthedocs.io/en/latest/dev/index.html).

## Code of Conduct

All contributors and maintainers are expected to follow the
[PSF Code of Conduct](https://github.com/psf/community-code-of-conduct).

## Notes

This project is loosely based on [this StackOverflow answer](https://stackoverflow.com/questions/18146107/how-to-add-blog-style-tags-in-restructuredtext-with-sphinx).
notctyparser 23.6.21
Just ctyparser with added version check.
Requires Python: >=3.9

# notctyparser

notctyparser is a fork and extension of [ctyparser](https://github.com/miaowware/ctyparser).

I've probably screwed something up. Use the original.

A CTY.DAT parser for modern amateur radio programs.

[![PyPI](https://img.shields.io/pypi/v/notctyparser)](https://pypi.org/project/notctyparser/) ![PyPI - Python Version](https://img.shields.io/pypi/pyversions/notctyparser) ![PyPI - License](https://img.shields.io/pypi/l/notctyparser)

## Installation

`notctyparser` requires Python 3.6 at minimum.

```none
pip install notctyparser
```

## Fork

I just added a stupid check for update without doing the update.

```python
def check_update(self) -> bool:
```

- Changed locale to en_US.utf8
- Used xpath to parse the download link.
- Chose more narrow raised exceptions.
- Specified utf-8 file encoding.
- Made the linter happy.

## Copyright

Copyright 2019-2022 classabbyamp, 0x5c  
Released under the MIT License.  
See `LICENSE` for the full license text.
nqgreenapi 1.0.0a4
NQ GreenApi Provider
Requires Python: >=3.10,<4.0

# NQ GreenApi Provider

Part of NQ suite by [Inqana](https://inqana.com). Built with [NQ SDK](https://pypi.org/project/nqsdk/).

## Tests

Run tests locally:

```bash
$ ./scripts/tests
```

## License

Licensed under the terms of the [Apache License, version 2.0](https://apache.org/licenses/LICENSE-2.0). See `LICENSE` file.

Copyright (c) 2023 Inqana Ltd.
django-peppered-passwords 0.0.4
Django hashed passwords with pepper
Requires Python: >=3.7

# Django peppered passwords

Adds a secret private key to the hashed passwords created with django.contrib.auth.

## Configuration

Define a secret in your project's settings.

    PEPPERED_PASSWORDS_SECRET_KEY = 'b04ab0b2d1e69cfa54f49f348c3388c2e6017cae6c5aefa4'

Do not use the secret key in example. Create your own.

Create a secret key by using python's builtin secret module.

    >>> import secrets
    >>> secrets.token_bytes(32).hex()

Add the hasher `PASSWORD_HASHERS` in your projects settings file. `PASSWORD_HASHERS` comes from Django.

    PASSWORD_HASHERS = [
      "django_peppered_passwords.hashers.PepperedPBKDF2PasswordHasher"
    ]

Please take it to the consideration, this is an irreversible action. Switching from peppered hashing to Django's default hasher is not possible.

Once you update the secret key, all the passwords will be broken. The users will need to reset their passwords via email.

## Background

Currently a user's password stored in database in this format:

     <algorithm>$<iterations>$<salt>$<hash>

Hash (Last column) is the password hashed with the salt in previous column. Example, these are two computed passwords, stored on database, for the same password of two users.

    pbkdf2_sha256$600000$fb9cUsHWK4EMZ7VWGBAcGD$2uwiVefFwanIhxLrv+/t3sKvP4X6tDKEMw/ysHD5dIc=
    pbkdf2_sha256$600000$HgWHWrF2qQD9Owj4XeEkjY$rh0qzfo+/ZCzWbL9ZJa8aKhiO5xoEMfT4EtP/+A+LzI=

The password is 123456. Imagine I am an attacker, who got the database of different django project, I want to look up the users who have chosen the password 123456. I have the salts of users stored in database.

    >>> make_password('123456', 'fb9cUsHWK4EMZ7VWGBAcGD')
    pbkdf2_sha256$600000$fb9cUsHWK4EMZ7VWGBAcGD$2uwiVefFwanIhxLrv+/t3sKvP4X6tDKEMw/ysHD5dIc=
    >>> make_password('123456', 'HgWHWrF2qQD9Owj4XeEkjY')
    pbkdf2_sha256$600000$HgWHWrF2qQD9Owj4XeEkjY$rh0qzfo+/ZCzWbL9ZJa8aKhiO5xoEMfT4EtP/+A+LzI=

These are correct password combinations. I am able to lookup the users who have their passwords exposed in public. Password 123456 is not a possible case in Django, since the password fields have a complexity validation. However, the salt is available to the attacker when a database is stolen. Salt could be used

- To hash the raw password pair in a rainbow table.
- To hash the already exposed passwords.

There is one more element needed for hashing the password, pepper, should be project specific. When a database is exposed in public, the attacker will not be able to lookup the passwords, since they don't have the secret pepper key.

## Notes from Django ticket 30561

According to NIST Digital Identity Guidelines Authentication and Lifecycle Management document, verifiers should perform an additional iteration of a key derivation function using a salt value that is secret and known only to the verifier.

- <https://code.djangoproject.com/ticket/30561>
- <https://pages.nist.gov/800-63-3/sp800-63b.html>
pyElevenlabs 0.0.3
Python wrapper for the ElevenLabs API
Requires Python: >=3.6

# Python wrapper for Elevenlabs API

This is a python wrapper for the Elevenlabs API ([LINK](https://beta.elevenlabs.io/))

Currently only supports calling the text-to-speech endpoint.
Needs a api_key and voice_id to work. Api Key is available in your Profile. Voice Id is available [here](https://api.elevenlabs.io/v1/voices).

---

This package and repository is no way affiliated with Elevenlabs. Please ssend all support requests related to this python package to this Issue Tracker: [Issues](https://github.com/philiplawall/pyElevenlabs/issues)