semvec/pypi-packages huggingface dataset:
gnetcli-adapter 2.7.0
Gnetcli-server adapter for Annet
Requires Python: >=3.10

# gnetcli_adapter
This package provides deployer and fetcher adapters for Annet

# Examples

## Using specified login and password

cat ~/.annet/context.yml
```yaml
fetcher:
  default:
    adapter: gnetcli
    params: &gnetcli
      dev_login: mylogin
      dev_password: mypassword
deployer:
  default:
    adapter: gnetcli
    params:
      <<: *gnetcli
...
context:
  default:
    fetcher: default
    deployer: default
selected_context: default
```

## Using tunnel through master SSH-connection

https://en.wikibooks.org/wiki/OpenSSH/Cookbook/Multiplexing

cat ~/.ssh/context.yml
```
Host myhost*
    ProxyJump mybastion

Host mybastion
    ControlMaster auto
    ControlPath ~/.ssh/mastersockets/%r@%h:%p
    ControlPersist 120m
```

`~/.annet/context.yml` the same because gnetcli read .ssh/config by default.
chatsynth-vanshajr 1.0.5
A library for creating and deploying chatbots with FAISS and GitHub integration for the ChatSynth app: https://chatsynth.streamlit.app.
Requires Python: >=3.8

# ChatSynth Library

[![PyPI Version](https://img.shields.io/pypi/v/chatsynth_vanshajr)](https://pypi.org/project/chatsynth_vanshajr/)
[![License](https://img.shields.io/badge/License-BSD--3.0-blue)](https://opensource.org/licenses/AGPL-3.0)

A Python library for creating and deploying personalized chatbots using FAISS for document retrieval and GitHub for deployment. This package is part of the **ChatSynth** project, which allows users to build AI-powered chatbots based on their personal or professional data.

🔗 **Live Demo**: [https://chatsynth.streamlit.app](https://chatsynth.streamlit.app)  
📂 **GitHub Repository**: [VanshajR/ChatSynth](https://github.com/VanshajR/ChatSynth)

# Acknowledgments

- Built with ❤️ by Vanshaj Raghuvanshi.

- Powered by LangChain, FAISS, and Streamlit.
---
shvcli-ell 0.2.0
Silicon Heaven CLI Elektroline extension
Requires Python: >=3.11

Silicon Heaven CLI Elektroline extension
========================================

The extension for the Silicon Heaven CLI access application to provide utilities
to work with Elektroline developed SHV systems.

* `📃 Sources <https://gitlab.com/elektroline-predator/shvcli-ell>`__
* `⁉️ Issue tracker <https://gitlab.com/elektroline-predator/shvcli-ell/-/issues>`__
* `Silicon Heaven CLI <https://gitlab.com/silicon-heaven/shvcli>`__
acdh-django-browsing 3.3.2
Django-App providing some useful things to create browsing views
Requires Python: >=3.10
Keywords: django

[![flake8 Lint](https://github.com/acdh-oeaw/acdh-django-browsing/actions/workflows/lint.yml/badge.svg)](https://github.com/acdh-oeaw/acdh-django-browsing/actions/workflows/lint.yml)
[![Test](https://github.com/acdh-oeaw/acdh-django-browsing/actions/workflows/test.yml/badge.svg)](https://github.com/acdh-oeaw/acdh-django-browsing/actions/workflows/test.yml)
[![PyPI version](https://badge.fury.io/py/acdh-django-browsing.svg)](https://badge.fury.io/py/acdh-django-browsing)
# acdh-django-browsing
Django-App providing some useful things to create browsing views

## Features
see the example project in this repo to check out how to use the package and what it does

## Quickstart
Install acdh-django-browsing:

`pip install acdh-django-browsing`

Add it to your `INSTALLED_APPS`:

```python
INSTALLED_APPS = (
    ...
    'browsing',
    ...
)
```


## Develop
### install (dev-)dependencies
```bash
pip install -r requirements.txt
```

### run migrations, load fixtures, and start dev server
```bash
python manage.py migrate
python manage.py loaddata data.json
python manage.py runserver
```

### run tests
```bash
coverage run manage.py test -v 2
```

### build the package
```bash
python -m build
```
llm-deep-research 0.0.3
LLM plugin of various deep research implementations
Requires Python: >=3.11
Keywords: llm, deep research

# llm-deep-research

[![PyPI](https://img.shields.io/pypi/v/llm-deep-research.svg)](https://pypi.org/project/llm-deep-research/)
[![Changelog](https://img.shields.io/github/v/release/ftnext/llm-deep-research?include_prereleases&label=changelog)](https://github.com/ftnext/llm-deep-research/releases)
[![Tests](https://github.com/ftnext/llm-deep-research/actions/workflows/test.yml/badge.svg)](https://github.com/ftnext/llm-deep-research/actions/workflows/test.yml)
[![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/ftnext/llm-deep-research/blob/main/LICENSE)



## Installation

Install this plugin in the same environment as [LLM](https://llm.datasette.io/).
```bash
llm install llm-deep-research
```
## Usage

### GenAI Processors' research

https://github.com/google-gemini/genai-processors/tree/main/examples/research

```
export LLM_GEMINI_KEY=your_api_key_here

llm -m genai-processors-research 'Research the best things about owning dalmatians!'
```

Also supports `--async`.

## Development

To set up this plugin locally, first checkout the code. Then create a new virtual environment:
```bash
cd llm-deep-research
```
Now create a new virtual environment and install the dependencies and test dependencies:
```bash
uv sync --extra test
```
To run the tests:
```bash
uv run pytest
```
logger4me 0.1.3
Add your description here
Requires Python: >=3.6

# logger4me

![img1](img/img1.png)

A simple and colorful Python logging utility that provides enhanced console output with ANSI color codes and flexible file logging options.

## Features

- **Colorful Console Output**: Different log levels are displayed in different colors for better readability
- **File Logging Support**: Optional file logging with customizable file paths
- **Color Control**: Choose whether to save colors in log files or keep them plain text
- **Flexible Log Levels**: Support for all standard Python logging levels (DEBUG, INFO, WARNING, ERROR, CRITICAL)
- **Easy Integration**: Simple one-function setup for your logging needs

## Installation

Install logger4me using uv:

```bash
uv add logger4me
```

Install logger4me using pip:

```bash
pip install logger4me
```

## Usage

### Basic Usage

```python
from logger4me import get_logger

# Create a logger with default settings
logger = get_logger()

# Log messages at different levels
logger.debug("This is a debug message")
logger.info("This is an info message")
logger.warning("This is a warning message")
logger.error("This is an error message")
logger.critical("This is a critical message")
```

### Advanced Configuration

```python
from logger4me import get_logger
import logging

# Create a logger with custom settings
logger = get_logger(
    level = 10,        # Set minimum log level
    log_file = './logs/app.log',  # Save logs to file
    save_color = False            # Don't save ANSI colors to file
)
```

### Parameters

- **level** (int): Minimum logging level (default: `logging.INFO`)
  - `10`: Debug messages and above(`logging.DEBUG`)
  - `20`: Info messages and above(`logging.INFO`)
  - `30`: Warning messages and above(`logging.WARNING`)
  - `40`: Error messages and above(`logging.ERROR`)
  - `50`: Critical messages only(`logging.CRITICAL`)

- **log_file** (str, optional): Path to save log messages to a file (default: `None`)
  - If provided, creates the directory structure automatically
  - File is created in write mode, overwriting existing content

- **save_color** (bool): Whether to save ANSI color codes in the log file (default: `False`)
  - `True`: Colors are preserved in the file
  - `False`: Plain text without color codes (recommended for file logs)
sampleproject-rs 0.2.3
A sample Python project from Rust binary
Requires Python: >=3.10
Keywords: sample, maturin, development

# A sample Python project from Rust binary

Inspired by [sampleproject](https://github.com/pypa/sampleproject/).

This provides the following:

* `sample` command
* `sample.simple.add_one()`

```python
>>> from sample import simple
>>> simple.add_one(42)
43
```

----

This is the README file for the project.

The file should use UTF-8 encoding and can be written using
[reStructuredText][rst] or [markdown][md use] with the appropriate [key set][md
use]. It will be used to generate the project webpage on PyPI and will be
displayed as the project homepage on common code-hosting services, and should be
written for that purpose.

Typical contents for this file would include an overview of the project, basic
usage examples, etc. Generally, including the project changelog in here is not a
good idea, although a simple “What's New” section for the most recent version
may be appropriate.

[rst]: http://docutils.sourceforge.net/rst.html
[md]: https://tools.ietf.org/html/rfc7764#section-3.5 "CommonMark variant"
[md use]: https://packaging.python.org/specifications/core-metadata/#description-content-type-optional
moira-python-client 5.1.1
Client for Moira - Alerting system based on Graphite data
Keywords: moira monitoring client metrics alerting


        Moira is a real-time alerting tool, based on Graphite data.
        moira-client is a python client for Moira API.
        Key features:
        - create, update, delete, manage triggers
        - create, delete, update subscriptions
        - manage tags, patterns, notifications, events, contacts
pymispgalaxies 1.1.1
Python API for the MISP Galaxies.
Requires Python: >=3.10

# PyMISPGalaxies

[![Build Status](https://travis-ci.org/MISP/PyMISPGalaxies.svg?branch=master)](https://travis-ci.org/MISP/PyMISPGalaxies)
[![codecov.io](https://codecov.io/github/MISP/PyMISPGalaxies/coverage.svg?branch=master)](https://codecov.io/github/MISP/PyMISPGalaxies?branch=master)

Pythonic way to work with the galaxies defined there: https://github.com/MISP/misp-galaxy

# Usage

Clusters and Galaxies are represented as immutable Python dictionaries.
buxcli 1.2.1
A simple CLI tool for alert you about your CLI.
Requires Python: >=3.7

# ⚡ BuxCLI 🚀  
Run any command + get instant email notifications

BuxCLI is a lightweight command-line tool that runs shell commands and sends instant **email alerts** when your command:

1️⃣ **Succeeds**  
2️⃣ **Fails**  
3️⃣ **Server starts** (auto-detects “server ready” messages)

Perfect for developers, sysadmins, and DevOps engineers who don’t want to stare at terminals.

---

# 📑 Table of Contents

- [Features](#-features)  
- [Installation](#-installation)  
- [Usage Examples](#-usage-examples)  
  - [Long Running Commands](#1-long-running-commands)  
  - [Server Startup Detection](#2-server-starting-commands)  
- [Contributing](#-contributing)  
- [Contact](#-contact)  
- [License](#-license)

---

## ✨ Features

- 🔔 Email alerts for **success**, **failure**, or **server startup**
- 🔐 Secure Gmail App Password setup
- 💬 Test email option during initial setup
- 🔄 Automatic retry if credentials are invalid
- 🎨 Colorful CLI output with ASCII banner
- 🧪 Works with all commands (Python, Django, Docker, Node, Bash, etc.)

---

## 💻 Installation

Install using pip:

```bash
pip install buxcli
```
Check Instalation
```bash
buxcli --help
```

Output:
```bash

██████  ██    ██ ██   ██  ██████ ██      ██ 
██   ██ ██    ██  ██ ██  ██      ██      ██ 
██████  ██    ██   ███   ██      ██      ██ 
██   ██ ██    ██  ██ ██  ██      ██      ██ 
██████   ██████  ██   ██  ██████ ███████ ██ 

Run commands with automatic email notifications when they succeed, fail, or a server starts.

Examples:
  buxcli run "python manage.py runserver"
  buxcli docker pull ollama
Usage: buxcli [OPTIONS] [CMD]... COMMAND [ARGS]...

  buxcli - Run commands with automatic email notifications

Options:
  --reconfig  Reconfigure email Credentials
  --help  Show this message and exit.

Commands example:
  buxcli docker pull nginx

```
---

## 🔗 Example
### 1) Long Running Commands

```bash
- buxcli docker pull nginx

- buxcli flutter build apk

# send mail on sucess or failure
```
### 2) Server Starting commands

```bash
- buxcli python manage.py runserver

# send mail on server starting
```
---

## 🤝 Contributing

```bash

# 1. Fork the repository

# 2. Create a feature branch
git checkout -b feature/my-feature

# 3. Commit your changes
git commit -m "Add new feature"

# 4. Push to GitHub
git push origin feature/my-feature

# 5. Open a Pull Request

```
---
## 📡 Contact 
```bash
Mohd. Rushaad Buxy
Email: m.rushaadq@gmail.com
GitHub: https://github.com/rushaad2911/Buxcli

buxcli – Never miss a command status again! 🚀
```
---
## 📝 License
```bash
This project is licensed under the MIT License. See the LICENSE file for details.
```
cf-pipeline-backend 0.0.4
Mixed C++/Python pipeline backend (stub implementation)
Requires Python: >=3.8

# cf-pipeline-backend

Pybind11-based backend implementing the mixed C++/Python pipeline described in `pipeline_backend/spec/PIPELINE_SPEC.md`.

Version 0.0.2 introduces a compiled backend (`pipeline_backend._backend`) that provides:
- C++ registry (cpp + python ops) and `Pipeline::run` loop
- PyCapsule C API (`pipeline_backend.register_op_v1`) for C++ plugins
- Python shims re-exporting the compiled functions (`pipeline_backend/__init__.py`)

This package exposes:

- `__backend_metadata__`
- `register_py_op`, `register_cpp_op`
- `list_ops`, `describe_ops`
- `Pipeline`
- `_register_op_capsule`

Resources bundled for validation/reference:
- Spec: `pipeline_backend/spec/PIPELINE_SPEC.md`
- Schemas: `pipeline_backend/spec/schemas/{pipeline_backend.schema.json,pipeline_plugin.schema.json}`
- Validator helper: `pipeline_backend.validator`

Example (uses cf_basic_signal, OPC UA virtual pH server):
```
pip install -e sand_toys/cf_basic_steps/cf_basic_signal
pip install -e sand_toys/cf-pipeline/cf-pipeline-backend
python sand_toys/cf-pipeline/cf-pipeline-backend/examples/run_opcua_fifo_avg_csv.py
```

Code lives in `src/pipeline_backend/`. This packaging layer enables tag-driven wheel builds and publishing to PyPI/TestPyPI.
aurocx-common 1.0.0
AuroCX Python Package
Requires Python: >=3.9

# Pre-Requisites to publish as pypi project
Always bump the version in pyproject.toml else it will throw an exception at the time of publishing!!

1. In case of updates to the existing code - change the minor version in pyproject.toml.(increment the minor version i.e 1.0.0 will be 1.0.1)

2. In case of a new feature - change the major version in pyproject.toml.(increment the major version i.e 1.0.1 becomes 2.0.0)


4. Following are the credentials required to publish pypi package -

   Full Name : Aurionpro Solutions
   Public Email : trekket2021@gmail.com
   Username : __token__
   Token: ""

   Library name - aurocx-common


   Make Sure you have .pypirc file exist in application
altsplicing 25.11.1
Alternative splicing in proteomics and phospho-proteomics
Requires Python: >=3.11
Keywords: proteomics

# AltSplicing

Python module for analysis of the alternative splicing in proteomics and phospho-proteomics data.

## Installation

To install the latest release from the [Python Package Index](https://pypi.org/project/altsplicing/):
```shell
pip install altsplicing
```

## Jupyter notebook examples

* `examples/altsp_pxd_sets.ipynb` - the workflow configured for PXD006122 and PXD020296 projects.

The data required for the notebook is available at [Zenodo](https://zenodo.org/records/14541303). Download
`altsp_pxd.7z` archive and unpack it directly to `examples` directory using [7-zip](https://www.7-zip.org/) or any 7z
compatible utility.

## License

BSD License.
bonesis 0.6.9
Synthesis of Most Permissive Boolean Networks
Requires Python: >=3.9
Keywords: computational systems biology, boolean networks, model synthesis

# BoNesis - Boolean Network synthesis

Synthesis of Most Permissive Boolean Networks from network architecture and dynamical properties

This software is distributed under the [CeCILL v2.1](http://www.cecill.info/index.en.html) free software license (GNU GPL compatible).

For installation instructions and usage, see [documentation](https://bnediction.github.io/bonesis).