semvec/pypi-packages huggingface dataset:
calc-app 1.0.0
A mathematical calculator server using Model Context Protocol (MCP)
Requires Python: >=3.8

# MCP Calculator

A mathematical calculator server implemented using the Model Context Protocol (MCP).

## Features

- Basic arithmetic operations (add, subtract, multiply, divide)
- Power and square root calculations
- Factorial calculation
- HTTP and stdio transport support
- Easy-to-use MCP interface

## Installation

```bash
pip install mcp-calculator
```

## Usage

### As a Server

Start the calculator server:

```bash
python -m mcp_calculator
```

### As a Library

```python
from mcp_calculator import add, subtract, multiply, divide, power, sqrt, factorial

# Basic arithmetic
result = add(5, 3)      # Returns 8
result = subtract(10, 4) # Returns 6
result = multiply(6, 7)  # Returns 42
result = divide(15, 3)   # Returns 5.0

# Advanced operations
result = power(2, 3)    # Returns 8
result = sqrt(16)       # Returns 4.0
result = factorial(5)    # Returns 120
```

## API Reference

### Available Functions

- `add(a: int, b: int) -> int`: Add two numbers
- `subtract(a: int, b: int) -> int`: Subtract two numbers
- `multiply(a: int, b: int) -> int`: Multiply two numbers
- `divide(a: int, b: int) -> float`: Divide two numbers
- `power(a: int, b: int) -> int`: Calculate power of a number
- `sqrt(a: int) -> float`: Calculate square root of a number
- `factorial(a: int) -> int`: Calculate factorial of a number

## Development

1. Clone the repository
2. Install dependencies: `pip install -e .`
3. Run tests: `python test_calculator.py`

## License

MIT License
compas-cgal 0.9.1
CGAL wrapper for COMPAS.
Requires Python: >=3.9

# COMPAS CGAL

![build](https://github.com/compas-dev/compas_cgal/workflows/build/badge.svg)
[![GitHub - License](https://img.shields.io/github/license/compas-dev/compas_cgal.svg)](https://github.com/compas-dev/compas_cgal)
[![Conda - Latest Release](https://anaconda.org/conda-forge/compas_cgal/badges/version.svg)](https://anaconda.org/conda-forge/compas_cgal)
[![Conda - Platform](https://img.shields.io/conda/pn/conda-forge/compas_cgal)](https://anaconda.org/conda-forge/compas_cgal)

This package provides Python bindings for specific algorithms of CGAL.
The bindings are generated with Nanobind and data is exchanged using NumPy arrays.

More information of installation, api and other details please follow documentation:
<https://compas.dev/compas_cgal/>

## Usage

The provided functionality can be used directly from the `compas_cgal` package
or from `compas.geometry` through the plugin mechanism in COMPAS.

For examples, see <https://compas.dev/compas_cgal/latest/examples.html>.

## License

`compas_cgal` is released under the LGPL 3.0 to be compatible with the license of CGAL.
pangaeapy 1.1.0
Download and analyse (meta-)data of PANGAEA datasets
Requires Python: >=3.10

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4013941.svg)](https://doi.org/10.5281/zenodo.4013941)

# pangaeapy - a Python module to access and analyse PANGAEA data

## Background

![pangaea](https://pangaea.de/assets/v.0163d8ce3a8d13294b065fcbdc04aebc/layout-images/pangaea-logo.png)

PANGAEA ([https://www.pangaea.de](https://www.pangaea.de)) is one of the world's largest archives of this kind offering essential data services such as data curation, long-term data archiving and data publication. PANGAEA hosts about 400,000 datasets comprising around 17.5 billion individual measurements (Aug. 2020) and observations which have been collected during more than 240 international research projects. The system is open to any project, institution or individual scientist using, archiving or publishing research data.

Since the programming languages Python and R have become increasingly important for scientific data analysis in recent years, we have developed 'pangaeapy'  a new, custom Python module that considerably simplifies typical data science tasks.

Given a DOI, pangaeapy uses PANGAEA’s web services to automatically load PANGAEA metadata into a dedicated python object and tabular data into a Python Data Analysis Library (pandas) DataFrame with a mere call of a specialized function. This makes it possible to integrate PANGAEA data with data from a large number of sources and formats (Excel, NetCDF, etc.) and to carry out data analyses within a suitable computational environment such as Jupyter notebooks in a uniform manner.

## Installation

* Source code from [GitHub](https://github.com/pangaea-data-publisher/pangaeapy)
    * `pip install git+https://github.com/pangaea-data-publisher/pangaeapy.git`
* Wheels for Python from [PyPI](https://pypi.org/project/pangaeapy/)
    * `pip install pangaeapy`



## Usage

```python
import pangaeapy.pandataset as pd

ds = pd.PanDataSet(787140)
print(ds.title)
print(ds.data.head())
```

## Examples
Please take a look at the example Jupyter Notebooks which you can find in the 'examples' folder

## Documentation

[https://pangaea-data-publisher.github.io/pangaeapy/](https://pangaea-data-publisher.github.io/pangaeapy/)

## Running the tests

The tests ar located in the `test` directory. You can run them by executing
`pytest` or `tox` in the root directory.

## Cite as
Robert Huber, Egor Gordeev, Markus Stocker, Aarthi Balamurugan, & Uwe Schindler (2020). pangaeapy - a Python module to access and analyse PANGAEA data. Zenodo. [http://doi.org/10.5281/zenodo.4013940](http://doi.org/10.5281/zenodo.4013940).

[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4013940.svg)](https://doi.org/10.5281/zenodo.4013940.)
latch-curate 0.2.4
Tools for curating single cell data
Requires Python: >=3.10

latch-curate
===

## Quickstart

Create on directory for each curation project/dataset and run the following
commands in this project directory.

```
latch-curate download run <gse-id>
latch-curate construct-counts run
latch-curate qc run
latch-curate transform run
latch-curate type-cells run
latch-curate harmonize-metadata run
```
meu-investimento-ferrufato 0.2
Uma biblioteca para cálculos de investimentos.
Requires Python: >=3.6

# Meu Investimento 🚀

Uma biblioteca Python simples e eficiente para cálculos de finanças pessoais, com funções para:

- Retorno de investimento (%)
- Juros compostos
- Conversão de taxa anual para mensal
- Cálculo do CAGR (Taxa de crescimento anual composta)

---

## 📦 Instalação

Instale diretamente do PyPI:

```bash
pip install meu_investimento

Ou instale localmente (durante o desenvolvimento):


pip install dist/meu_investimento-0.1-py3-none-any.whl


from investimentos import (
    calcular_retorno_investimento,
    calcular_juros_compostos,
    converter_taxa_anual_para_mensal,
    calcular_cagr
)

valor_inicial = 1000
valor_final = 1500
anos = 5
taxa_anual = 12

print(f"Retorno: {calcular_retorno_investimento(valor_inicial, valor_final):.2f}%")
print(f"Juros compostos: R${calcular_juros_compostos(valor_inicial, 6, anos):.2f}")
print(f"Taxa mensal equivalente: {converter_taxa_anual_para_mensal(taxa_anual)*100:.4f}%")
print(f"CAGR: {calcular_cagr(valor_inicial, valor_final, anos):.2f}%")


Funcionalidades

calcular_retorno_investimento(valor_inicial, valor_final) → Retorno em %

calcular_juros_compostos(principal, taxa_juros_anual, periodos) → Valor acumulado

converter_taxa_anual_para_mensal(taxa_anual) → Taxa mensal efetiva

calcular_cagr(valor_inicial, valor_final, anos) → CAGR em %

Público-alvo
Ideal para:

Estudantes aprendendo matemática financeira

Desenvolvedores que precisam de cálculos financeiros simples

Qualquer pessoa que deseje automatizar análises básicas de investimentos

Requisitos
Python 3.6 ou superior

Nenhuma dependência adicional (somente biblioteca padrão)


Licença
Este projeto está licenciado sob a MIT License. Veja o arquivo LICENSE para mais detalhes.






```
reproscreener 2.0.0
Automated reproducibility evaluation of research
Requires Python: >=3.13

<div align="center" id="top"> 
  <img src="./.github/reproscreener.png" alt="" />
</div>

<h1 align="center">reproscreener</h1>

<p align="center">
  <img alt="GitHub Workflow Status (with branch)" src="https://github.com/Machine-Learning-Pipelines/reproscreener/actions/workflows/ci.yml/badge.svg?branch=main">
    <img alt="GitHub deployments" src="https://img.shields.io/github/deployments/Machine-Learning-Pipelines/reproscreener/github-pages?label=build docs">
  <img alt="Codecov" src="https://codecov.io/gh/Machine-Learning-Pipelines/reproscreener/branch/main/graph/badge.svg?token=DWBDDAERY4">
  <img alt="PyPI" src="https://img.shields.io/pypi/v/reproscreener">
  <img alt="License" src="https://img.shields.io/github/license/Machine-Learning-Pipelines/reproscreener">

</p>

`reproscreener` is a tool designed to evaluate the reproducibility of papers and code to enhance trustworthy machine learning research. Please see the [project website](https://reproscreener.com/) for more information.

### License

Distributed under the MIT License. See `LICENSE.txt` for more information.

### Funding

We thank the The Center for Research and Education in AI and Learning (REAL@USC) for their funding and support towards this project.
Any opinions, findings, and conclusions or recommendations expressed in this material are those of the author(s) and do not necessarily reflect the views of the The Center for Research and Education in AI and Learning (REAL@USC).

---

This material is based upon work supported by the National Science Foundation under Grant No. OAC 2138773

---
db4e-systemd 1.2.2
A lightweight systemctl wrapper for Python
Requires Python: >=3.7

# Introduction

A lightweight Python module to interact with `systemd` services via `systemctl`, designed for use in Python-based service managers, admin tools, and dashboards.

---

# Features

* Query service status, PID, and enablement
* Start, stop, and restart services
* Enable and disable services
* Structured output, clean API
* Parses and interprets `systemctl` output

**IMPORTANT NOTE:** All `systemctl` operations except for `sysemctl status` require root access. This module uses `sudo` to deal with this fact. It's recommended that you use a fine-grained sudo configuration. For example, the following two lines in the `/etc/sudoers` file allow the *sally* user to start and stop the *db4e* services. 

```
sally ALL=(ALL) NOPASSWD: /bin/systemctl start db4e
sally ALL=(ALL) NOPASSWD: /bin/systemctl stop db4e
```

So a script that *sally* runs that uses this module will be successful in starting and stopping the *db4e* service, but will fail if `enable()` or `disable()` are attempted.

---

# Installation

```bash
pip install db4e-systemd
```

Or clone locally:

```bash
git clone https://github.com/NadimGhaznavi/db4esystemd.git
cd db4e-systemd
```

---

# Example Usage

```python
from Db4eSystemd.Db4eSystemd import Db4eSystemd

svc = Db4eSystemd('db4e')

if not svc.installed():
    print("Service not installed")
elif not svc.active():
    print("Service is stopped. Starting...")
    svc.start()
else:
    print(f"Service is running with PID {svc.pid()}")
```

---

# Methods

```python
svc = Db4eSystemd('myservice')

svc.start()          # Start service
svc.stop()           # Stop service
svc.restart()        # Restart service
svc.enable()         # Enable service startup at boot time
svc.disable()        # Disable service startup at boot time
svc.status()         # Refresh status
svc.active()         # True/False
svc.enabled()        # True/False
svc.installed()      # True/False
svc.pid()            # Integer PID or None
svc.stdout()         # Raw systemctl stdout
svc.stderr()         # Raw systemctl stderr
```

---

# License

GPL v3 - See LICENSE.txt

---

Created and maintained by Nadim-Daniel Ghaznavi. Part of the [Database 4 Everything](https://github.com/NadimGhaznavi/db4e) project.
fdock-cli 2.5.6
Un outil CLI puissant pour initialiser et gérer vos projets Python avec style !
Requires Python: >=3.10
Keywords: cli, development, initialization, project, python, tools

# 🚀 fdock_cli

Un outil CLI puissant pour initialiser et gérer vos projets Python avec style ! 

## 🎯 Fonctionnalités

- **Initialisation rapide** de projets Python avec structure complète
- **Gestion d'environnements virtuels** simplifiée
- **Interface interactive** avec menu coloré
- **Scripts bash intégrés** pour automatiser vos tâches

## 📦 Installation

```bash
pip install fdock_cli
```

## 🚀 Utilisation

Après installation, lancez l'installation des scripts :

```bash
python -m fdock_cli.install
```

Puis redémarrez votre terminal et utilisez :

```bash
# Initialiser un nouveau projet
fdock root

# Afficher les informations du projet
fdock hello
```

## 🎨 Fonctionnalités du menu

1. **Créer un environnement virtuel** (.venv) et l'activer
2. **Créer un fichier .env** pour vos variables d'environnement  
3. **Les deux !** (environnement + .env avec activation)
4. **Activer uniquement** le .venv existant
5. **🧹 Nettoyer le projet** (supprimer les fichiers générés)
6. **Je suis juste de passage** 🚶

## 📁 Structure générée

```
votre-projet/
├── src/
│   └── __init__.py
├── .gitignore
├── .dockerignore  
├── .dockerfile
├── .docker-compose.yml
├── pyproject.toml
├── README.md
└── .env
```

## 🎯 Pourquoi fdock_cli ?

- **Rapide** : Initialisez un projet en quelques secondes
- **Complet** : Tous les fichiers essentiels générés automatiquement
- **Interactif** : Menu coloré et intuitif
- **Flexible** : Choisissez exactement ce dont vous avez besoin

## 🛠️ Développement

```bash
git clone https://github.com/votre-repo/fdock_cli
cd fdock_cli
pip install -e .
```

## 📄 Licence

MIT License - Utilisez librement !

---

**Créé avec ❤️ pour simplifier la vie des développeurs Python !**
promediapaket 0.1.0
Tools for Managing PMP Files
Requires Python: >=3.9

# ProMediaPaket

ProMediaPaket (PMP) ist ein Dateiformatstandard und eine Bibliothek zur Verwaltung von Mediendateien. Es bietet eine einheitliche Möglichkeit, Video-, Audio- und Untertiteldateien in verschiedenen Sprachen zusammen mit Metadaten zu bündeln.

## Installation
```bash
pip install promediapaket
```

## Funktionen

### PMP-Dateien erstellen

Mit der `ProMediaPaket`-Klasse können Sie PMP-Dateien erstellen und verwalten:

```python
from promediapaket import ProMediaPaket

# Neue PMP-Datei erstellen
pmp = ProMediaPaket()

# Film-Metadaten festlegen
# provider ist die Quelle des Videos, z. B. zdf
# provider_id ist die Id des Videos welche die Quelle intern benutzt.
pmp.set_provider("provider", "provider_id")
pmp.set_titel("Film Titel")
pmp.add_video("pfad/zum/video.mp4")
pmp.add_audio("pfad/zur/de.mp3")
pmp.add_subtitle("pfad/zum/de.srt")
pmp.add_subtitle("pfad/zum/forced@de.srt")

# PMP-Datei speichern, nur Ordner angeben.
pmp.pack("/pafd/zur/ausgabe/")
```

### PMP-Dateien öffnen und abspielen

Zum Öffnen und Abspielen von PMP-Dateien können Sie den integrierten Player verwenden:

```bash
python player.py meine_datei.pmp
```

Der Player nutzt MPV zum Abspielen der Mediendateien mit den enthaltenen Audio- und Untertitelspuren.

### Informationen zu PMP-Dateien anzeigen

Um Informationen über eine PMP-Datei anzuzeigen:

```bash
python pmp_info.py meine_datei.pmp
```

### PMP-Dateien bearbeiten

Mit dem PMP-Tool können Sie bestehende PMP-Dateien bearbeiten:

```bash
python pmp_tool.py add audio meine_datei.pmp pfad/zur/neuen_audio.mp3
```

## PMP-Dateiformat

PMP-Dateien sind im Grunde umbenannte ZIP-Archive mit einer definierten Struktur. Details zum Format finden Sie in der [PROMEDIAPAKET.md](PROMEDIAPAKET.md) Dokumentation.

## Lizenz

Diese Software wird unter der MIT-Lizenz veröffentlicht.
distributed-logger 0.1.13
A lightweight logging system with Kafka support for auditing and debugging
Requires Python: >=3.9

# Distributed Logger

A lightweight logging system with Kafka support for auditing and debugging. Provides middleware for request auditing that can be used with any WSGI/ASGI framework.

## Features

- Request auditing middleware
- Support for multiple logging backends:
  - Kafka
  - Simple console logging
  - (More backends coming soon)
- Simple environment-based configuration
- Framework agnostic (works with Django, Flask, FastAPI, etc.)

## Installation

```bash
pip install distributed-logger
```

## Quick Start

1. Add the middleware to your framework:

For Django:
```python
MIDDLEWARE = [
    ...
    'distributed_logger.middleware.log_middleware.AuditLogMiddleware',
]
```

2. Set environment variables for configuration:

```bash
# For Kafka logging
export BROKER_TYPE=KAFKA
export KAFKA_BOOTSTRAP_SERVERS=localhost:9092
export KAFKA_TOPIC=audit_logs
export KAFKA_CLIENT_ID=your_app_name

# For simple console logging
export BROKER_TYPE=SIMPLE
```

That's it! The middleware will automatically log all requests.

## Usage Examples

### Custom Logging

```python
from distributed_logger.loggers import KafkaLogger
from distributed_logger.models import LogInfo
from distributed_logger.models.config import KafkaConfig

# Create a logger instance
config = KafkaConfig(
    broker_type="KAFKA",
    bootstrap_servers=["localhost:9092"],
    topic="audit_logs"
)
logger = KafkaLogger(config=config)

# Log some information
log_info = LogInfo(
    ip_address="127.0.0.1",
    user_id="user123",
    request_time="2024-01-01 12:00:00",
    action="custom_action",
    request_data={"key": "value"}
)
logger.publish(log_info)
```

## Environment Variables

| Variable | Description | Default |
|----------|-------------|---------|
| BROKER_TYPE | Type of logging backend ('KAFKA' or 'SIMPLE') | 'SIMPLE' |
| KAFKA_BOOTSTRAP_SERVERS | Comma-separated list of Kafka brokers | 'localhost:9092' |
| KAFKA_TOPIC | Kafka topic for logs | 'audit_logs' |
| KAFKA_CLIENT_ID | Client ID for Kafka producer | None |

## Development

To set up for development:

```bash
# Clone the repository
git clone https://github.com/arjun-navya/distributed-logger.git
cd distributed-logger

# Install development dependencies
pip install -e ".[dev]"

# Run tests
pytest
```

## Contributing

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

## License

This project is licensed under the MIT License - see the LICENSE file for details. # logger
damply 0.26.0
Data Management Plan made simple.
Requires Python: >=3.11
Keywords: damply, package, pixi, python

#OWNER: Jermiah

#DATE: 2025-05-20

#DESC: Data Management Plan made simple


# damply

[![codecov](https://codecov.io/gh/bhklab/damply/graph/badge.svg?token=tCcajRIGz9)](https://codecov.io/gh/bhklab/damply)
[![CI-CD](https://github.com/bhklab/damply/actions/workflows/main.yaml/badge.svg)](https://github.com/bhklab/damply/actions/workflows/main.yaml)
[![CodeFactor](https://www.codefactor.io/repository/github/bhklab/damply/badge)](https://www.codefactor.io/repository/github/bhklab/damply)

[![pixi-badge](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/prefix-dev/pixi/main/assets/badge/v0.json&style=flat-square)](https://github.com/prefix-dev/pixi)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&style=flat-square)](https://github.com/pre-commit/pre-commit)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json&style=flat-square)](https://github.com/astral-sh/ruff)
[![Built with Material for MkDocs](https://img.shields.io/badge/mkdocs--material-gray?logo=materialformkdocs&style=flat-square)](https://github.com/squidfunk/mkdocs-material)

[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/damply)](https://pypi.org/project/damply/)
[![PyPI - Version](https://img.shields.io/pypi/v/damply)](https://pypi.org/project/damply/)
[![PyPI - Format](https://img.shields.io/pypi/format/damply)](https://pypi.org/project/damply/)
[![Downloads](https://static.pepy.tech/badge/damply)](https://pepy.tech/project/damply)

## Overview


DaMPly (Data Management Plan) is a Python module designed to streamline the process of managing and packaging directories.
bd-fileorganizer 0.0.7
Organize files in folders by type
Requires Python: >=3.8

# 🗂️ bd_fileorganizer

**bd_fileorganizer** is a simple yet powerful Python utility that helps you clean up cluttered folders by automatically moving files into categorized subfolders like `images/`, `documents/`, `archives/`, and more — all based on file extensions.

It’s perfect for tidying up your `Downloads`, `Desktop`, or project folders with just one command.

---
## 📦 HOW TO USE:

** In Your terminal:
If mac use  python3 , if windows use python
- pip install bd-fileorganizer
- from bd_fileorganizer.organizer import organize_folder
- organize_folder("give your folder path with different files")

** In Your ipynb file:
- pip install bd-fileorganizer
- from bd_fileorganizer.organizer import organize_folder
- organize_folder("give your folder path with different files")

## 📦 Features

- 📁 Automatically sorts files into categories
- 🧠 Smart extension detection (`.jpg` → `images`, `.pdf` → `documents`, etc.)
- 🧪 Dry-run mode to preview changes
- 🐍 Easy-to-use Python API and CLI interface
- ✅ Beginner-friendly code and customizable

---

## 🚀 Installation

Install from source:

```bash
pip install bd-fileorganizer
````

> 📌 Available on PyPI!
    https://pypi.org/project/bd-fileorganizer/

---

## 🖥️ CLI Usage

```bash
organize_folder "/path/to/folder"
```

**Dry-run (preview only):**

```bash
organize_folder "/path/to/folder" --dry
```

---

## 🐍 Python API

```python

from bd_fileorganizer.organizer import organize_folder

organize_folder("/Users/you/Downloads")
```

---

## 🧪 Running Tests

```bash
pytest
```

---

## 🗃️ Folder Structure Example

**Before:**

```
Downloads/
├── photo.jpg
├── report.pdf
├── backup.zip
```

**After:**

```
Downloads/
├── images/
│   └── photo.jpg
├── documents/
│   └── report.pdf
├── archives/
│   └── backup.zip
```

---

## 🔧 Extension Mapping

| Category     | Extensions                      |
| ------------ | ------------------------------- |
| `images/`    | `.jpg`, `.jpeg`, `.png`, `.gif` |
| `documents/` | `.pdf`, `.docx`, `.txt`         |
| `archives/`  | `.zip`, `.tar`, `.gz`, `.rar`   |
| `videos/`    | `.mp4`, `.mov`, `.mkv`          |
| `audio/`     | `.mp3`, `.wav`                  |
| `others/`    | Everything else                 |

---

## 📄 License

Licensed under the [GNU License](https://www.gnu.org/licenses/gpl-3.0.html#license-text)

---

## 🤝 Contributing

Contributions, feature ideas, and bug reports are welcome!
Feel free to open an [issue](https://github.com/bhuvan0808/bd-fileorganizer/issues) or a [pull request](https://github.com/bhuvan0808/bd-fileorganizer/pulls).

---

## 👤 Authors

**Bhuvan**
GitHub: [@bhuvan0808](https://github.com/bhuvan0808)
GitHub: [@devaagulla](https://github.com/devaagulla)



---

> 🧹 Make your folders smarter, not messier — with `bd-fileorganizer` 🗂️
TFCat 1.0.3
Time-Frequency Catalogue (TFCat) Python module.
Requires Python: >=3.7
Keywords: radio astronomy, catalogue

#  Time-Frequency Catalogue (TFCat) Python Module

This module implements an interface for loading TFCat JSON 
data files. 

TFCat JSON Specification: [TFcat](https://gitlab.obspm.fr/maser/catalogues/catalogue-format)

TFCat JSON Schema: https://voparis-ns.obspm.fr/maser/tfcat/v1.0/schema#

*This version 1.0.3*

## Installation

TFCat is available from PyPI: https://pypi.org/project/TFCat/

```
pip install TFCat
```


## Acknowlegments
- This TFCat library has been derived from the 
  [jazzband/geojson](https://github.com/jazzband/geojson) python library.