semvec/pypi-packages huggingface dataset:
proloquor-model 0.0.5
Useful classes that model and examine proloquor.net surveys.
Requires Python: >=3.9

# Proloquor Model

Useful python classes that model and examine proloquor.net surveys.  To download the package from [PyPi](https://pypi.org/project/proloquor-model/):

```bash
% pip install proloquor-model
```

## Development Setup

```powershell   
PS C:\proloquor-model>git clone git@gitlab.com:proloquor-public/proloquor-model.git
PS C:\proloquor-model> python -m venv .venv
PS C:\proloquor-model> .venv\Scripts\Activate.ps1
(.venv) PS C:\proloquor-model> python -m pip install pip --upgrade
(.venv) PS C:\proloquor-model> pip install pip-tools
(.venv) PS C:\proloquor-model> pip-compile --upgrade
(.venv) PS C:\proloquor-model> pip install -r requirements.txt
(.venv) PS C:\proloquor-model> pytest
```

Once you make any changes to the code, perform the following steps to upload the source to gitlab and the executable library to [pypi.org](https://packaging.python.org/en/latest/tutorials/packaging-projects/).  

```powershell
(.venv) PS C:\proloquor-model> git commit git@gitlab.com:proloquor-public/proloquor-model.git
```

Update the version in pyproject.toml:
```python
[project]
name = "proloquor-model"
version = "0.0.1"
authors = [
  { name="Proloquor.net Staff", email="staff@proloquor.net" },
]
```
Build the library and deploy it to pypi.org using twine.  You'll be prompted for your pypi.org [API key](https://pypi.org/help/#apitoken).  

```powershell
(.venv) PS C:\proloquor-model> pip install build
(.venv) PS C:\proloquor-model> python3 -m build
(.venv) PS C:\proloquor-model>pip install twine
(.venv) PS C:\proloquor-model>python3 -m twine upload dist/*
```
gemmapy 2.0.3
a Python Wrapper for the Gemma API
Requires Python: >3.10
Keywords: gemma, bioinformatics

gemmapy: a Python Wrapper for the Gemma API
===========================================

This is a Python wrapper for `Gemma <https://gemma.msl.ubc.ca/>`_'s
RESTful `API <https://gemma.msl.ubc.ca/resources/restapidocs/>`_. Gemma is a web
site, database and a set of tools for the meta-analysis, re-use and
sharing of genomics data, currently primarily targeted at the analysis
of gene expression profiles. Gemma contains data from thousands of
public studies, referencing thousands of published papers.


Installation instructions
-------------------------
.. This is a content of docs/install.rst. Update it whenever install.rst changes.
   
The package requires Python3.10+. 

#. Install it from a local copy

   .. code-block:: bash

      git clone git@github.com:PavlidisLab/gemmapy.git
      cd gemmapy
      pip install .

#. Install it from PyPI 

   .. code-block:: bash

      pip install gemmapy


Usage
-----

To get started with *gemmapy*, read the 
`Tutorial <https://pavlidislab.github.io/gemmapy/tutorial.html>`_.

The full documentation can be found at 
https://pavlidislab.github.io/gemmapy/.


Citation
--------

To cite Gemma, please use: `Lim, N. et al., Curation of over 10 000
transcriptomic studies to enable data reuse, Database, 2021
<https://doi.org/10.1093/database/baab006>`_.
streamlit-chemui 0.0.1
Streamlit's chemui component
Requires Python: >=3.7

# streamlit-chemui

Streamlit component that allows you to do X

## Installation instructions

```sh
pip install streamlit-chemui
```

## Usage instructions

```python
import json
import streamlit as st

from chemui import ChemList, Smiles

DemoCSV = {
    "visual_data": [
        {
            "name": "csv的Demo名称",
            "description": "csv的Demo内容描述",
            "files": [
                {
                    "type": "CSV",
                    "name": "csv的展示名称",
                    "description": "csv的展示描述",
                    "path": "http://localhost:5500/CDK9_actives.csv",
                    "download_url": "http://localhost:5500/CDK9_actives.csv",
                    "format": "csv"
                }
            ],
            "download_url": "http://localhost:5500/CDK9_actives.csv"
        }
    ]
};

DemoCSV1 = json.dumps(DemoCSV)
ChemList(DemoCSV)
```

```python
import json
import streamlit as st

from chemui import ChemList, Smiles

Smiles("CC(=O)OC1=CC=CC=C1C(=O)O")
```
mppsolar 0.16.56
Package to communicate with Solar inverters and BMSs
Requires Python: <4.0,>=3.11

# MPP-Solar Device Python Package #

__BREAKING CHANGES__
- minimum python supported 3.10 for version >=0.16.0
- command separator changed to `#`
.


Python package with reference library of commands (and responses)
designed to get information from inverters and other solar inverters and power devices

Currently has support for:
- MPP-Solar and similar inverters, e.g.
  - PIP-4048MS
  - IPS-4000WM
  - Voltronic Axpert MKS 5KVA Off-grid Inverter-Chargers
  - LV5048
- JK BMS
- Victron VE Direct Devices:
  - tested on SmartShunt 500A
- Daly BMS

## Install ##
- `pip install mppsolar` (minimal install), or
- `pip install mppsolar[api]` (install server stuff), or
- `pip install mppsolar[ble]` (for Bluetooth support aka jkbms), or
- `pip install mppsolar[mongo]` (for MongoDB output), or
- `pip install mppsolar[pgsql]` (for PostgreSQL output), or
- `pip install mppsolar[push]` (for Prometheus PushGateway output), or
- `pip install mppsolar[systemd]` (for `--daemon` on Linux), or
- `docker pull jblance/mppsolar:latest` (docker install)


## Documentation ##
[See the wiki for documentation](https://github.com/jblance/mpp-solar/wiki)

## Support ##
If you want to tip me for this work, you can now buy me a coffee

[![buymeacoffee1](https://user-images.githubusercontent.com/1266998/225745276-54d6a4d4-a1ed-44f9-a1f2-e99eb1aa2812.png)](https://www.buymeacoffee.com/jblance)
slotmatch 0.1.0
Extract structured key-value pairs from unstructured LLM output using regex, fuzzy matching, and schema validation.
Requires Python: >=3.7

# SlotMatch

**SlotMatch** is a lightweight Python package for extracting structured key-value pairs from unstructured or noisy LLM outputs. It supports regex-based parsing, fuzzy key recovery, schema validation, and confidence scoring. Perfect for production RAG, chatbot, and NLU pipelines.

---

## Installation

```bash
pip install slotmatch

## Features

- Regex-based value extraction

- Fuzzy key mapping (e.g., intnt → intent)

- Schema validation for expected keys and types

- Type coercion (str, int, float, bool)

- Confidence scoring (regex = high, fuzzy = partial, fallback = 0)

- Lightweight, no external dependencies

## Usage

from slotmatch import SlotExtractor

schema = {
    "name": str,
    "intent": str,
    "destination": str
}

llm_output = '''
Hi, I'm Alice.
{
  "intnt": "book_flight",
  "dest": "NYC",
  "name": "Alice"
}
'''

extractor = SlotExtractor(schema)
print(extractor.extract(llm_output))

## Output

{
  'name': {'value': 'Alice', 'confidence': 1.0},
  'intent': {'value': 'book_flight', 'confidence': ~0.64},
  'destination': {'value': None, 'confidence': 0.0}
}

## Example Use Cases

- Post-processing LLM outputs (chatbots, assistants, tools)

- Extracting form fields or user intents

- Structuring data for downstream APIs or storage

- Integrating LLMs with business logic (field validation, routing)

## License

This project is licensed under the MIT License.
hashkeep 1.0.1
Simple utility to hash the contents of files and store hashes in a cache for quick repeat hashing
Requires Python: >=3.7

Caching File Hasher
===================

Simple utility to hash the contents of files and store hashes in a cache for quick repeat hashing.


Installing
----------

    pip install hashkeep


Basic Usage
-----------
    
    from pathlib import Path
    from hashlib import md5

    from hashkeep import CachingFileHasher

    hasher = CachingFileHasher(hasher=m5d, cache_path=Path('.cache'))
    hasher.get_file_hash('file.dat') == '9dd4e461268c8034f5c8564e155c67a6'


Command Line Usage
------------------

    usage: hashkeep [-h]
                    [--hasher {blake2b,blake2s,md5,md5-sha1,ripemd160,sha1,sha224,sha256,sha384,sha3_224,sha3_256,
                               sha3_384,sha3_512,sha512,sha512_224,sha512_256,shake_128,shake_256,sm3}]
                    [--hash-only] [--cache-path CACHE_PATH]
                    [--cache-for CACHE_FOR]
                    paths [paths ...]

    Perform file hash and cache results
    
    positional arguments:
      paths                 File to hash
    
    options:
      -h, --help            show this help message and exit
      --hasher {blake2b,blake2s,md5,md5-sha1,ripemd160,sha1,sha224,sha256,sha384,sha3_224,sha3_256,
                sha3_384,sha3_512,sha512,sha512_224,sha512_256,shake_128,shake_256,sm3}
                            Which hashing algorithm to use
      --hash-only           Only print file hash
      --cache-path CACHE_PATH
                            Where to cache computed file hashes
      --cache-for CACHE_FOR
                            Seconds to cache hashes for (default 365 days)
javascript-data-files 1.4.1
Work with JSON which is stored as a value in a JavaScript file
Requires Python: >=3.12

# javascript-data-files

This is a collection of Python functions for manipulating JavaScript "data files" -- that is, JavaScript files that define a single variable with a JSON value.

This is an example of a JavaScript data file:

```javascript
const shape = { "sides": 5, "colour": "red" };
```

Think of this module as the JSON module, but for JavaScript files.

These data files are meant to be both human- and machine-readable.

## Usage

If you install `javascript-data-files`:

*   You can read a JavaScript file with `read_js(path, varname)`
*   You can write a JavaScript file with `write_js(path, value, varname)`
*   You can append an item to a JavaScript array with `append_to_js_array(path, value)`
*   You can append a key-value pair to a JavaScript object with `append_to_js_object(path, key, value)`

If you install `javascript-data-files[typed]`:

*   You can read a JavaScript file and validate it matches a particular Python type with `read_typed_js(path, varname, model)`.

## Installation

You have two options:

1.  Copy the file `src/javascript` folder into your project.
    You probably want to copy the tests as well.

2.  Install the package using pip:

    ```console
    $ pip install javascript-data-files
    ```

## Why not use JSON files?

If you've opening an HTML file from disk, you can load data from a local JavaScript file, for example:

```html
<script src="file://users/alexwlchan/repos/javascript-data-files/data.js"></script>
```

This is the only way to load data from an external file from an HTML file you've opened locally -- you can't do this with a JSON file, for example.

I have a lot of HTML files and local sites I build with an HTML viewer and metadata in a JavaScript file.
The convenience of this approach outweighs the mild annoyance of having to store data in JavaScript, not JSON.

## Development

If you want to make changes to the library, there are instructions in [CONTRIBUTING.md](./CONTRIBUTING.md).

## License

MIT.
SOM-TUI 4.7
A TUI that lets you vote on SOM project through the terminal!
Requires Python: >=3.9

# SOM CLI

###### A TUI that lets you vote on SOM projects via the terminal

## Features:
- Uses Textual for the TUI
- Uses Selenium and Beautiful Soup for web scraping
- Gets cookies from the user by asking for them

# Prerequisites
- Have Chrome Installed
- If it doesn't work because the driver crashed, download the latest chrome version here: https://developer.chrome.com/docs/chromedriver/downloads

## Usage:
### pip (Recommended)
- Go into devtools in your browser while at summer.hackclub.com/campfire after signing in
- Go to the Storage tab
- In Cookies, there should be a cookie named _journey_session and copy the value of that cookie
- Then run `pip install SOM-TUI` in the terminal
- You might need to use `pip3 install SOM-TUI` on some systems
- Finally, type in `vote` in the terminal!
- Paste the cookie value you copied earlier into the text field
- Start voting!
- If you want to exit, tap Ctrl+Q
###Check out the Pypi page at https://pypi.org/project/SOM-TUI/1.3 and star this repo if you like it!
twitch-bot-plus 1.1.0
A modular Twitch chat bot framework.
Requires Python: >=3.10
Keywords: twitch, bot, irc, chat

# twitch-bot-plus
A python library for making Twitch Bots

## Env Setup
```
BOTNAME=Bot_Name
OAUTH_ID=oauth:
CLIENT_ID=
CLIENT_SECRET=
TWITCH_REFRESH_TOKEN=
CHANNEL=#Target_Channel
```
logos-cdi 1.1.0
The hackable dependency injection framework
Requires Python: >=3.12

# logos_cdi

LogosCDI is a dependency injection tool that allows you to create extensible and maintainable applications


## How to install
```sh
pip install logos_cdi
```

## Basic usage
First you need to create an object of the Application class
```py
from logos_cdi.application import Application

app = Application(
    modules=[

    ]
)
```
You may want to use some modules to improve productivity
```py
from logos_cdi.application import Application
from logos_cdi.command import Commands

app = Application(
    modules=[
        Commands()
    ]
)
```
The Commands Module gives you a basis for creating commands to be executed in the terminal.

You can call it with:

```sh
$ logos
usage: logos [--app-url APP_URL] {} ...
logos: error: the following arguments are required: command
```
Create your own modules with commands

```py
from logos_cdi.command import Commands, AbstractCommand, CommandModule

class TestCommand(AbstractCommand):

    def define_arguments(self, argument_parser):
        argument_parser.add_argument('--name', default='Anonymous')
        return super().define_arguments(argument_parser)

    def execute(self):
        return print('Hello', self.arguments.name)

class Tests(CommandModule, BaseModule):

    def define_commands(self):
        return {
            'test': Service(
                class_path='test_module.TestCommand',
                parameters={}
            )
        }

```
Add to your application

```py
from logos_cdi.application import Application
from logos_cdi.command import Commands
from test_module import Tests

app = Application(
    modules=[
        Commands(),
        Tests()
    ]
)
```

```sh
$ logos
usage: logos [--app-url APP_URL] {test} ...
logos: error: the following arguments are required: command

$ logos test --help
usage: logos test [-h] [--name NAME]

options:
  -h, --help   show this help message and exit
  --name NAME

$ logos test
Hello Anonymous

$ logo test --name=foo
Hello foo
```
kps-file-organizer 0.3.0
A powerful and configurable command-line tool to organize your files effortlessly.
Requires Python: >=3.8

# File Organizer CLI

A powerful and configurable command-line tool to organize your files effortlessly.

## Overview

This tool helps you keep your directories tidy by moving files into dedicated folders based on their extension, creation date, or custom rules you define.

## Features

*   Organize files by their extension (e.g., `.pdf`, `.jpg`, `.docx`).
*   Sort files into folders by creation date (e.g., `YYYY-MM-DD`).
*   Highly configurable using a `config.yaml` file.
*   Cross-platform and easy to use.

## Installation

You can install the File Organizer CLI directly from PyPI:

```bash
pip install kps-file-organizer
```

## Usage

Here are a couple of examples of how to use the tool.

### Organize by File Extension

This command will scan the specified directory and group files into subdirectories based on their extension (e.g., `pdf`, `jpg`, `txt`).

```bash
file-organizer /path/to/your/directory --by-extension
```

### Organize by Date

This command will scan the specified directory and group files into subdirectories based on their modification date.

```bash
file-organizer /path/to/your/directory --by-date
```

### Previewing Changes (Dry Run)

To see which files will be moved without actually performing the operation, use the `--dry-run` flag. This is highly recommended to run first.

```bash
file-organizer /path/to/your/directory --by-extension --dry-run
```

## Author

- **Krishna Pratap Singh**
- GitHub: [kps369](https://github.com/kps369)

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for details.
torii-ila 0.2.0
Integrated Logic Analyzer core for Torii based designs
Requires Python: >=3.11
Keywords: Torii, FPGA, ILA, Debugger, Logic Analyzer

# Torii ILA

> [!WARNING]
> Torii ILA is in early development, it may not be stable, or even functional at all, use at your own risk.

Torii ILA is an Integrated Logic Analyzer (ILA) for [Torii] based designs, it is adapted from the ILA that is a part of [SOL] and aims to be more generally useful outside of it, and also
aims to replace it directly.

It provides several backhaul interfaces for getting the ILA samples off of the device and on to a host:

* [USB] - Using [Torii-USB]
* [UART] - Using [`torii.lib.serial`]

## Getting Started

To get started, see the [installation] instructions and [Getting Started] sections of the [Documentation].

## Community

The two primary community spots for Torii and by extension Torii ILA are the `#torii` IRC channel on [libera.chat] (`irc.libera.chat:6697`) which you can join via your favorite IRC client or the [web chat], and the [discussion forum] on GitHub.

Please do join and share your projects using Torii, ask questions, get help with problems, or discuss development.

## License

Torii ILA is licensed under the [BSD-3-Clause], the full text of which can be found in the [`LICENSE`] file.

The documentation is licensed under the Creative Commons [CC-BY-SA 4.0] and can be found in the [`LICENSE.docs`] file

[Torii]: https://github.com/shrine-maiden-heavy-industries/torii-hdl/
[Torii-USB]: https://github.com/shrine-maiden-heavy-industries/torii-usb/
[SOL]: https://github.com/shrine-maiden-heavy-industries/sol/
[`torii.lib.serial`]: https://github.com/shrine-maiden-heavy-industries/torii-hdl/blob/main/torii/lib/stdio/serial.py
[installation]: https://torii-ila.shmdn.link/install.html
[Getting Started]: https://torii-ila.shmdn.link/getting_started.html
[Documentation]: https://torii-ila.shmdn.link
[USB]: https://torii-ila.shmdn.link/ila/usb.html
[UART]: https://torii-ila.shmdn.link/ila/uart.html
[libera.chat]: https://libera.chat/
[web chat]: https://web.libera.chat/#torii
[discussion forum]: https://github.com/shrine-maiden-heavy-industries/torii-ila/discussions
[BSD-3-Clause]: https://spdx.org/licenses/BSD-3-Clause.html
[`LICENSE`]: ./LICENSE
[CC-BY-SA 4.0]: https://creativecommons.org/licenses/by-sa/4.0/
[`LICENSE.docs`]: ./LICENSE.docs
remote-table 0.1.0
A Python port of the remote_table Ruby gem. Reads tabular data from local and remote sources.
Requires Python: >=3.12

# Remote Table Python Library

A Python port of the Ruby gem 'remote_table'.

## Installation

```bash
uv pip install .
```

## Usage

```python
from remote_table import RemoteTable

table = RemoteTable('path_or_url_to_file')
for row in table:
    print(row)
```

## Features
- Read delimited (CSV/TSV), fixed-width, HTML, JSON, XML, YAML, ODS, XLS, XLSX files
- Local and remote file support
- Auto-detect format

## License
MIT