semvec/pypi-packages huggingface dataset:
thlun 0.1.3
CLI library
Requires Python: >=3.9

<div align="center">
  <p>
    <img src='https://thlun.ashreach.dev/assets/banner.svg' height=300>
  </p>
  <br />
  <p align="center">
    <a href="https://github.com/Ashreach/ThLun/stargazers">
      <img src="https://img.shields.io/github/stars/Ashreach/ThLun?colorA=363a4f&colorB=b7bdf8&style=for-the-badge" alt="GitHub stars"/>
    </a>
    <a href="https://github.com/Ashreach/ThLun/issues">
      <img src="https://img.shields.io/github/issues/Ashreach/ThLun?colorA=363a4f&colorB=f5a97f&style=for-the-badge" alt="GitHub issues"/>
    </a>
    <a href="https://github.com/Ashreach/ThLun/contributors">
      <img src="https://img.shields.io/github/contributors/Ashreach/ThLun?colorA=363a4f&colorB=a6da95&style=for-the-badge" alt="GitHub contributors"/>
    </a>
    <a href="https://pypi.org/project/thlun/">
      <img src="https://img.shields.io/pypi/v/thlun?colorA=363a4f&colorB=a6da95&style=for-the-badge" alt="PyPI version"/>
    </a>
    <br>
    <a href="https://pepy.tech/project/thlun">
      <img src="https://static.pepy.tech/badge/thlun?colorA=363a4f&colorB=f5bde6&style=for-the-badge" alt="Downloads"/>
    </a>
  </p>
  <br>
</div>

## About

**ThLun** is a Python CLI library for stylish terminal output with ANSI colors, logging, progress bars, and spinners.

## Preview

<div align="center">
  <img src="https://thlun.ashreach.dev/assets/preview.gif" alt="ThLun Preview" >
</div>

## Installation

```bash
pip install thlun
```

## Quick Start

```python
from ThLun import bprint, Logger, ProgressBar, Spinner, Spinners
import time

# Basic colored output
bprint("[GREEN]Hello world...[RESET]")

# Logging with levels
logger = Logger('DEBUG')
logger.info("Application started")
logger.error("Something went wrong")

# Progress bar
progress = ProgressBar(total=100)
for i in range(100):
    progress.update(i + 1)
    time.sleep(0.01)

# Spinner for loading
spinner = Spinner(Spinners.dots)
spinner.start("Loading...")
time.sleep(2)
spinner.stop()
```

<img src='https://thlun.ashreach.dev/assets/preview.png'>

## Features

- **ANSI Colors**: Full color support with Fore, Back, and Style classes
- **IO Module**: Enhanced printing with color and style support
- **Logger**: Multi-level logging with colored output
- **Progress Bars**: Visual progress indicators
- **Spinners**: Loading animations with customizable styles
- **Screen Control**: Clear screen and cursor positioning


## Colors

<img src='https://thlun.ashreach.dev/assets/colors.jpg'>
genie-flow-invoker-ollama 0.8.4
Genie Flow Invoker Ollama
Requires Python: >=3.11.0

# Ollama Invokers
[![PyPI version](https://badge.fury.io/py/genie-flow-invoker-ollama.svg?icon=si%3Apython)](https://badge.fury.io/py/genie-flow-invoker-ollama)
![PyPI - Downloads](https://img.shields.io/pypi/dm/genie-flow-invoker-ollama)

This package contains Genie Flow invokers for different Ollama invocations.

## Installing the ollama invoker

```bash
pip install genie-flow-invoker-ollama
```

## Installing Ollama

To run models locally, you'll need to install Ollama. We recommend using the official native installer for your platform:

[Install Ollama](https://ollama.com/download)

This will set up the Ollama runtime and make the ollama command available in your terminal.

Once installed, you can start a model like:

```bash
ollama run llama3
```

For advanced users, Ollama also provides a Docker image: [Ollama for Docker](https://hub.docker.com/r/ollama/ollama) which you can use in containerized environments.

## Select model and query
List all available ollama models run:

```bash
ollama list
```
To start using the selected model, create a meta.yaml and a prompt like described here: [Create LLM templates](https://genieversum.github.io/getting_started/#locally-running-llm:~:text=to%20the%20user.-,Create%20the%20LLM%20Templates,-The%20template%20that)

There are three different types of invokers available:

- OllamaChatInvoker, includes dialogue history in your prompt
- OllamaGenerateInvoker, includes base64-encoded images in your prompt, using the model defined in meta.yaml
- OllamaEmbedInvoker, vectorizes text using the embedding model specified in meta.yaml

### Include base64 encoded images in prompt

For images to be included, the prompt template **must** be structured as follows, or else, the query will only contain plain text.

```jinja
prompt: |
    Some prompt text
images:
    - {{ image_as_base64 }}
```
pytest-asyncio 1.3.0
Pytest support for asyncio
Requires Python: >=3.10

pytest-asyncio
==============

.. image:: https://img.shields.io/pypi/v/pytest-asyncio.svg
    :target: https://pypi.python.org/pypi/pytest-asyncio
.. image:: https://github.com/pytest-dev/pytest-asyncio/workflows/CI/badge.svg
    :target: https://github.com/pytest-dev/pytest-asyncio/actions?workflow=CI
.. image:: https://codecov.io/gh/pytest-dev/pytest-asyncio/branch/main/graph/badge.svg
    :target: https://codecov.io/gh/pytest-dev/pytest-asyncio
.. image:: https://img.shields.io/pypi/pyversions/pytest-asyncio.svg
    :target: https://github.com/pytest-dev/pytest-asyncio
    :alt: Supported Python versions
.. image:: https://img.shields.io/badge/Matrix-%23pytest--asyncio-brightgreen
    :alt: Matrix chat room: #pytest-asyncio
    :target: https://matrix.to/#/#pytest-asyncio:matrix.org

`pytest-asyncio <https://pytest-asyncio.readthedocs.io/en/latest/>`_ is a `pytest <https://docs.pytest.org/en/latest/contents.html>`_ plugin. It facilitates testing of code that uses the `asyncio <https://docs.python.org/3/library/asyncio.html>`_ library.

Specifically, pytest-asyncio provides support for coroutines as test functions. This allows users to *await* code inside their tests. For example, the following code is executed as a test item by pytest:

.. code-block:: python

    @pytest.mark.asyncio
    async def test_some_asyncio_code():
        res = await library.do_something()
        assert b"expected result" == res

More details can be found in the `documentation <https://pytest-asyncio.readthedocs.io/en/latest/>`_.

Note that test classes subclassing the standard `unittest <https://docs.python.org/3/library/unittest.html>`__ library are not supported. Users
are advised to use `unittest.IsolatedAsyncioTestCase <https://docs.python.org/3/library/unittest.html#unittest.IsolatedAsyncioTestCase>`__
or an async framework such as `asynctest <https://asynctest.readthedocs.io/en/latest>`__.


pytest-asyncio is available under the `Apache License 2.0 <https://github.com/pytest-dev/pytest-asyncio/blob/main/LICENSE>`_.


Installation
------------

To install pytest-asyncio, simply:

.. code-block:: bash

    $ pip install pytest-asyncio

This is enough for pytest to pick up pytest-asyncio.


Contributing
------------
Contributions are very welcome. Tests can be run with ``tox``, please ensure
the coverage at least stays the same before you submit a pull request.
speciesot 0.2.7
Geometric inference of cross-species transcriptome correspondence using Gromov–Wasserstein optimal transport.
Requires Python: ==3.12.7

# Species-OT

[](
[![Downloads](https://static.pepy.tech/badge/scegot)](https://pepy.tech/project/speciesot)
)

Geometric inference of cross-species transcriptome correspondence using Gromov-Wasserstein optimal transport.

![fig.png](./docs/_static/fig.png)

## Installation

```sh
$ pip install speciesot
```

## Requirements

- Python 3.12.7
- NVIDIA GPUs or Apple Silicon

  Click [here](https://developer.apple.com/metal/jax/) to learn how to utilize Apple Silicon's GPUs (official documentation).

## Documentation

The tutorial is available [here](https://yuyatokuta.github.io/Species-OT/).

## Preprint

Please see the following preprint:
[Y. Tokuta et al. Geometric inference of cross-species transcriptome correspondence using Gromov-Wasserstein optimal transport. bioRxiv](https://doi.org/10.1101/2025.10.23.684069)
podbase 0.0.1
Python SDK for PodBase vector database
Requires Python: >=3.12
Keywords: podbase, vector-database, python, sdk

# PodBase Python SDK

Python client for PodBase vector database.

## Installation

```bash
pip install podbase
```

## Usage

### Initialize Client

```python
from podbase import PodBase

podbase = PodBase({"baseUrl": "http://localhost:8080"})
```

### Health Check

Check if server is running.

```python
await podbase.health()
# Returns: {"message": "ok"}
```

### Create Collection

Create a new collection with embedding configuration.

```python
collection = await podbase.create.collection("my-docs", {
    "embedding": {
        "provider": "sbert",
        "model": "google/embeddinggemma-300m",
        "dimension": 768,
    }
})
```

### Select Collection

Get reference to existing collection.

```python
collection = podbase.select.collection("my-docs", {
    "embedding": {
        "provider": "sbert",
        "model": "google/embeddinggemma-300m",
        "dimension": 768,
    }
})
```

### Check Collection Exists

Check if a collection exists.

```python
result = await podbase.exist.collection("my-docs")
exists = result["exists"]
```

### Delete Collection

Delete a collection and all its data.

```python
await podbase.delete.collection("my-docs")
```

### Purge Collection

Remove all records but keep collection structure.

```python
await podbase.purge.collection("my-docs")
```

### Insert Records

Add records to a collection.

```python
await collection.records.insert([
    {
        "content": "Python is a dynamic language",
        "payload": {"category": "programming", "lang": "py"},
    },
    {
        "content": "PodBase is a vector database",
        "payload": {"category": "database", "type": "vector"},
    },
])
# Returns: {"inserts": 2}
```

### Search Records

Find similar records using semantic search.

```python
results = await collection.records.search({
    "term": "What is Python?",
    "limit": 5,
    "payload": {"category": {"$eq": "programming"}},
})
# Returns: {"records": [...], "pagination": {...}}
```

### Unsert Records

Remove records by ID or filter.

```python
# By IDs
await collection.records.unsert({
    "ids": ["record-id-1", "record-id-2"],
})

# By filter
await collection.records.unsert({
    "payload": {"category": {"$eq": "outdated"}},
})
# Returns: {"unserted_ids": [...]}
```

## Filter Operators

Use in `payload` or `metadata` filters:

| Operator                | Description             |
| ----------------------- | ----------------------- |
| `$eq`                   | Equal                   |
| `$neq`                  | Not equal               |
| `$gt` / `$gte`          | Greater than (or equal) |
| `$lt` / `$lte`          | Less than (or equal)    |
| `$in` / `$nin`          | In / not in array       |
| `$regex`                | Regular expression      |
| `$and` / `$or` / `$not` | Logical operators       |
set-pdf-margins 0.1.1
Place user-defined margins around PDF page content
Requires Python: >=3.10

# `set-pdf-margins`

This script places user-defined margins around the content of each page of a given PDF file. The left and top margins are given explicitly. The right and bottom margins result from explicitly given page sizes in horizontal (x) and vertical (y) directions. The page content is not rescaled. The document outline is preserved. This script is meant to facilitate PDF reading and margin note taking on tablets and e-readers. Note that correctly determining the bounding box of the content of a PDF page is difficult and your mileage may vary depending on your input PDF.

## Installation

> [!IMPORTANT]
> `set-pdf-margins` requires [ghostscript](https://ghostscript.com) to be installed and available on your system.

Install with `pip`:

```console
pip install set-pdf-margins
```

Or use `uvx`:

```console
uvx set-pdf-margins --help
```

## Usage

```console
$ set-pdf-margins [OPTIONS] PDF_INPUT_PATH MARGIN_LEFT MARGIN_TOP PAGE_SIZE_X PAGE_SIZE_Y
```

**Arguments**:

* `PDF_INPUT_PATH`: [required]
* `MARGIN_LEFT`: [required]
* `MARGIN_TOP`: [required]
* `PAGE_SIZE_X`: [required]
* `PAGE_SIZE_Y`: [required]

**Options**:

* `--pdf-output-path PATH`
* `--unit [pt|mm]`: [default: pt]
* `--install-completion`: Install completion for the current shell.
* `--show-completion`: Show completion for the current shell, to copy it or customize the installation.
* `--help`: Show this message and exit.

If your page content is too large to fit on your target page size, or if you want to crop headers, footers, or page numbers before determining the bounding boxes of the actual content of each page, consider preprocessing your file using other tools first.
yemot 0.1.2
Python client for the Yemot (Call2All) API
Requires Python: >=3.11

# בדיקות והתקנת הפרוייקט
## בדוק שיש לך את הגירסא המעודכנת של pip
Windows
```
pip install --upgrade pip
```

Linux/MAC OS
```
python3 -m pip install --upgrade pip
```


## התקנת הפרוייקט
Windows
```
pip install yemot
```

Linux/MAC OS
```
python3 -m pip install yemot
```
## מבנה הפרוייקט
הפרוייקט מורכב מארבעה מודלים
1. Client - ניהול החיבור לימות המשיח
2. System - קבלת מידע והפעולות במערכת
3. Campaign - קבלת מידע וביצוע פעולות בקמפיינים
4. Ivr - קבלת מידע וביצוע פעולות בשלוחות
# איך להשתמש בפרוייקט
## כלול את הספריה בקובץ שלך
אפשר לכלול את כל המודלים 
```
import yemot
```
או מודול מסויים
```
from yemot import Client, System, Campaign, Ivr
```
וחבר אותו למשתנה, כשאתה קורא לפרוייקט אתה חייב לשלוח את המספר מערכת והסיסמא
```
client = Client(username='0xxxxxxxxx', password='xxxxxxx')
```
כמובן אם השתמשנו ב import yemotאז צריך להשתמש ב 
```
client = yemot.Client(username='0xxxxxxxxx', password='xxxxxxx')
```
וכן בכל השאר

כעת תוכל לבצע את הקריאות

בשביל להתחבר מחדש אחרי ניתוק או ממערכת אחרת
```
client.login(username='0xxxxxxxxx', password='xxxxxxx')
```
לניתוק
```
client.logout()
```
## שימוש במודול System
קריאה למודול
```
system = System(client)
```
לקבלת פרטי המערכת
```
system.system_info()
```
עדכון פרטי מערכת
שלח את הנתון שהינך רוצה לעדכן
```
system.set_system_info(name='שם', email='אימייל', organization='חברה', contact_name='שם איש קשר', phones='טלפון', invoice_name='שם לחשבונית', invoice_address='כתובת לחשבונית', fax='פקס', access_password='סיסמת גישה', record_password='סיסמת הקלטות')
```
לקבלת רשימת חיובי יחידות
ניתן לשלוח מאיזה מספר נתון שימשוך
וכן כמה נתונים שימשוך ברירת מחדל 100
```
system.get_transactions(first='מספר התחלתי', limit='כמה נתונים')
```
העברת יחידות
```
system.transfer_units(destination='מספר מערכת להעברה', amount='כמות יחידות')
```
רשימת השיחות הפעילות במערכת
```
system.get_incoming_calls()
```
העלאת קובץ למערכת
```
system.upload_file(file_path="/tmp/message.mp3", path="ivr2:1/000.wav", convert_audio=True)
```
הורדת קבצים
```
audio_bytes = system.download_file(path="ivr2:1/000.wav")
```
## שימוש במודול Campaign
קריאה למודול
```
camp = Campaign(client)
```
קבלת מצב כל תבניות הקמפיינים
```
camp.get_templates()
```
עדכון תבנית קמפיין
```
camp.update_template()
```
העלאת קבצי קמפיין
```
camp.upload_template_file()
```
הורדת קבצי קמפיין
```
camp.downlaoad_template_file()
```
יצירת תבנית קמפיין חדשה

מחיקת תבנית קמפיין

הצגת המספרים שברשימת התפוצה

עדכון מספר בודד ברשימת תפוצה

# הפרוייקט יעודכן בתקופה הקרובה באופן שוטף אז תתעדכנו






### References
https://f2.freeivr.co.il/post/75
ifscfinder 0.1.0
High-performance IFSC code lookup utilities backed by SQLite.
Requires Python: >=3.7
Keywords: ifsc, banking, lookup, sqlite, finance, indian-banks

IFSCFinder (Python)
===================

IFSCFinder is a high-performance Python package that provides lightning-fast IFSC code lookups through an embedded SQLite database. With sub-millisecond query times and 40x cache acceleration, it's optimized for banking automation, fintech analytics, and high-throughput microservice architectures.

**Performance Metrics:**
- **Average lookup time**: 0.01ms per query
- **Throughput**: 136,845 lookups/second (uncached), 5.5M/second (cached)
- **Cache speedup**: 40x faster for repeated queries
- **Database size**: 42MB compressed SQLite with full Indian banking network coverage
- **Memory footprint**: Minimal with configurable caching

Installation
------------

```bash
pip install git+https://github.com/IntegerAlex/IFSCFinder.git#subdirectory=python
```

For local development:

```bash
cd /home/akshat/projects/ifsc/python
python3 -m venv .venv
source .venv/bin/activate
pip install -e .
```

Usage
-----

```python
from ifscfinder import ifsc_to_details, ifsc_to_bank

details = ifsc_to_details("SBIN0000001")
bank_name = ifsc_to_bank("SBIN0000001")
```

- `ifsc_to_details(code)` returns a dictionary with `BANK`, `BRANCH`, `ADDRESS`, `CITY1`, `CITY2`, `STATE`, and `STD_CODE` keys.
- Field-specific helpers (`ifsc_to_bank`, `ifsc_to_branch`, `ifsc_to_state`, etc.) offer ergonomic access.
- `clear_lookup_cache()` invalidates the in-memory cache when the database changes.
- `get_database(db_path=None)` returns the underlying `IFSCDatabase` singleton if you need lower-level control.

Data Source
-----------

The packaged SQLite database lives under `ifscfinder/data/ifsc.db`. Replace this file with an updated dataset to refresh lookups. The package automatically validates the presence of the database and raises a descriptive `FileNotFoundError` if it is missing.

Testing & Quality
-----------------

- Run `python3 -m compileall src/ifscfinder` to sanity check syntax.
- Upcoming automated tests will live under `python/tests` and be executed via `pytest`.
- The code uses strict IFSC normalization and structured logging to aid production diagnostics.

Roadmap
-------

- Publish the package to PyPI with automated GitHub Actions builds.
- Provide a JSON export pipeline to feed JavaScript, Go, and Rust ports.
- Synchronize API contracts across the forthcoming TypeScript client and other language bindings.

Contributing
------------

1. Fork the repository and create a feature branch.
2. Run sanity checks before submitting a pull request.
3. Document any API changes in this README and sync cross-language specs.

License
-------

LGPL-2.1 License. See `LICENSE` in the project root.

**Copyright Notice:**
Copyright (c) 2024 Akshat Kotpalliwar. All rights reserved.

This package is distributed under the GNU Lesser General Public License v2.1.
See the LICENSE file for full copyright information and license terms.