semvec/pypi-packages huggingface dataset:
flexscspace 1.1.0
The update to SCSpace provides more flexible version options
Requires Python: >=3.8

# FlexScspace 

[![Python >=3.8](https://img.shields.io/badge/python-%3E%3D3.8-blue)](https://www.python.org/)
[![PyPI Version](https://img.shields.io/pypi/v/flexscspace)](https://pypi.org/project/flexscspace/)
[![License](https://img.shields.io/badge/license-GNU-green)](LICENSE)

## Multi-Version Enhanced scRNA-seq Spatial Reconstruction Toolkit

**Flexible Versioned Spatial Analysis Toolkit**  
*Extending scSpace with multiple algorithm implementations for optimal single-cell spatial reconstruction*
---

## Quick Navigation
- [Features](#-features)
- [Installation](#-installation)  
- [Quick Start](#-quick start)
- [Version Guide](#-version comparison)

---

## Features
- **Six Algorithm Versions**: `v0` through `v3c` 
- **Unified API**: Switch versions with one parameter

## Installation
```bash
pip install FlexScspace  # Requires Python≥3.8, pytorch, scanpy
```

## Quick Start
### Common Usage(v0/v1/v2/v3b/v3c)
```python
# Initialize with selected version
from FlexScspace import VersionSelector
algorithm = VersionSelector(version="v2")
# Load data (consistent across versions)
sc_obj, st_obj = algorithm.load_data(
    sc_data_path="sc_data.csv",
    st_data_path="st_data.csv",
    spatial_key=['imagerow','imagecol']
)
# Process data
sc_obj, st_obj = algorithm.preprocess(
    sc_adata=sc_obj,
    st_adata=st_obj,
    n_features=2000)
# Spatial reconstruction
sc_obj, st_obj = algorithm.construct_pseudo_space(
    sc_adata=sc_obj,
    st_adata=st_obj,
    batch_size=16,
    epoch_num=1000
)
```

### v3a Specific Usage
```python
# Initialize with selected version
from FlexScspace import VersionSelector
algorithm = VersionSelector(version="v3a")
# Load data (consistent across versions)
sc_obj, st_obj = algorithm.load_data(
    sc_data_path="sc_data.csv",
    st_data_path="st_data.csv",
    spatial_key=['imagerow','imagecol']
)
# Process data
sc_obj, st_obj = algorithm.preprocess(
    sc_adata=sc_obj,
    st_adata=st_obj,
    n_features=2000,
    r_binary=r_path,
    output_dir=output_dir)
# Spatial reconstruction
sc_obj, st_obj = algorithm.construct_pseudo_space(
    sc_adata=sc_obj,
    st_adata=t_obj,
    batch_size=16,
    epoch_num=1000
)
```

## Version Comparison

|Versions|Key Innovation|Recommended Use Case|
|:---|:--|:--|
|v0|Basic version|Baseline comparisons|
|v1|Spatially variable gene|Tissues with clear spatial gradients|
|v2|Implicit Neural Representation|To be explored|
|v3.a|Batch correction:CCA|To be explored|
|v3.b|Batch correction:Scanorama|To be explored|
|v3.c|Batch correction:scVi|Tissues with complex organization|
ychatty 0.1.0
A simple and friendly command-line chat interface with colorful output
Requires Python: >=3.8
Keywords: chat, cli, colorful, interactive, terminal

# 🎉 chatty

A simple and friendly command-line chat interface with colorful output! 

chatty is a delightful CLI tool that provides an interactive chat-like experience with beautiful colors, emojis, and a friendly bot companion.

## ✨ Features

- 🤖 **Friendly AI-like responses** - Chat with a cheerful bot
- 🌈 **Beautiful colors** - Rich, colorful terminal output
- 😊 **Emoji support** - Fun emojis throughout the interface
- 📜 **Conversation history** - Keep track of your chat
- ⏰ **Time queries** - Ask for the current time
- 😄 **Jokes** - Request jokes for entertainment
- 🎨 **Rich formatting** - Tables, panels, and beautiful layouts
- 🚀 **Fast and lightweight** - Minimal dependencies

## 🚀 Installation

Install chatty directly from PyPI:

```bash
pip install chatty
```

Or install with uv:

```bash
uv add chatty
```

## 💬 Usage

### Basic Usage

Simply run chatty to start an interactive chat session:

```bash
chatty
```

### With Options

```bash
# Start with your name for a personalized experience
chatty --name "Alice"

# Start in quiet mode (no welcome message)
chatty --quiet

# Get help
chatty --help
```

### Example Conversation

```
🎉 Welcome to chatty! 🎉

💬 Type anything to chat with me!
🚪 Type 'bye', 'exit', or 'quit' to leave
📜 Type 'history' to see our conversation
❓ Type 'help' for more commands

You: Hello!
chatty: Hey! Great to see you! 😊

You: What time is it?
chatty: The current time is 14:30:25! ⏰

You: Tell me a joke
chatty: Why don't scientists trust atoms? Because they make up everything! 😄

You: bye
chatty: Goodbye! It was great chatting! 👋
```

## 🎮 Commands

- **General chat**: Just type anything to chat!
- **Time**: Ask "what time is it?" to get the current time
- **Jokes**: Say "tell me a joke" for a random joke
- **History**: Type "history" to see conversation history
- **Help**: Type "help" for command information
- **Exit**: Type "bye", "exit", or "quit" to leave

## 🛠️ Development

### Requirements

- Python 3.8+
- rich >= 13.0.0
- click >= 8.0.0

### Local Development

1. Clone the repository:
```bash
git clone https://github.com/zokrezyl/chatty.git
cd chatty
```

2. Install with uv:
```bash
uv sync
```

3. Run in development mode:
```bash
uv run chatty
```

### Building

Build the package:
```bash
uv build
```

## 📝 License

MIT License - see LICENSE file for details.

## 🤝 Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## 🐛 Issues

Found a bug or have a feature request? Please open an issue on GitHub.

## 🌟 Why chatty?

chatty was created to bring a bit of joy and color to the command line. Sometimes you just want to have a friendly conversation with your terminal! 

Whether you're taking a break from coding, testing terminal colors, or just want to chat with a friendly bot, chatty is here to brighten your day! ✨

---

Made with ❤️ by zokrezyl
ucdp-regf 0.15.3
Unified Chip Design Platform - Register File
Requires Python: <4.0,>=3.10.0

[![PyPI Version](https://badge.fury.io/py/ucdp-regf.svg)](https://badge.fury.io/py/ucdp-regf)
[![Python Build](https://github.com/nbiotcloud/ucdp-regf/actions/workflows/main.yml/badge.svg)](https://github.com/nbiotcloud/ucdp-regf/actions/workflows/main.yml)
[![Documentation](https://readthedocs.org/projects/ucdp-regf/badge/?version=stable)](https://ucdp-regf.readthedocs.io/en/stable/?badge=stable)
[![Coverage Status](https://coveralls.io/repos/github/nbiotcloud/ucdp-regf/badge.svg?branch=main)](https://coveralls.io/github/nbiotcloud/ucdp-regf?branch=main)
[![python-versions](https://img.shields.io/pypi/pyversions/ucdp-regf.svg)](https://pypi.python.org/pypi/ucdp-regf)

# Unified Chip Design Platform - Register File

* [Documentation](https://ucdp-regf.readthedocs.io/en/stable/)
* [PyPI](https://pypi.org/project/ucdp-regf/)
* [Sources](https://github.com/nbiotcloud/ucdp-regf)
* [Issues](https://github.com/nbiotcloud/ucdp-regf/issues)

## Installation

Installing it is pretty easy:

```bash
pip install ucdp-regf
```
odoo-connector-datoulobase 0.1.0
A simple and clean Python connector for Odoo XML-RPC API
Requires Python: >=3.6

# odoo_connector

A clean and lightweight Python connector for **Odoo's XML-RPC API**.

This package simplifies interactions with Odoo models using Python, so you can authenticate, read, create, update, and delete records easily.

## ✨ Features

- 🔐 Authentication via XML-RPC
- 📚 CRUD operations on any Odoo model
- 🔁 Generic method caller
- 🧼 Clean and well-documented code
- ✅ Ready for use in production or automation scripts

---

## 🛠️ Installation

### A. Clone the repository & install locally:

```bash
git clone https://github.com/your-user/odoo_connector.git
cd odoo_connector
pip install -e .
```

---

## 🚀 Usage

### 1. Import and initialize

```python
from odoo_connector import OdooConnector

odoo = OdooConnector(
    url='https://your-odoo-instance.com',
    db='your_database_name',
    username='admin@example.com',
    password='your_password'
)
```

### 2. Read records

```python
partners = odoo.read('res.partner', fields=['name', 'email'], limit=5)
for p in partners:
    print(p)
```

### 3. Create a record

```python
partner_id = odoo.create('res.partner', {
    'name': 'Bruce Wayne',
    'email': 'batman@gotham.com'
})
print("New Partner ID:", partner_id)
```

### 4. Update a record

```python
odoo.write('res.partner', [partner_id], {'phone': '+123456789'})
```

### 5. Delete a record

```python
odoo.unlink('res.partner', [partner_id])
```

### 6. Call a custom method

```python
has_rights = odoo.call_method(
    'res.partner',
    'check_access_rights',
    ['read'],
    {'raise_exception': False}
)
print("Has read access:", has_rights)
```

---

## 📦 Project Structure

```
odoo_connector/
├── odoo_connector/
│   ├── __init__.py
│   └── api.py
├── tests/
│   └── test_connector.py
├── setup.py
├── README.md
└── LICENSE
```
ecs-alchemy 0.1.0a1
An Entity Component System architecture module for Flask projects.
Requires Python: >=3.8

# ecs-alchemy

**WORK IN PROGRESS - ALPHA VERSION**

This project provides an Entity Component System (ECS) architecture module for projects using SQLAlchemy.

## Installation

```bash
pip install ecs-alchemy
```

## Usage

```python
# Example usage to be added here
```

## Building and Uploading to PyPI

**1. Install Build Tools:**

```bash
pip install --upgrade build twine
```

**2. Build the Package:**

```bash
python3 -m build
```

**3. Upload to TestPyPI (Recommended):**

```bash
python3 -m twine upload --repository testpypi dist/*
```

**4. Install from TestPyPI:**

```bash
pip install --index-url https://test.pypi.org/simple/ --no-deps ecs-alchemy
```

**5. Upload to PyPI:**

```bash
python3 -m twine upload dist/*
```
kimina-client 0.2.1
Client SDK to interact with Kimina Lean server.
Requires Python: >=3.9

# Kimina client

Client SDK to interact with Kimina Lean server. 

Example use:
```python
from kimina_client import KiminaClient

# Specify LEAN_SERVER_API_KEY in your .env or pass `api_key`.
# Default `api_url` is https://projectnumina.ai
client = KiminaClient()

# If running locally use:
# client = KiminaClient(api_url="http://localhost:80")

client.check("#check Nat")
```

## Backward client

```python
from kimina_client import Lean4Client

client = Lean4Client()

client.verify("#check Nat")
```
handymatt-media 0.4.7
A collection of custom media analysis/generation libraries for my personal use.
Requires Python: >=3.8

# handymatt-media

A collection of custom media analysis/generation libraries that I use in many of my Python projects!

## Libraries
- `media_generator`: 
- `video_analyser`: 
- `video_preview_grid_maker`: 
- `image_metadata`: [ABANDONED] Library for reading and writing metadata in json format to the metadata description of images. 

## Libraries to add:
- `mkv_tag_editor`: [requires: `MKVToolNix`]
jinja2-htmlmin 1.0.1
Automatic HTML minification for Jinja2 templates
Requires Python: >=3.9
Keywords: fastapi, html, htmlmin, jinja, jinja2, minification, minify, optimization, performance, response, starlette, template, web

# jinja2-htmlmin

[![PyPI - Python Version](https://shields.monicz.dev/pypi/pyversions/jinja2-htmlmin)](https://pypi.org/p/jinja2-htmlmin)
[![Liberapay Patrons](https://shields.monicz.dev/liberapay/patrons/Zaczero?logo=liberapay&label=Patrons)](https://liberapay.com/Zaczero/)
[![GitHub Sponsors](https://shields.monicz.dev/github/sponsors/Zaczero?logo=github&label=Sponsors&color=%23db61a2)](https://github.com/sponsors/Zaczero)

Automatic HTML minification for Jinja2 templates.

## Why Use This?

- **Zero runtime overhead**: Minification happens once at load time, not on every render
- **Smaller HTML**: Reduced bandwidth and faster page loads
- **Drop-in compatibility**: Works with any Jinja2 loader (Flask, Django, FastAPI, etc.)
- **Broad Python support**: Compatible with Python 3.9+
- [**Semantic Versioning**](https://semver.org): Predictable, reliable updates
- [**Zero-Clause BSD**](https://choosealicense.com/licenses/0bsd/): Public domain, use freely anywhere

## Installation

```bash
pip install jinja2-htmlmin
```

## Quick Start

```python
from jinja2 import Environment, FileSystemLoader
from jinja2_htmlmin import minify_loader

# Wrap any Jinja2 loader
# See https://htmlmin.readthedocs.io/en/latest/reference.html for options
env = Environment(
    loader=minify_loader(
        FileSystemLoader("templates"),
        remove_comments=True,
        remove_empty_space=True,
        remove_all_empty_space=True,
        reduce_boolean_attributes=True,
    )
)

# Rendered HTML is automatically minified
html = env.get_template('index.html').render(title='My Page')
```

## How It Works

1. Template loads normally through your existing loader
2. Jinja2 syntax is temporarily protected during minification
3. HTML content is minified using [htmlmin2](https://github.com/wilhelmer/htmlmin)
4. Jinja2 syntax is restored and template compiles as usual
5. Jinja2's built-in caching means this happens only once per template