semvec/pypi-packages huggingface dataset:
moveread-core 0.4.3
Core Moveread Dataset
Requires Python: >=3.10

# Moveread Core Dataset

### CLI

#### Exporting

**Important**
- Exporting `boxes` will yield one box per PGN move.
- To export the labeled boxes, use `core export ocr` instead 

```bash
core export pgn -v --glob 'path/to/core' > sans.txt
core export labels -v --glob 'path/to/cores/*' > labels.txt
core export boxes -vg 'path/**/*' --recursive -o path/to/files-dataset
core export ocr -vgr '**' -o path/to/ocr-dataset
```

#### Nonlocal Core
  
```bash
core --meta 'azure+cosmos://<CONN_STR>?db=games&container=games' --blobs 'azure+blob://...' export # [...]
core --env export # [...] Loads CORE_META and CORE_BLOBS from .env file
core -e export --prefix tournament/ export labels # exports from tournament only
core -e export -p tournament/group/1 # exports from tournament/group/1 only
```

Or you can dump to local first:

```bash
core -e dump --prefix tournament -o local-tournament
```
alchemizer 0.1.1
Meta-framework to facilitate development of frameworks using identity map and unit of work patterns
Requires Python: <4.0,>=3.12

# Alchemizer

A meta-framework to facilitate development of frameworks using identity map and unit of work patterns.

The name is a nod to [SQLAlchemy](https://github.com/sqlalchemy/sqlalchemy) and [RuneScape](https://runescape.wiki/w/Alchemiser).
dynalite-pdeg 0.0.2
An API for the Dynalite PDEG, using telnet
Requires Python: >=3.11

# Dynalite PDEG API

This module aims to provide an API to access the dynalite ethernet gateway (PDEG) through its telnet communication capabilities.
A backup CGI function is provided but its usage is not recommended and it may be removed in future versions

Requires asyncio and telnetlib3.

For documentation of the API, see [The dynalite docs](https://docs.dynalite.com/system-builder/latest/ethernet_gateways/integration/dynet_text.html#_telnet_access)
loki-urllib3-client 0.2.2
A simple loki client using urllib3
Requires Python: >3.7

# loki-urllib3-client

A simple Python Loki client using urllib3

This is a modified version of [loki-client](https://github.com/hack-han/loki-client)

# Quickstart

## Install : 
```bash
pip3 install loki-urllib3-client
```

## Usage
```python
from loki_urllib3_client import LokiClient

loki_url = 'http://localhost:3100'
loki_client = LokiClient(url=loki_url)

# test ready()
loki_ready = loki_client.ready()
if not loki_ready:
    print('Loki is not ready.')
    exit(1)

# test labels()
result = loki_client.labels()
print(result)

# test post()
label_dic = {'host': 'windows', 'env': 'test'}
logs_lst = ['This is line 1', 'This is line 2', 'This is line 3', 'This is line 4']
result = loki_client.post(label_dic, logs_lst)
if not result[0]:
    print(result[1])

# test query_range()
query = r'{host="ubuntu"}|~"error"'
result = loki_client.query_range(query, direction=LokiClient.Direction.backward, limit=10)
print(result)

if result[0]:
    print(result[1]['status'])
    print(result[1]['data']['resultType'])

# test query()
result = loki_client.query(query, direction=LokiClient.Direction.backward, limit=10)
print(result)
```
hl7lw 0.1.2
Super light weight Hl7 2.x parser
Requires Python: >=3.8

# hl7lw: A Lightweight HL7 2.x Parsing Library

[![pypi](https://img.shields.io/pypi/v/hl7lw)](https://pypi.org/project/hl7lw/)
[![Test-Status](https://github.com/acv/hl7lw/actions/workflows/python-app.yml/badge.svg?branch=main)](https://github.com/acv/hl7lw/actions/workflows/python-app.yml)

The hl7lw library aims to provide an extremely simple and lightweight
API to read, modify, and write HL7 2.x messages. Minimal processing is
done to the messages and most data access should feel very natural and
pythonic.

The library also includes an MLLP implementation for both client and
server.

All objects have docstrings.

```Python
import hl7lw

p = hl7lw.Hl7Parser()
m = p.parse_message(message_bytes)

if m["MSH-9.1"] == "ORU":
    m["ORC-1"] = "RP"

message_bytes = p.format_message(m)

report = "\n".join([obx[5] for obx in m.get_segments('OBX') if obx[2] in ('TX', 'FT', 'ST')])

c = hl7lw.MllpClient()
c.connect(host="127.0.0.1", port="1234")
c.send(message_bytes)
ack_bytes = c.recv()
c.close()

ack_m = p.parse_message(ack_bytes)
assert ack_m["MSA-1.1"] == "AA"
assert m["MSH-10"] == ack_m["MSA-2"]

```
perplexity-gradio 0.0.1
A Python package for creating Gradio applications with Perplexity models
Requires Python: >=3.10

# `perplexity-gradio`

is a Python package that makes it very easy for developers to create machine learning apps that are powered by Perplexity's API.

# Installation

You can install `perplexity-gradio` directly using pip:

```bash
pip install perplexity-gradio
```

That's it! 

# Basic Usage

You should first save your Perplexity API key to this environment variable:

```bash
export PERPLEXITY_API_KEY=<your token>
```

Then in a Python file, write:

```python
import gradio as gr
import perplexity_gradio

gr.load(
    name='llama-3.1-sonar-large-128k-online',
    src=perplexity_gradio.registry,
).launch()
```

Run the Python file, and you should see a Gradio Interface connected to the model on Perplexity!

![ChatInterface](chatinterface.png)

# Customization 

Once you can create a Gradio UI from an OpenAI endpoint, you can customize it by setting your own input and output components, or any other arguments to `gr.Interface`. For example, the screenshot below was generated with:

```py
import gradio as gr
import perplexity_gradio

gr.load(
    name='llama-3.1-sonar-large-128k-online',
    src=perplexity_gradio.registry,
    title='Perplexity-Gradio Integration',
    description="Chat with llama-3.1-sonar-large-128k-online model.",
    examples=["Explain quantum gravity to a 5-year old.", "How many R are there in the word Strawberry?"]
).launch()
```
![ChatInterface with customizations](perplexity-gradio-custom.png)

# Composition

Or use your loaded Interface within larger Gradio Web UIs, e.g.

```python
import gradio as gr
import perplexity_gradio

with gr.Blocks() as demo:
    with gr.Tab("llama-3.1-sonar-large-128k-online"):
        gr.load('llama-3.1-sonar-large-128k-online', src=perplexity_gradio.registry)
    with gr.Tab("llama-3.1-sonar-small-128k-online"):
        gr.load('llama-3.1-sonar-small-128k-online', src=perplexity_gradio.registry)

demo.launch()
```

# Under the Hood

The `perplexity-gradio` Python library has two dependencies: `openai` and `gradio`. It defines a "registry" function `perplexity_gradio.registry`, which takes in a model name and returns a Gradio app.

# Supported Models

For a comprehensive list of available models and their specifications, please refer to the [Perplexity Model Cards documentation](https://docs.perplexity.ai/guides/model-cards).


Note: The Online LLMs' search subsystem does not attend to the system prompt. The system prompt can be used to provide instructions related to style, tone, and language of the response.

Note: if you are getting a 401 authentication error, then the OpenAI API Client is not able to get the API token from the environment variable. This happened to me as well, in which case save it in your Python session, like this:

```py
import os

os.environ["PERPLEXITY_API_KEY"] = ...
```
chess_features 0.5.0
Transform chess positions to various encodings
Keywords: chess, encoding, features

# Chess Features

This Python package provides a convenient way to convert chess board representations from the Python Chess library into formats suitable for machine learning algorithms. It offers various representations that can be directly utilized as input for machine learning tasks.

## Features

- Convert Python Chess board representations into machine learning-friendly formats.
- Supports several common representations used in machine learning tasks.
- Easy-to-use interface for seamless integration into your projects.

## Installation

You can install the package using pip:

```bash
pip install chess_features
```

## Usage

Here's a basic example demonstrating how to use the package:

```python
from chess import Board
from chess_features import ChessFeatures

# Create a Chess board using the Python Chess library
board = Board()

# Initialize the ChessFeatures
converter = ChessFeatures()

# Convert the board representation into a machine learning-friendly format
# Example: Convert to a feature vector
feature_vector = converter.to_stockfish_feature_vector(board)

# Example: Convert to a bitmap
bitmap = converter.to_bitmap(board)

```

## Available Representations

- Feature Vector: A flattened vector representation of the board.
- Bitmap: A bitmap representation of the board.

## Acknowledgements

- This package utilizes the [Python Chess library](https://python-chess.readthedocs.io/en/latest/).
- The information for Stockfish features are taken from [Stockfish Evaluation Guide](https://hxim.github.io/Stockfish-Evaluation-Guide/).

## ChatGPT

Apart from this readme no ChatGPT was used.
egor-kashpar-16 0.0.3
A short description of the project.
Requires Python: ~=3.11

# egor-kashpar-16

<a target="_blank" href="https://cookiecutter-data-science.drivendata.org/">
    <img src="https://img.shields.io/badge/CCDS-Project%20template-328F97?logo=cookiecutter" />
</a>

A short description of the project.

## Project Organization

```
├── LICENSE            <- Open-source license if one is chosen
├── Makefile           <- Makefile with convenience commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default mkdocs project; see www.mkdocs.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── pyproject.toml     <- Project configuration file with package metadata for 
│                         egor_kashpar_16 and configuration for tools like black
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.cfg          <- Configuration file for flake8
│
└── egor_kashpar_16   <- Source code for use in this project.
    │
    ├── __init__.py             <- Makes egor_kashpar_16 a Python module
    │
    ├── config.py               <- Store useful variables and configuration
    │
    ├── dataset.py              <- Scripts to download or generate data
    │
    ├── features.py             <- Code to create features for modeling
    │
    ├── modeling                
    │   ├── __init__.py 
    │   ├── predict.py          <- Code to run model inference with trained models          
    │   └── train.py            <- Code to train models
    │
    └── plots.py                <- Code to create visualizations
```

--------
misiss-mlops 0.1.3
A short description of the project.
Requires Python: ~=3.10

# mlops

<a target="_blank" href="https://cookiecutter-data-science.drivendata.org/">
    <img src="https://img.shields.io/badge/CCDS-Project%20template-328F97?logo=cookiecutter" />
</a>

A short description of the project.

## Project Organization

```
├── LICENSE            <- Open-source license if one is chosen
├── Makefile           <- Makefile with convenience commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default mkdocs project; see www.mkdocs.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── pyproject.toml     <- Project configuration file with package metadata for 
│                         mlops and configuration for tools like black
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.cfg          <- Configuration file for flake8
│
└── mlops   <- Source code for use in this project.
    │
    ├── __init__.py             <- Makes mlops a Python module
    │
    ├── config.py               <- Store useful variables and configuration
    │
    ├── dataset.py              <- Scripts to download or generate data
    │
    ├── features.py             <- Code to create features for modeling
    │
    ├── modeling                
    │   ├── __init__.py 
    │   ├── predict.py          <- Code to run model inference with trained models          
    │   └── train.py            <- Code to train models
    │
    └── plots.py                <- Code to create visualizations
```

--------
listwrap 0.0.3
Formatting lists of strings.
Requires Python: >=3.10

# listwrap

Formatting lists of strings.

Use cases include subtasks of automatic config generation or any other highly structured context such as programmatically constructing human-readable SQL statements.

Links:
- [Documentation](https://zkurtz.github.io/listwrap/listwrap.html)
- [We're on pypi](https://pypi.org/project/listwrap/) (so `pip install listwrap`)

## Examples

```
>>> from listwrap import align
>>> print(align(["a", "b", "c"]))
    "a",
    "b",
    "c",
>>> print(align(["a", "b", "c"], quote=None))
    a,
    b,
    c,
>>> print(align(["a", "b", "c"], indent=1))
 "a",
 "b",
 "c",
>>> print(align(["a", "b", "c"], indent=0, vertical=False))
"a","b","c",
```
Several formatting other options are supported; see the `align` method docstring.

## Development

Create and activate a virtual env for dev ops:
```
git clone git@github.com:zkurtz/listwrap.git
cd listwrap
pip install uv
uv sync
source .venv/bin/activate
```
hekaido-hw5-repo 0.1.0
my solution of second hw in MLOps course

second_hw
==============================

my solution of second hw in MLOps course

Project Organization
------------

    ├── LICENSE
    ├── Makefile           <- Makefile with commands like `make data` or `make train`
    ├── README.md          <- The top-level README for developers using this project.
    ├── data
    │   ├── external       <- Data from third party sources.
    │   ├── interim        <- Intermediate data that has been transformed.
    │   ├── processed      <- The final, canonical data sets for modeling.
    │   └── raw            <- The original, immutable data dump.
    │
    ├── docs               <- A default Sphinx project; see sphinx-doc.org for details
    │
    ├── models             <- Trained and serialized models, model predictions, or model summaries
    │
    ├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
    │                         the creator's initials, and a short `-` delimited description, e.g.
    │                         `1.0-jqp-initial-data-exploration`.
    │
    ├── references         <- Data dictionaries, manuals, and all other explanatory materials.
    │
    ├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
    │   └── figures        <- Generated graphics and figures to be used in reporting
    │
    ├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
    │                         generated with `pip freeze > requirements.txt`
    │
    ├── setup.py           <- makes project pip installable (pip install -e .) so src can be imported
    ├── src                <- Source code for use in this project.
    │   ├── __init__.py    <- Makes src a Python module
    │   │
    │   ├── data           <- Scripts to download or generate data
    │   │   └── make_dataset.py
    │   │
    │   ├── features       <- Scripts to turn raw data into features for modeling
    │   │   └── build_features.py
    │   │
    │   ├── models         <- Scripts to train models and then use trained models to make
    │   │   │                 predictions
    │   │   ├── predict_model.py
    │   │   └── train_model.py
    │   │
    │   └── visualization  <- Scripts to create exploratory and results oriented visualizations
    │       └── visualize.py
    │
    └── tox.ini            <- tox file with settings for running tox; see tox.readthedocs.io


--------

<p><small>Project based on the <a target="_blank" href="https://drivendata.github.io/cookiecutter-data-science/">cookiecutter data science project template</a>. #cookiecutterdatascience</small></p>
artem-mlops-misis 0.0.1
A short description of the project.
Requires Python: ~=3.12

# ml_ops

<a target="_blank" href="https://cookiecutter-data-science.drivendata.org/">
    <img src="https://img.shields.io/badge/CCDS-Project%20template-328F97?logo=cookiecutter" />
</a>

A short description of the project.

## Project Organization

```
├── LICENSE            <- Open-source license if one is chosen
├── Makefile           <- Makefile with convenience commands like `make data` or `make train`
├── README.md          <- The top-level README for developers using this project.
├── data
│   ├── external       <- Data from third party sources.
│   ├── interim        <- Intermediate data that has been transformed.
│   ├── processed      <- The final, canonical data sets for modeling.
│   └── raw            <- The original, immutable data dump.
│
├── docs               <- A default mkdocs project; see www.mkdocs.org for details
│
├── models             <- Trained and serialized models, model predictions, or model summaries
│
├── notebooks          <- Jupyter notebooks. Naming convention is a number (for ordering),
│                         the creator's initials, and a short `-` delimited description, e.g.
│                         `1.0-jqp-initial-data-exploration`.
│
├── pyproject.toml     <- Project configuration file with package metadata for 
│                         ml_ops and configuration for tools like black
│
├── references         <- Data dictionaries, manuals, and all other explanatory materials.
│
├── reports            <- Generated analysis as HTML, PDF, LaTeX, etc.
│   └── figures        <- Generated graphics and figures to be used in reporting
│
├── requirements.txt   <- The requirements file for reproducing the analysis environment, e.g.
│                         generated with `pip freeze > requirements.txt`
│
├── setup.cfg          <- Configuration file for flake8
│
└── ml_ops   <- Source code for use in this project.
    │
    ├── __init__.py             <- Makes ml_ops a Python module
    │
    ├── config.py               <- Store useful variables and configuration
    │
    ├── dataset.py              <- Scripts to download or generate data
    │
    ├── features.py             <- Code to create features for modeling
    │
    ├── modeling                
    │   ├── __init__.py 
    │   ├── predict.py          <- Code to run model inference with trained models          
    │   └── train.py            <- Code to train models
    │
    └── plots.py                <- Code to create visualizations
```

--------
grepenv 1.1.1
grep's the env
Requires Python: <4.0,>=3.8


<h1 align=center>
  
  **grepenv** 🔎
  
</h1>

<h3 align=center>

  greps your env

</h3>


<div align=center>

  [![PyPI version](https://badge.fury.io/py/grepenv.svg)](https://badge.fury.io/py/grepenv)
  [![Coverage Status](https://coveralls.io/repos/github/mdLafrance/grepenv/badge.svg?branch=main)](https://coveralls.io/github/mdLafrance/grepenv?branch=main)
  [![Pipeline](https://github.com/mdLafrance/grepenv/actions/workflows/pipeline.yaml/badge.svg)](https://github.com/mdLafrance/grepenv/actions/workflows/pipeline.yaml)
  
</div>

## About
A little tool to search through your environment.  

I made `grepenv` to simplify the process of calling various combinations of `env | grep | sort`, and replicating my aliases for this across machines.

## Installation
`grepenv` can be installed using pip, but [pipx]([pipx](https://github.com/pypa/pipx)) is recommended:
```bash
pipx install grepenv
```
This installs the `grepenv` shell script:
```bash
grepenv --help 
ge --help # The short alias 'ge' is also available
```
## Usage
`grepenv` takes a regex pattern, and matches it against currently available environment variables. 
Calling `grepenv --example` will show some example usage.

```bash
$ grepenv xdg # Will find any key or value that contains the letters xdg (lower or upper case).
```

``` bash
$ grepenv "_api_(key|token)_" --keys # finds any environment variable with this regex pattern, matching only on keys.
GITHUB_API_TOKEN=abc_NlNhalNDL78NAhdKhNAk78bdf7f
OPENAI_API_KEY=123_abcdefghijklmno
```

```bash
$ grepenv --find-key gitlab # Search for an environment variable with the name gitlab, and output it's value.
123_abcdefghijklmnop
# GITLAB_API_TOKEN=123_abcdefghijklmnop
```

```bash
$ grepenv perl --path # Search for the pattern "perl", but only in the PATH
/usr/bin/site_perl
/usr/bin/vendor_perl
/usr/bin/core_perl
```
django-smart-selects 1.7.2
Django application to handle chained model fields.
Requires Python: >=3.8

# Django Smart Selects

[![Jazzband](https://jazzband.co/static/img/badge.svg)](https://jazzband.co/)
[![Build Status](https://github.com/jazzband/django-smart-selects/workflows/Test/badge.svg)](https://github.com/jazzband/django-smart-selects/actions)
[![Coverage Status](https://codecov.io/gh/jazzband/django-smart-selects/branch/master/graph/badge.svg)](https://codecov.io/gh/jazzband/django-smart-selects)
[![PyPI](https://img.shields.io/pypi/v/django-smart-selects.svg)](https://pypi.org/project/django-smart-selects/)

This package allows you to quickly filter or group "chained" models by adding a custom foreign key or many to many field to your models. This will use an AJAX query to load only the applicable chained objects.

Works with Django version 3.2 to 5.0.

**Warning**: The AJAX endpoint enforces no permissions by default.  This means that **any model with a chained field will be world readable**. If you would like more control over this permission, the [`django-autocomplete-light`](https://github.com/yourlabs/django-autocomplete-light) package is a great, high-quality package that enables the same functionality with permission checks.

## Documentation

For more information on installation and configuration see the documentation at:

https://django-smart-selects.readthedocs.io/

## Reporting issues / sending PRs

You can try the test_app example using:

```shell
python manage.py migrate
python manage.py loaddata test_app/fixtures/*
python manage.py runserver
```

Then login with admin/admin at http://127.0.0.1:8000/admin/


## TODO

* Add permission checks to enable users to restrict who can use the chained fields.
* Add a `ChainedCheckboxSelectMultiple` widget and adjust `chainedm2m.js` and `chainedfk.js` to build checkboxes in that case