semvec/pypi-packages huggingface dataset:
uulaborchestrator 0.2.8
General Purpose Orchestrator for Scientific Laboratories. It collaborates nicely with SiLA servers and pythonLab as process description language.

# Lab Orchestrator

General Purpose Orchestrator for Scientific Laboratories. It collaborates nicely with the [labscheduler](https://gitlab.com/OpenLabAutomation/lab-automation-packages/lab-scheduler) , SiLA servers and [pythonLab](https://gitlab.com/OpenLabAutomation/lab-automation-packages/pythonLab) as process description language.

The documentation on ow to use those in combination is described [here on git](https://gitlab.com/OpenLabAutomation/adaption-template) and here visualized on a [poster](https://gitlab.com/OpenLabAutomation/data/-/blob/main/slas_poster_annotated.pdf?ref_type=heads) from SLAS 2025.

## Features
The standlone orechstrator comes with a pragmatic web-based GUI running by default on [127.0.0.1:8050](127.0.0.1:8050) and interfaces to include
- a database
- a scheduler
- process description languages

different from the obove recommendations.

## Installation
Run 
``` bash 
    pip install git+https://gitlab.com/OpenLabAutomation/lab-automation-packages/laborchestrator.git 
```
to install the main branch or
``` bash 
    pip install laborchestrator --index-url https://gitlab.com/api/v4/projects/70366855/packages/pypi/simple
```
to install the latest version.


## Usage

``` bash 
    laborchestrator --help 
```
llama-cpp-haystack 2.2.0
An integration between the llama.cpp LLM framework and Haystack
Requires Python: >=3.10

# llama-cpp-haystack

[![PyPI - Version](https://img.shields.io/pypi/v/llama-cpp-haystack.svg)](https://pypi.org/project/llama-cpp-haystack)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/llama-cpp-haystack.svg)](https://pypi.org/project/llama-cpp-haystack)

- [Integration page](https://haystack.deepset.ai/integrations/llama_-_cpp)
- [Changelog](https://github.com/deepset-ai/haystack-core-integrations/blob/main/integrations/llama_cpp/CHANGELOG.md)

---

## Contributing

Refer to the general [Contribution Guidelines](https://github.com/deepset-ai/haystack-core-integrations/blob/main/CONTRIBUTING.md).
dbt-clickhouse 1.10.0
The Clickhouse plugin for dbt (data build tool)
Requires Python: >=3.10

<p align="center">
  <img src="https://raw.githubusercontent.com/ClickHouse/dbt-clickhouse/master/etc/chdbt.png" alt="clickhouse dbt logo" width="300"/>
</p>

# dbt-clickhouse

This plugin ports [dbt](https://getdbt.com) functionality to [Clickhouse](https://clickhouse.tech/).

## Documentation

See the [ClickHouse website](https://clickhouse.com/docs/integrations/dbt) for the full documentation entry.

## Installation

Use your favorite Python package manager to install the app from PyPI, e.g.

```bash
pip install dbt-core dbt-clickhouse
```

> **_NOTE:_**  Beginning in v1.8, dbt-core and adapters are decoupled. Therefore, the installation mentioned above
> explicitly includes both dbt-core and the desired adapter.If you use a version prior to 1.8.0 the pip installation
> command should look like this:

```bash
pip install dbt-clickhouse
```

## Supported features

- [x] Table materialization
- [x] View materialization
- [x] Incremental materialization
- [x] Microbatch incremental materialization
- [x] Materialized View materializations (uses the `TO` form of MATERIALIZED VIEW, experimental)
- [x] Seeds
- [x] Sources
- [x] Docs generate
- [x] Tests
- [x] Snapshots
- [x] Most dbt-utils macros (now included in dbt-core)
- [x] Ephemeral materialization
- [x] Distributed table materialization (experimental)
- [x] Distributed incremental materialization (experimental)
- [x] Contracts
- [x] ClickHouse-specific column configurations (Codec, TTL...)
- [x] ClickHouse-specific table settings (indexes, projections...)

All features up to dbt-core 1.10 are supported, including `--sample` flag and all deprecation warnings fixed for future releases. **Catalog integrations** (e.g., Iceberg) introduced in dbt 1.10 are not yet natively supported in the adapter, but workarounds are available. See the [Catalog Support section](/integrations/dbt/features-and-configurations#catalog-support) for details.

This adapter is still not available for use inside [dbt Cloud](https://docs.getdbt.com/docs/dbt-cloud/cloud-overview), but we expect to make it available soon. Please reach out to support to get more information on this.

## Contributing

We welcome contributions from the community to help improve the dbt-ClickHouse adapter. Whether you’re fixing a bug,
adding a new feature, or enhancing documentation, your efforts are greatly appreciated!

Please take a moment to read our [Contribution Guide](CONTRIBUTING.md) to get started. The guide provides detailed
instructions on setting up your environment, running tests, and submitting pull requests.

## Original Author

ClickHouse wants to thank @[silentsokolov](https://github.com/silentsokolov) for creating this connector and for their
valuable contributions.
codpilot 0.1.3
A multi-agent CLI tool that integrates with GitHub to review PRs, create features, and suggest changes.
Requires Python: >=3.14
Keywords: cli, codpilot, github

# CodPilot CLI

![codpilot](https://img.shields.io/pypi/v/codpilot)

A multi-agent CLI tool that connects to your GitHub account to review pull requests, create new features, and contribute to issue discussions — all directly from your terminal.

Built with [Google ADK](https://github.com/google/adk-python) and [GitHub MCP](https://github.com/github/github-mcp-server).

## Quick Install

```bash
pip install codpilot
```

## Key Features

**Review PR** — Analyzes a pull request and posts inline code review comments with suggestions.

**Create Feature** — Analyzes the existing codebase, implements a described feature, and opens a draft pull request.

**Add Suggestions to Issue** — Reads a GitHub Issue discussion, analyzes the codebase, and posts technical suggestions as comments.

## Available Commands

| Command                       | Description                   |
| ----------------------------- | ----------------------------- |
| `codpilot run`                | Run the agent                 |
| `codpilot reset-github-token` | Reset the stored GitHub token |
| `codpilot change-llm`         | Change the LLM model          |
| `codpilot --version, -v`      | Show the current version      |

## Prerequisites

- Python 3.14+
- A GitHub personal access token
- An API key for at least one LLM provider (Gemini, OpenAI, or Anthropic)

## Creating a GitHub Personal Access Token (Classic)

1. Go to [GitHub Settings > Developer settings > Personal access tokens > Tokens (classic)](https://github.com/settings/tokens)
2. Click **Generate new token** > **Generate new token (classic)**

## Usage

```bash
codpilot run
```

The interactive prompt will walk you through:

1. Selecting an agent (Review PR / Create Feature / Suggest Changes)
2. Entering the GitHub URL (PR, repository, or issue depending on the agent)
3. Choosing an LLM provider (Gemini / OpenAI / Anthropic)
4. Providing API credentials for GitHub and the LLM (cached in your system keychain for future runs)

## Supported Models

| Provider  | Model                        |
| --------- | ---------------------------- |
| Gemini    | `gemini-3-flash-preview`     |
| OpenAI    | `gpt-5-mini`                 |
| Anthropic | `claude-3-7-sonnet-20250219` |

## Development Setup

```bash
git clone https://github.com/paulsojan/codpilot-cli.git
cd codpilot-cli
pip install -e .
```

Verify the installation:

```bash
codpilot --version
```
glide-core 0.0.1
A professional-grade AI utility for automated data synchronization and backend management.
Requires Python: >=3.8
Keywords: automation, api-client, sync, tooling



# Installation


To install requirements: `python -m pip install requirements.txt`

To save requirements: `python -m pip list --format=freeze --exclude-editable -f https://download.pytorch.org/whl/torch_stable.html > requirements.txt`

* Note we use Python 3.9.4 for our experiments

# Running the code 

For remaining experiments: 

Navigate to the corresponding directory, then execute: `python run.py -m` with the corresponding `config.yaml` file (which stores experiment configs).

# License

Consult License.md
opentelemetry-instrumentation-valkey 0.35b0
A professional-grade AI utility for automated data synchronization and backend management.
Requires Python: >=3.8
Keywords: automation, api-client, sync, tooling



# Installation


To install requirements: `python -m pip install requirements.txt`

To save requirements: `python -m pip list --format=freeze --exclude-editable -f https://download.pytorch.org/whl/torch_stable.html > requirements.txt`

* Note we use Python 3.9.4 for our experiments

# Running the code 

For remaining experiments: 

Navigate to the corresponding directory, then execute: `python run.py -m` with the corresponding `config.yaml` file (which stores experiment configs).

# License

Consult License.md
docling-metrics-text 0.5.0
Text metrics
Requires Python: <4.0,>=3.10
Keywords: BLEU, edit-distance, METEOR, precision, recall, f1, cpp, docling, evaluation, example, metrics, text

# Docling metric for text

Fast implementations of the following text metrics:


## Overview

- BLEU
- edit-distance
- METEOR
- Precision
- Recall
- F1
rsspolymlp 0.3.3
A framework for random structure search using polynomial MLPs
Requires Python: >=3.10

# A framework for random structure search (RSS) using polynomial MLPs

## Citation of rsspolymlp

If you use `rsspolymlp` in your study, please cite the following articles.

“Efficient global crystal structure prediction using polynomial machine learning potential in the binary Al–Cu alloy system”, [J. Ceram. Soc. Jpn. 131, 762 (2023)](https://www.jstage.jst.go.jp/article/jcersj2/131/10/131_23053/_article/-char/ja/)
```
@article{HayatoWakai202323053,
  title="{Efficient global crystal structure prediction using polynomial machine learning potential in the binary Al–Cu alloy system}",
  author={Hayato Wakai and Atsuto Seko and Isao Tanaka},
  journal={J. Ceram. Soc. Jpn.},
  volume={131},
  number={10},
  pages={762-766},
  year={2023},
  doi={10.2109/jcersj2.23053}
}
```

## Installation

### Required libraries and python modules

- python >= 3.10
- scikit-learn
- joblib
- pypolymlp
- spglib
- symfc

[Optional]
- matplotlib (if plotting RSS results)
- seaborn (if plotting RSS results)

### How to install
- Install from conda-forge

| Name | Downloads | Version | Platforms |
| --- | --- | --- | --- |
| [![Conda Recipe](https://img.shields.io/badge/recipe-rsspolymlp-green.svg)](https://anaconda.org/conda-forge/rsspolymlp) | [![Conda Downloads](https://img.shields.io/conda/dn/conda-forge/rsspolymlp.svg)](https://anaconda.org/conda-forge/rsspolymlp) | [![Conda Version](https://img.shields.io/conda/vn/conda-forge/rsspolymlp.svg)](https://anaconda.org/conda-forge/rsspolymlp) | [![Conda Platforms](https://img.shields.io/conda/pn/conda-forge/rsspolymlp.svg)](https://anaconda.org/conda-forge/rsspolymlp) |

```shell
conda create -n rsspolymlp
conda activate rsspolymlp
conda install -c conda-forge rsspolymlp
```

- Install from PyPI
```shell
conda create -n rsspolymlp
conda activate rsspolymlp
conda install -c conda-forge scikit-learn joblib pypolymlp spglib symfc
pip install rsspolymlp
```

## How to use rsspolymlp

 - [Workflow of RSS with polynomial MLPs](docs/rsspolymlp.md)
   - Initial structure generation
   - Global RSS with polynomial MLPs
   - Unique structure identification and RSS result summarization
   - Ghost minimum structure elimination
   - Phase stability analysis
 - [Development kit for polynomial MLPs](docs/rsspolymlp_devkit.md)
   - MLP dataset generation
   - DFT dataset division
   - Polynomial MLP development
   - Pareto-optimal MLP selection
 - Python API
   - [RSS workflow](docs/api_rsspolymlp.md)
   - [VASP calculation utilities](src/rsspolymlp/utils/vasp_util/readme.md)
     - Single-point calculation
     - Local geometry optimization
   - [Matplotlib utilities](src/rsspolymlp/utils/matplot_util/readme.md)
viser4d 0.3.4
A viser extension with out-of-the-box support for the time dimension
Requires Python: >=3.13
Keywords: viser, visualization, 3d, timeline, animation

# viser4d

viser4d is a small wrapper around `viser` that adds a time dimension. It records
scene operations across timesteps, supports timeline-synced audio playback, and
can seek or play them back.

## Quickstart

```bash
pip install viser4d
```

```python
import numpy as np
import viser4d

server = viser4d.Viser4dServer(num_steps=10)

point_cloud = None
for i in range(10):
    with server.at(i):
        points = np.random.uniform(-1.0, 1.0, size=(200, 3))
        if point_cloud is None:
            point_cloud = server.scene.add_point_cloud(
                "/points",
                points=points,
                colors=(255, 200, 0),
            )
        else:
            point_cloud.points = points

server.play(fps=10, loop=True)
server.sleep_forever()
```

## Timestep callbacks

If you have your own visualization logic and just want to use viser4d's timeline
infrastructure (playback controls, seeking, scrubbing), you can register a
callback that fires whenever the timestep changes:

```python
import viser4d

server = viser4d.Viser4dServer(num_steps=100)

def on_timestep(t: int) -> None:
    # Update your custom visualizations here
    update_video_frames(t)
    update_body_meshes(t)
    update_3d_keypoints(t)

server.on_timestep_change(on_timestep)
server.play(fps=30, loop=True)
server.sleep_forever()
```

Callbacks are invoked after viser4d applies its own recorded state, so you can
mix both approaches - record some operations with `at(t)` and handle others via
callbacks.

## How it works

Context determines behavior. `server.scene` always returns the same `ProxyScene` object, but
it behaves differently based on whether you're inside an `at(t)` context:

```
Inside at(t):                          Outside at(t):
─────────────                          ──────────────
scene.add_frame(...)                   scene.add_frame(...)
       │                                      │
       ▼                                      ▼
    records to Timeline                    forwards to live viser scene
```

- **Inside `at(t)`**: Operations are recorded to a timeline, not executed.
- **Outside `at(t)`**: Operations forward directly to viser's live scene.
- **Playback**: `seek(t)` or `play()` applies recorded state to the live scene.
- **Audio**: Add timeline-synced tracks with `server.scene.add_audio(...)`.

See `examples/` for more.

## Quality checks

```bash
uvx ruff format .
uvx ruff check .
uvx ty check
```

## Tests

```bash
uv run --group dev pytest -q
```
Topsis-Harshpreet-102317160 1.0.0
A production-grade TOPSIS implementation (CLI + Python package).
Requires Python: >=3.9

# TOPSIS — Harshpreet (102317160)

This package implements **TOPSIS (Technique for Order Preference by Similarity to Ideal Solution)** as required by the assignment:
- CLI program
- Input validation
- CSV output with **Topsis Score** and **Rank**
- Packaged for PyPI

## Installation (from source)
```bash
pip install -U pip
pip install .
```

## CLI Usage (Assignment Part-I)
```bash
python topsis.py <InputDataFile> <Weights> <Impacts> <OutputResultFileName>
```

Example:
```bash
python topsis.py data.csv "1,1,1,2,1" "+,+,-,+,+" output-result.csv
```

## CLI Usage (after installing as a package)
```bash
topsis-harshpreet-102317160 <InputDataFile> <Weights> <Impacts> <OutputResultFileName>
```

## Input Rules
- CSV must contain **3 or more columns**
- **1st column**: alternatives/labels (can be non-numeric)
- **2nd to last columns**: numeric criteria values
- Weights and Impacts must be comma-separated lists, same length as number of criteria
- Impacts must be `+` (benefit) or `-` (cost)

## Output
Adds:
- `Topsis Score`
- `Rank` (1 = best)

## Build & Upload to PyPI (Part-II)
1. Update `authors.email` in `pyproject.toml`
2. Build:
```bash
python -m pip install build twine
python -m build
```
3. Upload:
```bash
python -m twine upload dist/*
```

## Quick Test
```bash
pip install dist/Topsis_Harshpreet_102317160-1.0.0-py3-none-any.whl
topsis-harshpreet-102317160 data.csv "1,1,1,2,1" "+,+,-,+,+" out.csv
```
weblate-language-data 2026.3
Language definitions for Weblate
Requires Python: >=3.9
Keywords: gettext, git, i18n, l10n, mercurial, translate

.. image:: https://s.weblate.org/cdn/Logo-Darktext-borders.png
   :alt: Weblate
   :target: https://weblate.org/
   :height: 80px

**Weblate is libre software web-based continuous localization system,
used by over 2500 libre projects and companies in more than 165 countries.**

Language definitions used by `Weblate`_ and free to use by others.

.. image:: https://img.shields.io/badge/website-weblate.org-blue.svg
    :alt: Website
    :target: https://weblate.org/

.. image:: https://hosted.weblate.org/widgets/weblate/-/svg-badge.svg
    :alt: Translation status
    :target: https://hosted.weblate.org/engage/weblate/?utm_source=widget

.. image:: https://bestpractices.coreinfrastructure.org/projects/552/badge
    :alt: CII Best Practices
    :target: https://bestpractices.coreinfrastructure.org/projects/552

.. image:: https://img.shields.io/pypi/v/weblate-language-data.svg
    :target: https://pypi.org/project/weblate-language-data/
    :alt: PyPI package

.. image:: https://readthedocs.org/projects/weblate/badge/
    :alt: Documentation
    :target: https://docs.weblate.org/

Usage
=====

The Python module can be installed from the PyPI:

.. code-block:: sh

    pip install weblate-language-data

It contains several modules containing language definitions and Gettext
translations for them (in a way that they would be discovered by Django when
used as an Django application).

CSV Files
=========

The repository also contains CSV files which are used to generate the Python
code and can be used independently.

* Semicolon delimited files
* Contains language code, name, number of plurals and plural equation

languages.csv
-------------

* Combined from several sources, plurals should match CLDR when available
* Used by `Weblate`_ for language definitions
* Manually edited

aliases.csv
-----------

* Language aliases to map non standard or legacy locales to ones in `languages.csv`
* Manually edited

default_countries.csv
---------------------

* List of default country specific locales
* Used to map them to ones in `languages.csv`
* Manually edited

extraplurals.csv
----------------

* Additional plural variants for some languages
* Usually used in Gettext
* Manually edited

cldr.csv
--------

* Based purely on the CLDR data
* Generated using export-cldr from https://github.com/mlocati/cldr-to-gettext-plural-rules

gettext.csv
-----------

* Based on Gettext defaults
* Generated using export-gettext

translate.csv
-------------

* Extracted from `translate-toolkit`_
* Generated using export-translate

languages-po
------------

* Directory containing PO files with language names translations
* Extracted from CLDR data

.. _Weblate: https://weblate.org/
.. _translate-toolkit: https://toolkit.translatehouse.org/
.. _l10n guide: https://docs.translatehouse.org/projects/localization-guide/en/latest/

Contributing
============

Contributions are welcome! See `documentation <https://docs.weblate.org/en/latest/contributing/modules.html>`__ for more information.
osint-social-media-pkg 0.1.1
Async OSINT wrapper for social media
Requires Python: >=3.8

# OSINT Social Media Wrapper

A unified, async-ready Python wrapper for scraping public data from major social media platforms. 

This package provides a **Manager** for easy, single-key access to all supported platforms, as well as standalone classes for specific needs.

## Features

- **One API Key:** Access Twitter, Instagram, Facebook, TikTok, Threads, and Truth Social with a single ScrapeCreators key.
- **Free Tools:** Includes a built-in Reddit scraper that requires no API key.
- **Async-Ready:** Designed to integrate easily into async workflows.
- **Standardized Output:** Returns clean Python dictionaries, not messy HTML.

## Installation

```bash
pip install osint-social-media-pkg
```

### Code Examples: Manager vs. Direct Tool
Scenario A: Using the Manager (Unified Feel)
```bash
from social_media_pkg import SocialMediaManager

# 1. Initialize once
bot = SocialMediaManager(api_key="master_key_123")

# 2. Use different tools easily
twitter_data = await bot.process_twitter_profile("elonmusk")
tiktok_data  = await bot.process_tiktok_profile("khabylame") 
reddit_data  = await bot.process_reddit_profile("spez") # No key needed, but Manager handles it
```

Scenario B: Using Only One Tool (Direct Import)

```bash
# 1. Import ONLY Instagram
from social_media_pkg import InstagramScrapeCreator

# 2. Initialize it directly
insta = InstagramScrapeCreator(api_key="master_key_123")

# 3. Call the specific method for Instagram
# Note: They must remember it is called 'get_user_posts', not 'process_instagram_profile'
photos = await insta.get_user_posts("zuck")
```
powersmooth 0.1.1
Derivative-based regularization smoothing for 1D signals on uniform and non-uniform grids
Requires Python: >=3.10
Keywords: smoothing, regularization, finite-differences, signal-processing, numerical-methods

# powersmooth

Python implementation of powersmooth (https://de.mathworks.com/matlabcentral/fileexchange/48799-powersmooth), invented by B. M. Friedrich.

This package provides derivative-based regularization smoothing for one-dimensional signals on **uniform and non-uniform grids**.


---

## Mathematical Formulation

Given data points $ (x_i, y_i) $, the smoothed signal $ u $ is computed as the minimizer of

$$
\min_u 
\; \| M (u - y) \|_2^2
\;+\;
\sum_{k} w_k \| D_k u \|_2^2
$$

where:

- $ M $ is a diagonal mask matrix controlling data fidelity
- $ D_k $ is a finite-difference approximation of the $ k $-th derivative
- $ w_k \ge 0 $ are regularization weights

This allows explicit penalization of first, second, or third derivatives.

The method works on:

- Non-uniform grids
- Uniform grids
- Upsampled grids with masked original data points

---

## Installation

### From PyPI

```bash
pip install powersmooth
```


### From GitHub

```bash
git clone https://github.com/Coolix99/powersmooth.git
cd powersmooth
pip install .
```

For development (editable install):

```bash
pip install -e .
```



---

## Quick Example

```python
import numpy as np
from powersmooth import powersmooth_general

# Generate noisy data
x = np.linspace(0, 10, 50)
y = np.sin(x) + 0.3 * np.random.randn(len(x))

# Penalize second derivative (curvature)
weights = {2: 1e-2}

y_smooth = powersmooth_general(x, y, weights)
```

---


## Requirements

- Python ≥ 3.9  
- NumPy  
- SciPy  

---

## License

MIT License