semvec/pypi-packages huggingface dataset:
vpd 0.9.13
VirtualPathDictChains. Hierarchical, Addressable Dicts, potentially using YaML
Requires Python: >=3.9

# python-vpd

VirtualPathDictChains - Hierarchical Settings Management using YaML

This is an amalgamation of existing code that has been separated into its own package.

Hosted on GitHub: https://github.com/dbotwinick/python-vpd

As of version 0.9.5+, python 2.7 support is being phased out and targeting 3.9+ for python support. The legacy code
is actually still python 2.7 compatible; however, the vpd.next code is not guaranteed to support python versions
less than 3.9.

The base legacy code for VirtualPathDictChains is still useful and provides a mechanism to find data in "chains" of
yaml. For example, if you had a dict: "{"test": {"v1": "v1", "v2":"v2"}}", using the VPD/VirtualPathDictChain approach,
you could query for "test/v1" and get the result "v1". This was originally designed for complex settings or
preferences management in python applications.

The "chain" part is that if a value is not found, the next source/VirtualPathDict would be searched. By having a chain,
settings could be "merged" into a single queryable view. String values in the dicts also supported default arg
substitution such that if a query result contained a text value of "{test/v2}", the bracketed expression
would be used as a lookup to find that value--allowing references--which is also really useful for managing complex
settings or preferences for an application etc.

The legacy code is maintained at vpd.legacy and backwards-compatible stubs are provided in the package root. Therefore,
the following packages still work:

- vpd.arguments
- vpd.cid
- vpd.cmp
- vpd.iterable
- vpd.yaml_dict

The newer generation code expands on this base concept to allow modeling arbitrary relationships among data "types"
(expected to be yaml or yaml-like) to be able to create novel use-cases. So the next generation mechanism can also
be used to model settings and use references to share settings/preferences. It's basically something like a simple,
non-indexed, in-memory graph database for modeling relationships that do not require much complexity such that a
real graph solution is warranted; however, the problem at hand benefits from describing relationships first and
then lazily calculating some result following along the data relationships.

This newer code is in "vpd.next.graph".

As an additional utility basis, vpd.next.k8s provides utility mechanisms for Kubernetes. These are meant to ease
tasks managing state (via ConfigMaps) and secrets for python applications. These can be combined with the legacy
VirtualPathDict mechanisms as well as the vpd.next.graph mechanisms as part of maintaining complex applications
intended to operate in a Kubernetes context. Note that the official Kubernetes python client is required for Kubernetes
functionality.

More documentation to come...
tektoro-base-py 0.1.0
TekToroBase Python Framework - Multi-tenant SaaS framework with financial compliance features
Requires Python: >=3.10
Keywords: fastapi, multi-tenant, saas, framework, compliance, fintech

# TekToroBase Python Framework

Multi-tenant SaaS framework for Python applications with financial compliance features.

## Features

- **Multi-tenant Architecture**: Schema-per-tenant isolation with PostgreSQL
- **Financial Compliance**: Built-in audit logging, SOX/PCI DSS/GDPR support  
- **FastAPI Integration**: Modern async web framework
- **SQLAlchemy Models**: Comprehensive data models for business applications
- **Alembic Migrations**: Database schema management
- **Security First**: JWT authentication, secure configuration management

## Database Setup

### 1. Start Local PostgreSQL

```bash
# Start PostgreSQL with Docker
npm run db:start

# Check database health
npm run db:health
```

### 2. Initialize Database

```bash
# Run initial migrations
npm run db:init

# Create a new migration
npm run db:create-migration "Add new feature"
```

### 3. Multi-Tenant Management

```bash
# Create tenant schema
npm run db:create-tenant demo

# List all tenants
npm run db:list-tenants
```

### Database URLs

- **PostgreSQL**: `localhost:5432` (tektoro_user/tektoro_pass)
- **Redis**: `localhost:6379`
- **pgAdmin**: `http://localhost:8080` (admin@tektoro.com/admin123)

## Development

### Installation

```bash
# Install with uv
uv sync

# Install in development mode
pip install -e .
```

### Testing

```bash
# Run tests with coverage
npm run test:coverage

# Watch mode
npm run test:watch
```

### Quality

```bash
# Run all quality checks
npm run quality

# Format code
npm run format

# Lint code
npm run lint
```

## Models

### Shared Schema (Cross-tenant)
- **auth.py**: Users, Roles, Permissions, Tenants
- **audit.py**: Audit logs, compliance tracking

### Tenant Schema (Per-tenant)
- **business.py**: Organizations, contacts
- **documents.py**: File management
- **communication.py**: Notifications, messaging

## Configuration

### Environment Variables

```bash
DATABASE_URL=postgresql+asyncpg://tektoro_user:tektoro_pass@localhost:5432/tektoro_base
REDIS_URL=redis://localhost:6379/0
JWT_SECRET_KEY=your-secret-key
```

### GitHub Secrets (Production)

Required secrets for deployment:
- `DATABASE_URL`
- `JWT_SECRET_KEY` 
- `REDIS_URL`

## Architecture

```
┌─── Shared Schema ────┐    ┌─── Tenant Schemas ───┐
│ • Users             │    │ • Organizations      │
│ • Roles             │    │ • Documents          │ 
│ • Permissions       │    │ • Communications     │
│ • Audit Logs        │    │ • Business Data      │
└─────────────────────┘    └──────────────────────┘
```

## License

MIT License - see LICENSE file for details.
goaly-mcp 0.0.0
Goaly MCP - Goal and Task Management with Model Context Protocol
Requires Python: >=3.12
Keywords: agent, ai, claude, fastmcp, goals, goaly, llm, mcp, model-context-protocol, task-management, toolprint

# Goaly MCP

A goal and task management system with Model Context Protocol (MCP) integration and a real-time dashboard.

## Features

- **Goal & Task Management**: Create goals with tasks stored in a DAG
- **MCP Integration**: FastMCP 2.0 server for AI agent interaction
- **Real-time Dashboard**: React-based dashboard with live updates via SSE
- **Task Dependencies**: Manage complex task relationships and blocking dependencies
- **RESTful API**: Complete FastAPI-based REST API
- **Database Migrations**: Alembic-powered database versioning
- **Production Ready**: Docker support, monitoring, and deployment tools

## Quick Start

### Prerequisites

- Python 3.12+
- Node.js 18+
- pnpm (for frontend)

### Installation

```bash
# Complete setup
just setup

# Start development
just serve

# View dashboard
open http://localhost:8000/dashboard
```

### API Documentation

- **Dashboard**: http://localhost:8000/dashboard
- **API Docs**: http://localhost:8000/docs
- **MCP Server**: http://localhost:8000/mcp

## Development

```bash
# Install dependencies
just install

# Run tests
just test

# Format & lint
just fmt && just lint

# Build for production
just build-all
```

## Architecture

- **Backend**: FastAPI + SQLAlchemy + Alembic
- **Frontend**: React + Material-UI + D3.js
- **Database**: PostgreSQL (production) / SQLite (development)
- **MCP Server**: FastMCP 2.0 for AI agent integration
- **Real-time**: Server-Sent Events (SSE)

## 🤝 Contributing

Found a bug? Have an idea? We'd love your help!

- 🐛 [Report issues](https://github.com/toolprint/goaly-mcp/issues)
- 💡 [Share ideas](https://github.com/toolprint/goaly-mcp/discussions)
- 🔧 [Submit PRs](https://github.com/toolprint/goaly-mcp/pulls)

## 📄 License

MIT License - see [LICENSE](LICENSE) file for details.

______________________________________________________________________

<div align="center">

**Built by developers who got tired of watching AI pick the wrong tools** 🎯

<a href="https://toolprint.ai">
  <img src="./assets/toolprint.png" alt="Toolprint" width="200">
</a>

<p>
  <strong>Built with ❤️ by <a href="https://toolprint.ai">Toolprint</a></strong><br>
  <sub>© 2025 OneGrep, Inc.</sub>
</p>

</div>
ca2roi 0.1.3
Calcium imaging automatic ROI selection and analysis tool
Requires Python: >=3.10

# MiV-Ca2 Intensity Analysis Toolbox

A CLI tool for calcium imaging video post-processing: bleaching analysis, ROI selection, and trace extraction.

The package is developed to provide light-weight and easy-to-use tools for calcium imaging video analysis.
Data can be saved in csv format for further analysis.
(Please note in [issue](https://github.com/skim0119/CA2-Sandbox/issues) if you have desired format other than csv).

<!-- https://github.com/skim0119/Ca2-Sandbox/blob/main/assets-readme/v051.png -->
![MiV-Ca2 Intensity Analysis Toolbox](https://github.com/skim0119/Ca2-Sandbox/blob/main/assets-readme/v051.png?raw=true)

## Easy installation

`pip install ca2roi`

> Recommend `python3.10+`.

## Easy launch

`ca2roi-gui`

## CLI usage (for batch processing)

```
ca2roi <video_path> [--workspace <output_folder>]
```

- `video_path`: Path to the calcium imaging video (e.g., AVI file)
- `--workspace`: Output directory (default: `result`)

The tool will:
- Compute and save bleaching info
- Compute and overlay fluctuation map
- Allow interactive ROI selection (or load existing ROIs)
- Save ROI traces, ROI images, and ROI locations

## Python-package ca2roi

```py
import ca2roi
```

## Project Structure

Project uses `Python3` as a main backend language. It uses `FastAPI` to connect frontend and backend.
Frontend is developed with `Vue3` and `TypeScript`.

The tool is not yet supported to be launched in a server.

All the core source code is in `src` folder.

- `ca2roi`: `Python` package for analysis functions.
- `frontend`: `Vue3` frontend for GUI development
- `commands`: CLI command scripts, written with `Python` with `click`.

## Contribution / Development

`Makefile` includes useful commands for development.

## Support

This project is mainly developed by [@skim0119](https://github.com/skim0119) as part of the support for [Mind-in-vitro project](https://mattia-lab.com/).
langchain-llama-stack 0.2.1
An integration package connecting Llama Stack and LangChain
Requires Python: >=3.12

# langchain-llama-stack

This package contains the LangChain integration with [Llama Stack](https://github.com/meta-llama/llama-stack).

## Installation

```bash
pip install -U langchain-llama-stack
```

If your Llama Stack distribution requires credentials, use the `LLAMA_STACK_API_KEY` environment variable.

If your Llama Stack distribution server is not running on `http://localhost:8321`, use the `LLAMA_STACK_BASE_URL` environment variable or `base_url` param.

## Chat Models

`ChatLlamaStack` class exposes chat models hosted on your Llama Stack distribution server.

```python
from langchain_llama_stack import ChatLlamaStack

llm = ChatLlamaStack(model="meta/llama-3.1-8b-instruct")
llm.invoke("Sing a ballad of LangChain.")
```
sat-download 1.0.0
A Python package for satellite imaginery download.
Requires Python: >=3.11

# Remote Sensing Satellite Downloader

This project provides tools for searching and downloading satellite imagery from various providers, such as Copernicus Data Space and USGS Earth Explorer. It includes a modular architecture with APIs, data types, and services to streamline satellite data retrieval.

## Features

- Search and download satellite imagery from multiple providers.
- Modular architecture for easy integration and extension.
- Support for various satellite data formats and APIs.

## Installation

To install the package, you can use one of the following methods:

### Clone the Repository and Install with `pip`

```bash
git clone https://github.com/Aouei/remote-sensing-satellite-downloader.git
cd remote-sensing-satellite-downloader
pip install .
```

### Install directly from git
```bash
pip install git+https://github.com/Aouei/remote-sensing-satellite-downloader.git
```