semvec/pypi-packages huggingface dataset:
libdkit 25.3.5
Data Processing Toolkit
Requires Python: >=3.11

DKit (Data Toolkit) 
==================

Data processing toolkit.  General purpose data
processing library in Python:

* ETL
  - maintain schemas
  - schema transforms
  - transform from one format to the other
  - support many different formats (see below)
* Data Exploration
* Data manipulation
* Report generation using Latex and Reportlab
* Extensive test coverage (>70%)

# Data formats
Include extensions that facilitate reading data, 
transforming it and then and writing to any of the 
following formats:

* Parquet (using pyarrow)
* SQL (using any SQLAlchemy enabled database)
* Messagepack
* HDF5
* XML
* json and jsonl
* CSV
* Excel
* Apache Avro

# Schema Generation 
Support schema generation for the following:

* Apache Arrow
* Apache Avro
* SQL (via Sqlalchemy)
* Spark
mcp-server-sqlite-cn 2025.1.14
A simple SQLite MCP server
Requires Python: >=3.10.2

# SQLite MCP 服务器

## 概述
这是一个基于 SQLite 的模型上下文协议(MCP)服务器实现,提供数据库交互和商业智能功能。该服务器支持运行 SQL 查询、分析业务数据以及自动生成业务洞察备忘录。

## 组件

### 资源
服务器提供一个动态资源:
- `memo://insights`: 持续更新的业务洞察备忘录,用于汇总分析过程中发现的见解
  - 通过 append-insight 工具发现新见解时自动更新

### 提示
服务器提供一个演示提示:
- `mcp-demo`: 交互式提示,引导用户完成数据库操作
  - 必需参数: `topic` - 要分析的业务领域
  - 生成适当的数据库模式和示例数据
  - 引导用户完成分析和见解生成
  - 与业务洞察备忘录集成

### 工具
服务器提供六个核心工具:

#### 查询工具
- `read_query`
   - 执行 SELECT 查询以从数据库读取数据
   - 输入:
     - `query` (字符串): 要执行的 SELECT SQL 查询
   - 返回: 查询结果对象数组

- `write_query`
   - 执行 INSERT、UPDATE 或 DELETE 查询
   - 输入:
     - `query` (字符串): SQL 修改查询
   - 返回: `{ affected_rows: number }`

- `create_table`
   - 在数据库中创建新表
   - 输入:
     - `query` (字符串): CREATE TABLE SQL 语句
   - 返回: 表创建确认

#### 模式工具
- `list_tables`
   - 获取数据库中所有表的列表
   - 无需输入
   - 返回: 表名数组

- `describe-table`
   - 查看特定表的模式信息
   - 输入:
     - `table_name` (字符串): 要描述的表名
   - 返回: 包含列名和类型的列定义数组

#### 分析工具
- `append_insight`
   - 向备忘录资源添加新的业务见解
   - 输入:
     - `insight` (字符串): 从数据分析中发现的业务见解
   - 返回: 见解添加确认
   - 触发 memo://insights 资源的更新


## 在 Claude Desktop 中使用

### uv

```bash
# 在 claude_desktop_config.json 中添加服务器
"mcpServers": {
  "sqlite": {
    "command": "uv",
    "args": [
      "--directory",
      "parent_of_servers_repo/servers/src/sqlite",
      "run",
      "mcp-server-sqlite-cn",
      "--db-path",
      "~/test.db"
    ]
  }
}
```

### Docker

```json
# 在 claude_desktop_config.json 中添加服务器
"mcpServers": {
  "sqlite": {
    "command": "docker",
    "args": [
      "run",
      "--rm",
      "-i",
      "-v",
      "mcp-test:/mcp",
      "mcp/sqlite",
      "--db-path",
      "/mcp/test.db"
    ]
  }
}
```

## 构建

Docker:

```bash
docker build -t mcp/sqlite .
```

## 许可证

本 MCP 服务器采用 MIT 许可证。这意味着您可以自由使用、修改和分发本软件,但需遵守 MIT 许可证的条款和条件。详情请参阅项目仓库中的 LICENSE 文件。
python-scciclient 0.17.0
Python ServerView Common Command Interface (SCCI) Client Library
Requires Python: >=3.8

===============================
python-scciclient
===============================

Python ServerView Common Command Interface (SCCI) Client Library

* Free software: Apache license

Features
--------

* support ServerView Common Command Interface (SCCI) for
  FUJITSU iRMC S4/S5 -  integrated Remote Management Controller
vul_py_utils 0.0.8.dev2
The package contains common utilities for Python projects at Vulcan Labs.
Requires Python: <4.0,>=3.11

vul-py is a general-purpose library of utilities and extensions to the standard library. It provides common functionality such as: redis, file I/O, image processing, and more. It is compatible with Python ^3.11.

To use package, please follow this repo: [vulcanlabsvn/vul-py: vul-py ](https://github.com/vulcanlabsvn/vul-py)

# Change Log

### 0.0.8.dev2 - 26/02/2024
ADD:
* exceptions.handle_common_error
* exceptions.map_error2exception
* exceptions.to_common_error_response

UPDATE:
* VulcanBaseException: add gRpc field

### 0.0.7 - 27/02/2024

Add:

* response_error and response_data
* VulcanBaseError
* VulcanBaseException

### ~~0.0.6 - 27/02/2024 - Deprecated~~

### 0.0.5 - 03/01/2024

Deprecated:

* Remove torch dependencies
* Remove JsonHandlerWithGpu and host_health_check
call-center-tools 1.0.0
Tools for call center staffing calculations
Requires Python: >=3.8

# call-center-tools

Package contains essential tools for call center staffing calculations.

Package installation:
```shell
pip install call_center_tools
```

Let's try to calculate number of agents for call center with average of 1000 calls per hour.
Average duration of call is 120 sec. Agents should be occupied max 85% of time. 
80% of calls should be answered in 20 sec.

```python
from call_center_tools import calc_staffing

result = calc_staffing(
    calls_per_hour=1000,
    aht=120,
    max_occupancy=0.85,
    target_answer_time=20,
    target_service_level=0.8,
    shrinkage=0.3
)
```
Result:
```text
Inputs:
  Calls per hour:           1000
  Average handling time:    120 sec
  Shrinkage:                30.0 %
  Max occupancy             85.0 %
  Target answer time        20 sec
  Target service level      80.0 %

Outputs:
  Traffic intensity:        33.333 Erlangs
  Waiting probability:      19.07 %
  Immediate answer:         80.93 %
  Service level:            93.72 %
  Average speed of answer:  3.43 sec
  Occupancy:                83.33 %
  Agents:                   40
  Agents + shrinkage:       58
```
So recommended number of agents for such call center is `40`, not counting shrinkage.

Let's imagine we have only `35` agents, not recommended `40`:

```python
from call_center_tools import calc_staffing

result = calc_staffing(
    calls_per_hour=1000,
    aht=120,
    agents=35,
    max_occupancy=0.85,
    target_answer_time=20,
    target_service_level=0.8,
    shrinkage=0.3
)
```
Result:
```text
Inputs:
  Calls per hour:           1000
  Average handling time:    120 sec
  Available agents:         35
  Shrinkage:                30.0 %
  Max occupancy             85.0 %
  Target answer time        20 sec
  Target service level      80.0 %

Outputs:
  Traffic intensity:        33.333 Erlang
  Waiting probability:      69.65 %
  Immediate answer:         30.35 %
  Service level:            47.24 %
  Average speed of answer:  50.15 sec
  Occupancy:                95.24 %
  Agents + shrinkage:       50
```

Try to use `example.py` to test your own parameters.

You can also find method for Erlang C and Erlang B calculations:
```python
from call_center_tools import erlang_c, erlang_b
```
compyr 0.0.3
Testing framework for porting R functions over to Python
Requires Python: <4.0,>=3.9
Keywords: python

# compyr

[![Release](https://img.shields.io/github/v/release/apsocarras/compyr)](https://img.shields.io/github/v/release/apsocarras/compyr)
[![Build status](https://img.shields.io/github/actions/workflow/status/apsocarras/compyr/main.yml?branch=main)](https://github.com/apsocarras/compyr/actions/workflows/main.yml?query=branch%3Amain)
[![codecov](https://codecov.io/gh/apsocarras/compyr/branch/main/graph/badge.svg)](https://codecov.io/gh/apsocarras/compyr)
[![Commit activity](https://img.shields.io/github/commit-activity/m/apsocarras/compyr)](https://img.shields.io/github/commit-activity/m/apsocarras/compyr)
[![License](https://img.shields.io/github/license/apsocarras/compyr)](https://img.shields.io/github/license/apsocarras/compyr)

Testing framework for porting R functions over to Python

- **Github repository**: <https://github.com/apsocarras/compyr/>
- **Documentation** <https://apsocarras.github.io/compyr/>

## Getting started with your project

### 1. Create a New Repository

First, create a repository on GitHub with the same name as this project, and then run the following commands:

```bash
git init -b main
git add .
git commit -m "init commit"
git remote add origin git@github.com:apsocarras/compyr.git
git push -u origin main
```

### 2. Set Up Your Development Environment

Then, install the environment and the pre-commit hooks with

```bash
make install
```

This will also generate your `uv.lock` file

### 3. Run the pre-commit hooks

Initially, the CI/CD pipeline might be failing due to formatting issues. To resolve those run:

```bash
uv run pre-commit run -a
```

### 4. Commit the changes

Lastly, commit the changes made by the two steps above to your repository.

```bash
git add .
git commit -m 'Fix formatting issues'
git push origin main
```

You are now ready to start development on your project!
The CI/CD pipeline will be triggered when you open a pull request, merge to main, or when you create a new release.

To finalize the set-up for publishing to PyPI, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/publishing/#set-up-for-pypi).
For activating the automatic documentation with MkDocs, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/mkdocs/#enabling-the-documentation-on-github).
To enable the code coverage reports, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/codecov/).

## Releasing a new version

- Create an API Token on [PyPI](https://pypi.org/).
- Add the API Token to your projects secrets with the name `PYPI_TOKEN` by visiting [this page](https://github.com/apsocarras/compyr/settings/secrets/actions/new).
- Create a [new release](https://github.com/apsocarras/compyr/releases/new) on Github.
- Create a new tag in the form `*.*.*`.

For more details, see [here](https://fpgmaas.github.io/cookiecutter-uv/features/cicd/#how-to-trigger-a-release).

---

Repository initiated with [fpgmaas/cookiecutter-uv](https://github.com/fpgmaas/cookiecutter-uv).
mineru-app 0.0.6
A PDF processing and conversion tool
Requires Python: >=3.10

## Installation


```bash
pip install mineru_app
```

or using docker 

```bash
docker pull registry.cn-hangzhou.aliyuncs.com/data_proc/mineru_app:v0.0.6
```

## Start

```bash
export MINERU_API_KEY=your_api_key
mineru_app
```

or using docker

```bash
docker run -d -p 7860:7860 -e MINERU_API_KEY=your_api_key registry.cn-hangzhou.aliyuncs.com/data_proc/mineru_app:v0.0.6
```


## Use Gradio App

Access http://127.0.0.1:7860 in your web browser
RFC-Draw 2.26
Makes svg, ascii and xml diagrams for IETF RFCs
Requires Python: >=3.6
Keywords: SVG, IETF, RFC

## RFC-Draw
### A simple drawing package to make SVG and ASCII-art diagrams for RFCs 

RFC-draw is a python tkinter-based drawing system, with three components: 

* _rfc-draw.py_ - interactive drawing program to create on-screen diagrams,   
   &emsp; and save them to rfc-draw-data (.rdd) files  

* _rdd-to-svg.py_ - creates a drawing's SVG file that conforms to the RFC7996 SVG schema  

* _rdd-to-ascii.py_ - creates a drawing's ASCII-art (.txt) file  

rfc-draw.py let's you draw (with your mouse) three kinds of objects, 
in three layers, with restrictions to allow for ASCII-art:  

1. Lines  
   &emsp; Lines have one or more segments; 
   each segment must be either horizontal or vertical. 
 
2. Rectangles  
   &emsp; Rectangles may have line(s) of text at their centre.  
 
3. Text  
   &emsp; A text object has one or more (centred) lines of text.  

To use rfc-draw you'll need to install the following python modules:  
&emsp; tkinter, math, sys, re, os, svgwrite, traceback (for POSIX and windows)  
&emsp; termios (for POSIX) or msvcrt (for Windows)  

To install a python module, e.g. tkinter, the (POSIX) command is  
&emsp;&emsp; pip3 install tkinter  
  
If that doesn't work, you may need to use a more up-to-date version of pip,  
i.e. one that matches your version of python, for example pip3.10
SpatialAccessibility 0.0.13
A Spatial Accessibility Calculation package
Requires Python: >=3.8

# [SpatialAccessibility Lib](https://github.com/wsqstar/SpatialAccessibility)

![PyPI - Version](https://img.shields.io/pypi/v/SpatialAccessibility)

This is a library for spatial accessibility analysis in Python， hosted on https://github.com/wsqstar/SpatialAccessibility .
> Inspried by the work of Prof.Fahui Wang and Dr.Lingbo Liu, DOI: 10.1201/9781003292302-14

## Installation
To install the library, you can use pip:

```
# We recommend to use the pypi index url to install the library
!pip install SpatialAccessibility --index-url https://pypi.org/simple

```
or if you ara using Colab:

```
!pip install hatchling==1.26.3 build twine
!pip install git+https://github.com/wsqstar/SpatialAccessibility.git

```

## Usage
To use the library, you need to have a od matrix of the study area. You can then use the following code to calculate the spatial accessibility:
```python
from SpatialAccessibility import calculate_accessibility
# @title 示例调用
import pandas as pd
Data_df = pd.read_csv("datasets/Data.csv")

Data_df.rename(columns={'O_Popu': 'O_Demand'}, inplace=True)
Current_Accessibility, summary_accessibility = calculate_accessibility(Data_df,print_out=False)

# Load the dataframe
```
weightgain 1.0.0
Train an adapter for any embedding model in <1min
Requires Python: >=3.12

# weightgain

**Fine-tune _any_ embedding model in under a minute. Even models from OpenAI, Cohere, Voyage, etc.**

It works by training an adapter that sits _on top_ of the model, instead of modifying the model itself. This adapter transforms your embeddings after they're generated to boost retrieval accuracy and overall RAG performance.

Weightgain lets you train an adapter in just a couple lines of code, even if you don't have a dataset.

## Installation

```bash
> pip install weightgain
```

## Quickstart

```python
from weightgain import Dataset, Adapter

# Generate a dataset (or supply your own)
dataset = Dataset.from_synthetic_chunks(
    prompt="Chunks of code from an arbitrary Python codebase.",
    llm="openai/gpt-4o-mini",
)

# Train the adapter
adapter = Adapter("openai/text-embedding-3-large")
adapter.fit(dataset)

# Apply the adapter
new_embeddings = adapter.transform(old_embeddings)
```

## Usage

### Choosing an Embedding Model

Weightgain wraps LiteLLM to provide access to models. You can fine-tune models from OpenAI, Cohere, Voyage, and more. [Here's](https://docs.litellm.ai/docs/embedding/supported_embedding) the full list of supported models.

<!--TODO: You can also define your own-->

### Building the Dataset

You need a dataset of `[query, chunk]` pairs to get started. A chunk is a retrieval result, e.g. a code snippet or excerpt from a document. You can either generate a synthetic dataset or supply your own.

**If you already have chunks:**

```python
from weightgain import Dataset

chunks = [...] # list of strings
dataset = Dataset.from_chunks(
    chunks,
    llm="openai/gpt-4o-mini",
    n_queries_per_chunk=1
)
```

This will use `gpt-4o-mini` (or whatever LiteLLM model you want) to generate `1` query per chunk.

**If you don't have chunks:**

```python
dataset = Dataset.from_synthetic_chunks(
    prompt="Chunks of code from an arbitrary Python codebase.",
    llm="openai/gpt-4o-mini",
    n_chunks=25,
    n_queries_per_chunk=1
)
```

This will generate chunks using the prompt, and then generate `1` query per chunk.

**If you have queries and chunks:**

```python
qa_pairs = [...] # list of (str, str) tuples
dataset = Dataset.from_pairs(qa_pairs, model)
```

### Training the Adapter

```python
from weightgain import Adapter

adapter = Adapter.fit(
    dataset,
    batch_size=25,
    max_epochs=50,
    learning_rate=100.0,
    dropout=0.0
)
```

After training, you can generate a report with various plots (training loss, cosine similarity distributions before/after training, etc.):

```python
adapter.show_report()
```

![Example report](./report.png)

### Using the Adapter

```python
old_embeddings = [...] # list of vectors
new_embeddings = adapter.transform(old_embeddings)
```

Behind the scenes, an adapter is just a matrix of weights that you can multiply your embeddings with. You can access this matrix like so:

```python
adapter.matrix # returns numpy.ndarray
```

## Roadmap

1. Add option to train an MLP instead of a linear layer
2. Add a method for easy hyperparameter search