semvec/pypi-packages huggingface dataset:
common-metrics 0.0.6
Package for commonly used metrics in bio-metrics.
Requires Python: >=3.6

# Biometrics

### Contains most frequently used metrics in the biometrics field.

Please find the implementation on this [repository](https://github.com/Blazkowiz47/biometrics).

Currently supports following metrics:

1. Equal Error Rate (EER)
2. False Reject Rate (FRR)
3. Impostor Attack Presentation Acceptance Rate (IAPAR).

Additionally, it also supports threshold calculation.
graffito 0.0.1
A function-tagging library using decorators as tags.

# Graffito

> Speak softly, but carry a big can of paint.
>
> _Banksy_

## Installtion

Find this tool on`PyPI`: `pip install graffito`

## Usage

Given a program:
```python
from graffito.tags import graffiti, get_tags

func_test = graffiti

@func_test
def test():
    pass

class TestClass:

    method_test = graffiti

    @method_test
    def class_test(self):
        pass

print(get_tags(TestClass))
print(get_tags(test))
```
Executing the program will return:
```bash
{'class_test': ['method_test']}
{'test': ['func_test']}
```
This is a bespoke module. However, let's say that we wanted to characterize functions of a certain
signature with a decorator so that we could handle them the same way. Let's say:
```python
from graffito.tags import graffiti, get_tags

class TestClass:

    two_var_sig = graffiti

    @two_var_sig
    def function_a(self, input_a, input_b):
        print(f"{input_a}, {input_b}")

    @two_var_sig
    def function_b(self, input_a, input_b):
        print(f"{input_b}, {input_a}")

    def function_not_like_them(self, input_a):
        print(f"SIKE!")

t = TestClass()
tags = get_tags(TestClass)
for tag in tags:
    if "two_var_sig" in tags[tag]:
        getattr(t, tag)(1,2)
```
I know it seems really arbitrary, but it helped me write a simple computer emulator and I think I 
can develop it to be useful outside of my silly context. Let's find out.
subsnitch 0.0.1
Python Boilerplate contains all the boilerplate you need to create a Python package.
Requires Python: <3.12.0,>=3.8.0

# subsnitch
subsnitch is a program I made for stitching coverart,audio,subtitles into a video format. Feel free to use this to add subtitles to any audio work or for translation purposes.

# Installation
I highly recommend you use `pipx` to install this, as it creates the virtualenv for you and seamlessly handles the loading of the virtual environment when running this tool. If you choose not to use `pipx`, you should create a virtualenv and possibly a wrapper script to launch this in the virtualenv.

```sh
pipx install subsnitch
```

# Usage

When executed without arguments, the program should scan the current working directory for [mp3, wav] files and then process them
    Look for {basename}.vtt, {basename}.{ext}.vtt                                                   assert failure
    Look for {basename}.[png,jpeg,jpg,webp], {basename}.{ext}.[png,jpeg,jpg,webp], cover.[png,jpeg,jpg]       assert failure
Alternatively the program may take arguments to alter how it functions

The following is the help for the program
```
usage: __main__.py [-h] [-V] [-v]

burning subtitles/covers on audio tracks to produce video files

options:
  -h, --help     show this help message and exit
  -V, --version  show program's version number and exit
  -v, --verbose
```

# Examples

```sh
No content
```

# Credits

This package was created with [Cookiecutter](https://github.com/cookiecutter/cookiecutter) and the [tbennett6421/pythoncookie](https://github.com/tbennett6421/pythoncookie) project template.
remote-config-fetcher 0.1.1
A package to fetch Firebase RemoteConfig values
Requires Python: >=3.6

# Remote Config Fetcher

A package to fetch Firebase RemoteConfig values.

## Installation

```bash
pip install remote_config_fetcher
```

## Usage

```python
from remote_config_fetcher import RemoteConfigFetcher

config_fetcher = RemoteConfigFetcher('path/to/your/serviceAccountKey.json')
values = config_fetcher.get_remote_config_values()
print(values)
```
segmented-docstring 0.4.33
Split and Combine python bare code and docstrings
Requires Python: >=3.7

# 🐍✂️ Segmented Docstring: Split Your Python, Not Your Hairs!

[![PyPI version](https://badge.fury.io/py/segmented-docstring.svg)](https://badge.fury.io/py/segmented-docstring)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Python Versions](https://img.shields.io/pypi/pyversions/segmented-docstring.svg)](https://pypi.org/project/segmented-docstring/)

Ever felt like your Python files were getting too chunky? Tired of scrolling through endless docstrings to find that one line of code? Say hello to Segmented Docstring, the tool that lets you have your cake and eat it too!

## 🎭 What's This Sorcery?

Segmented Docstring is a magical Python tool that:

1. 🔪 Slices your Python files into two delicious pieces: bare code and docstrings
2. 🧙‍♂️ Conjures them back together whenever you need
3. 🎩 Does it all with style and panache!

## 🚀 Quick Start

```bash
pip install segmented-docstring
```

Now you're ready to split some Python!

```bash
segmented-docstring split your_chunky_file.py
```

Voila! You now have `your_chunky_file.barecode.py` and `your_chunky_file.docstring.py`.

Missing those docstrings? No problem!

```bash
segmented-docstring combine your_directory
```

And just like that, your files are whole again. It's like magic, but real!

## 🎨 Features

- **Split with Precision**: Separate your code and docstrings faster than a ninja chopping vegetables.
- **Combine with Elegance**: Merge your files back together smoother than a well-aged whiskey.
- **CLI that Speaks Your Language**: Our command-line interface is so friendly, it might ask you out for coffee.
- **Configurable**: Tweak it, tune it, make it sing your favorite song.

## 🛠 Installation

```bash
pip install segmented-docstring
```

Or if you're feeling adventurous:

```bash
git clone https://github.com/robin-collins/segmented_docstring.git
cd segmented_docstring
pip install -e .
```

## 📚 Documentation

For those who love to read (we know you're out there!), check out our [full documentation](https://robin-collins.github.io/segmented_docstring/).

## 🤝 Contributing

Found a bug? Want to add a feature that turns code into haiku? We're all ears! Check out our [contributing guidelines](CONTRIBUTING.md) and join the fun!

## 📜 License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details. It's so permissive, you could probably use it to open a lemonade stand.

## 🎉 Acknowledgments

- Coffee ☕, for making this project possible
- Python 🐍, for being awesome
- You 👉, for reading this far!

Remember, with great power comes great responsibility. Use Segmented Docstring wisely, and may your code always be clean and your docstrings always informative!
latestearthquake-indonesia-rpelin 0.0.3
This package will detect the latest earthquakes from BMKG Indonesia
Requires Python: >=3.8

# latest-indonesian-earthquake
This package will detect the latest earthquakes from BMKG Indonesia

## HOW IT WORK ?
This package will scrape from [BMKG](https://www.bmkg.go.id)

This package will use BeautifulSoup4 and Request, which generates json ready to use in web and mobile applications.

## HOW TO USE
'''
import gempaterkini

if __name__ == '__main__':
    results = gempaterkini.ekstraksi_data()
    gempaterkini.tampilkan_data(results)
'''

## Author
Ruri Pelinandang
nmwifi 0.0.3
Python API (and CLI) to configure a Wi-Fi device through NetworkManager using a fallback Access Point.
Requires Python: <4.0,>=3.10
Keywords: network-manager, networking, wifi, ap, api

# nmwifi

The [Python](https://www.python.org) package `nmwifi` provides an API (and a CLI) to configure a Wi-Fi device through [NetworkManager](https://networkmanager.dev/) using a fallback Access Point.

Python Package `nmwifi` (managed using [Poetry](https://python-poetry.org/))

**Note**: please take a look at the project's GitHub repository **<https://github.com/gruvw/nmwifi>** for more information.

Install by running: `pip install nmwifi`.
torch-genai 0.0.1.dev1
GenAI
Requires Python: >=3.10

# GAN Framework


## Generator

Generator must have:

```python
    def forward(self, x, return_q=True):
        """x - images [NCHW]
        return_q - if True, return `r` (recons images [NCHW]),
        and optional `vqres` (quantized info)
        """
        ...
        return r, vqres if return_q else r
```

VQRes has definition:
```python
VQRes = namedtuple('VQRes', [
    'quantized',
    'indices',
    'entro_mean',
    'mean_entro',
    'entro_loss',
    'commit_loss',
    'cdbook_loss'
])
```

## Discriminator
nuance 0.8.1
Transit signals detection among correlated noises
Requires Python: >=3.9
Keywords: astronomy, exoplanets, jax, transit

# nuance
Efficient detection of planets transiting quiet or active stars

<p align="center">
    <img src="docs/_static/illu_readme.png" height="350" style="margin:50px">
</p>

*nuance* uses linear models and Gaussian processes (using the [JAX](https://github.com/google/jax)-based [tinygp](https://github.com/dfm/tinygp)) to simultaneously **search for planetary transits while modeling correlated noises** (e.g. stellar variability) in a tractable way. See [the paper](https://arxiv.org/abs/2402.06835) for more details.

When to use *nuance*?
- To detect single or periodic transits
- When correlated noises are present in the data (e.g. stellar variability or instrumental systematics)
- For space-based or sparse ground-based observations
- To effectively find transits in light curves from multiple instruments
- To use GPUs for fast transit searches

Documentation at [nuance.readthedocs.io](https://nuance.readthedocs.io)

## Example

```python
import numpy as np
from nuance import linear_search, periodic_search, core

# linear search
epochs = time.copy()
durations = np.linspace(0.01, 0.2, 15)
ls = linear_search(time, flux, gp=gp)(epochs, durations)

# periodic search
periods = np.linspace(0.3, 5, 2000)
snr_function = jax.jit(core.snr(time, flux, gp=gp))
ps_function = periodic_search(epochs, durations, ls, snr_function)
snr, params = ps_function(periods)

t0, D, P = params[np.argmax(snr)]
```

## Installation

`nuance` is written for python 3 and can be installed using pip

```shell
pip install nuance
```

or from sources
  
```shell
git clone https://github.com/lgrcia/nuance
cd nuance
pip install -e .
```

## Citation

If you find *nuance* useful for your research, cite [Garcia et. al 2024](https://ui.adsabs.harvard.edu/abs/2024AJ....167..284G). The BibTeX entry for the paper is:

```
@ARTICLE{2024AJ....167..284G,
       author = {{Garcia}, Lionel J. and {Foreman-Mackey}, Daniel and {Murray}, Catriona A. and {Aigrain}, Suzanne and {Feliz}, Dax L. and {Pozuelos}, Francisco J.},
        title = "{nuance: Efficient Detection of Planets Transiting Active Stars}",
      journal = {\aj},
     keywords = {Exoplanet detection methods, Stellar activity, Time series analysis, Gaussian Processes regression, Computational methods, GPU computing, 489, 1580, 1916, 1930, 1965, 1969, Astrophysics - Earth and Planetary Astrophysics, Astrophysics - Instrumentation and Methods for Astrophysics},
         year = 2024,
        month = jun,
       volume = {167},
       number = {6},
          eid = {284},
        pages = {284},
          doi = {10.3847/1538-3881/ad3cd6},
archivePrefix = {arXiv},
       eprint = {2402.06835},
 primaryClass = {astro-ph.EP},
       adsurl = {https://ui.adsabs.harvard.edu/abs/2024AJ....167..284G},
      adsnote = {Provided by the SAO/NASA Astrophysics Data System}
}
```
fastapi-translation 0.0.1
Translations report for FastAPI docs
Requires Python: >=3.12

# FastAPI Translations Management

Easy management for translations of the [FastAPI](https://github.com/fastapi/fastapi) project documentation.

✨ Inspired by the this [pull request](https://github.com/fastapi/fastapi/pull/11864) from [@lucasbalieiro](https://github.com/lucasbalieiro).

## 🙋🏾‍♀️ Who's this library for?

This is a very specific package, intended for contributors of [FastAPI](https://github.com/fastapi/fastapi) translations.

If you don't work with us, feel free to look around, but I don't think you'll be able to use it anywhere else

## Instalation

## 💽 Installation

Install using `pip install -U fastapi-translations`.

## ⌨️ Usage

After installing fastapi-translations, you'll be able to use it anywhere via the `fastapi_translations` command.

You can see all options with `fastapi_translations --help`:

![help](docs/img/help.png)

A basic usage is: `fastapi_translations -l pt -c`.

It will scan all english docs in FastAPI project, check which documents have translations into the language informed, and which documents, despite having a translation, are out of date.

You'll need to wait a little bit while it is analyzing all docs:

![processing](docs/img/processing.jpg)

And when it is done, you'll see a brief summary:

![summary](docs/img/summary.jpg)

And a `csv` file will be saved: `fastapi-translations-lang-{chosen-language}.csv` with all files, dates, etc. 🤗
khnlp 0.0.3
Khmer NLP Toolkits
Requires Python: >=3.6
Keywords: , , 

## khnlp: Khmer NLP Toolkits

khnlp is a library for **advanced Khmer Natural Language Processing** in Python. 
It is developed by a research team of Cambodia Academy of Digital Technology ([CADT](http://cadt.edu.kh/)) since mid 2021, which is built on the very latest research, and was designed from day one to be used in real products.
 
### Features
* [Word Segmentation](https://github.com/IDRI-LAB/Khmer-NLP-Tools/tree/main/khnlp/khnlp/segment) is the process of dividing a string of written language into its component words.
Example: "សួស្តីអ្នកទាំងអស់គ្នា" => "សួស្តី | អ្នក | ទាំងអស់ | គ្នា"
* [Name Romanization](https://github.com/IDRI-LAB/Khmer-NLP-Tools/tree/main/khnlp/khnlp/romanize) is the process of converting Khmer script into the Roman (Latin) alphabet.
Example:  "សួស្តី" => "suo sdei"

### Installation
System requirements:
* Operation system: macOs / OSX, Linux, Windows
* Python version: 3.6+
* Package managers: pip

**pip**

`pip install khnlp==0.0.3`

### Inferences
* [Word Segmentation](https://github.com/IDRI-LAB/Khmer-NLP-Tools/tree/main/khnlp/inference/segment)
* [Name Romanization](https://github.com/IDRI-LAB/Khmer-NLP-Tools/tree/main/khnlp/inference/romanize)

### Contributors
* [Vichet Chea]
* [Sotheara Leang](mailto:leangsotheara@gmail.com)
ScarxApiClient 0.0.2
Client for Scarx API

# ScarxApi Python Client

Example Usage:

```
import asyncio
from ScarxApi import ScarxApi


async def main():
    with ScarxApi("Test-Client", "ApiToken") as api:
        response = await api.IpServiceV1.get_ip(ip="1.1.1.1")
    print(response)


if __name__ == "__main__":
    loop = asyncio.new_event_loop()
    loop.run_until_complete(main())

```