semvec/pypi-packages huggingface dataset:
iflow-mcp-anycontext-ai-thingsboard-mcp-server 0.1.0
Add your description here
Requires Python: >=3.10

# Thingsboard MCP Server

## Setup environment using uv

### Windows
```
# Install uv
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"

# Create virtual environment
uv venv

# Activate virtual environment
.venv\Scripts\activate
```

### Linux

```
# Install uv
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create virtual environment
uv venv

# Activate virtual environment
source .venv/bin/activate
```

## Add environment variables

Create .env file: `cp .env.example .env`

Add the environment variables to allow the MCP server to connect to Thingsboard.


## Install dependencies
```
uv pip install -r pyproject.toml
```

## Run server
```
uv run src/thingsboard.py
```
yt-mpv 0.2.8
Play videos in MPV, while archiving them on archive.org

# 📺 yt-mpv

Watch a YouTube video without ads, while archiving to archive.org.

```bash
uvx yt-mpv install
```

Follow instructions to configure internet archive credentials, then drag
[the links](https://bitplane.net/dev/python/yt-mpv/install) to your bookmarks
bar. You can watch without archiving (takes a couple of seconds to open), or
click the watch+archive link to upload after watching. After closing MPV, it'll
download it again in highest quality in the background, and upload it to
archive.org with `$(whoami)-urlhash` as the item name.

You will, of course, need to install `mpv` in order to use it, and have an
archive.org account to configure the `internetarchive` uploader. You'll get XDG
desktop notifications 

## why?

This is what you get when you put 4 minutes of adverts after every 6 minutes
of content; someone spends a couple of hours fixing the problem.

## links

* [🏠 home](https://bitplane.net/dev/python/yt-mpv)
 * [🖇 bookmarklets](https://bitplane.net/dev/python/yt-mpv/install)
* [🐍 pypi](https://pypi.org/project/yt-mpv)
* [🐱 github](https://github.com/bitplane/yt-mpv)
symfc 1.6.1
This is the symfc module.
Requires Python: >=3.10

# symfc

## What does symfc do?

Atomic vibrations in crystals are often conveniently described using the phonon
model. In this model, the crystal potential is expanded into a Taylor series
with respect to atomic displacements from their equilibrium positions, and the
expansion coefficients are referred to as force constants.

Predicting phonon properties through computer simulations is becoming
increasingly popular, with the supercell approach being one of the techniques
employed for phonon calculations. In this method, force constants are derived
from datasets of atomic forces and displacements obtained from supercell
snapshots, which feature various configurations of atomic displacements.

While force constants possess specific symmetries, those computed from
displacement-force datasets often do not adhere to these symmetries due to
factors such as numerical noise or approximations used. Symfc is a software
designed to compute force constants from displacement-force datasets in the
supercell approach, ensuring they meet the required symmetry constraints.

## Citation of symfc

"Projector-based efficient estimation of force constants", A. Seko and A. Togo,
Phys. Rev. B, **110**, 214302 (2024)
[[doi](https://doi.org/10.1103/PhysRevB.110.214302)]
[[arxiv](https://arxiv.org/abs/2403.03588)].

```
@article{PhysRevB.110.214302,
  title = {Projector-based efficient estimation of force constants},
  author = {Seko, Atsuto and Togo, Atsushi},
  journal = {Phys. Rev. B},
  volume = {110},
  issue = {21},
  pages = {214302},
  numpages = {18},
  year = {2024},
  month = {Dec},
}
```
bqat 1.8.7
Biometric Quality Assessment Tool - CLI (BQAT-CLI)
Requires Python: <3.15,>=3.10
Keywords: bqat, cli, biometric, data, quality, assessment

# BQAT

[![PyPI - Version](https://img.shields.io/pypi/v/bqat)](https://pypi.python.org/pypi/bqat)
[![PyPI - Downloads](https://img.shields.io/pypi/dm/bqat)](https://pypi.python.org/pypi/bqat)
[![PyPI - Format](https://img.shields.io/pypi/format/bqat)](https://pypi.python.org/pypi/bqat)
[![PyPI - License](https://img.shields.io/pypi/l/bqat)](https://pypi.python.org/pypi/bqat)
[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/bqat)](https://pypi.python.org/pypi/bqat)

> A command line interface to [BQAT](https://biometix.github.io/).

BQAT (Biometric Quality Assessment Tool) is an open-source tool designed for assessing the quality of biometric data. It provides evaluations for various modalities, including [face](https://biometix.github.io/modality/face.html), [fingerprint](https://biometix.github.io/modality/fingerprint.html), [iris](https://biometix.github.io/modality/iris.html), and [voice](https://biometix.github.io/modality/speech.html).

## Highlights

- 🚀 A simple Python interface for running `BQAT` workflow, and more.
- 🖥️ Supports macOS, Linux, and Windows.

## Prerequisites

- [Docker](https://www.docker.com/)
- x86-64 or ARMv9 CPU

## Quick Start

1. Install

    ```sh
    pip install bqat
    ```

2. Display version info

    ```sh
    bqat --version
    ```

3. Validate installation via benchmarking

    ```sh
    bqat --benchmark
    ```

4. Run BQAT analysis

    ```sh
    bqat --mode face --input data/face
    ```

5. Run BQAT analysis and compile a EDA report

    ```sh
    bqat --mode fingerprint --input data/fingerprint --report
    ```

## Flags for BQAT

Please refer to the documentation of [BQAT](https://biometix.github.io/) further details.

## Flags for the Python CLI

| Flag | Description |
| --- | --- |
| --help | Print help info. |
| --version, -V | Display version info. |
| --update, -U | Update BQAT backend container. |
| --uninstall | Uninstall BQAT-CLI. |
sf-backtester 0.1.1
Add your description here
Requires Python: >=3.13

# sf-backtester

SLURM-based parallel backtesting for quantitative finance. Distributes MVO optimization across compute nodes, processing one year per task.

## Installation

```bash
pip install sf-backtester
```

## Usage

### CLI

```bash
# Run backtest
sf_backtester run config.yml

# Preview sbatch script without submitting
sf_backtester run config.yml --dry-run
```

### Python API

```python
from sf_backtester import BacktestRunner, BacktestConfig

slurm_config = SlurmConfig(
    n_cpus=8,
    mem="32G",
    time="03:00:00",
    mail_type="BEGIN,END,FAIL",
    max_concurrent_jobs=30,
)

config = BacktestConfig(
    signal_name="momentum",
    gamma=50,
    data_path="/path/to/alphas.parquet",
    project_root="/path/to/project",
    byu_email="you@byu.edu",
    constraints=["ZeroBeta", "ZeroInvestment"],
    slurm=slurm_config,
)

runner = BacktestRunner(config)

# Preview the sbatch script
print(runner.dry_run())

# Submit to SLURM
runner.submit()
```

Or load from YAML:

```python
from sf_backtester import BacktestRunner

runner = BacktestRunner.from_yaml("config.yml")

runner.submit()
```

You can also pass a DataFrame directly:

```python
from sf_backtester import BacktestRunner
import polars as pl

runner = BacktestRunner.from_yaml("config.yml")

data = pl.read_parquet("alphas.parquet")

runner.submit(data=data)
```

## Configuration

### YAML format

```yaml
signal_name: momentum
gamma: 500
data_path: /path/to/alphas.parquet
project_root: /path/to/project
email: you@byu.edu

constraints:
  - ZeroBeta
  - ZeroInvestment

slurm:
  n_cpus: 8
  mem: 32G
  time: "03:00:00"
  mail_type: BEGIN,END,FAIL
```

## Data format

Input parquet must have columns:
- `date`: Date column
- `barrid`: Asset identifier  
- `alpha`: Alpha signal values
- `predicted_beta`: Predicted beta values

Output is one parquet per year in `output_dir/{year}.parquet` containing portfolio weights.

## Publishing
1. Bump the version

```bash
uv version v*.*.*
```

2. Add changes (it can be just the version change)

```bash
git add .
git commit -m "Bumped version."
```

3. Tag the branch

```bash
git tag v*.*.*
```

4. Push to origin

```bash
git push origin/main --tags
```
amplify-bbopt 1.1.0
Black box optimization library based on Amplify SDK
Requires Python: >=3.10

# Amplify-BBOpt

Amplify-BBOpt is a powerful Python package by [Fixstars Amplify](https://amplify.fixstars.com/en), designed to streamline the implementation and execution of black-box optimization algorithms.

*   Documentation:  
 <https://amplify.fixstars.com/docs/amplify-bbopt/v1/>
*   Contributing (bug reports, improvements):  
 <https://amplify.fixstars.com/en/contact>

## Features

Amplify-BBOpt is built upon the powerful [Amplify SDK](https://amplify.fixstars.com/en/docs/amplify/), bridging the gap between black-box optimization and specialized hardware. It uniquely offers annealing-based optimization methods, including Factorization Machine Quantum Annealing (FMQA) and Kernel-QA, which are designed to run on quantum annealers and various Ising machine backends.

*   **Intuitive API**: A clean, straightforward interface enables rapid experimentation and allows users to easily swap between different optimization methods.
*   **High-Dimensional Scalability**: Engineered to effectively solve complex optimization problems, even those with a high-dimensional parameter space.
*   **Built-in Constraint Handling**: Natively supports both unconstrained and constrained optimization problems, providing a versatile framework for real-world applications.

## Basic Usage

```py
from amplify import FixstarsClient

from amplify_bbopt import FMTrainer, Optimizer, RealVariable, blackbox


# Define a test function
# (This represents a simulation or experiment)
def spherical_func(a: float, b: float) -> float:
    return (a + 1) ** 2 + (b - 1) ** 2


# Make a black-box function and define relevant decision variables
@blackbox
def bb_func(
    a: float = RealVariable((-5, 5)),  # type: ignore
    b: float = RealVariable((-5, 5)),  # type: ignore
) -> float:
    return spherical_func(a, b)


# Prepare solver client
client = FixstarsClient()
client.parameters.timeout = 1000

# Execute optimization
opt = Optimizer(bb_func, FMTrainer(), client)
opt.add_random_training_data(num_data=5)
opt.optimize(num_iterations=10)

# View results
print(opt.best.objective)
print(opt.best.values)
```

## For Developers

Amplify-BBOpt requires Python 3.10 or later.
Also, it depends on `amplify` and `torch` packages, which can be installed via pip.
After installing the dependencies, you can install Amplify-BBOpt in editable mode.

```bash
$ pip install -e amplify-bbopt
```

Instead, we recommend using `uv` for managing the development environment and running tests.

```bash
$ uv sync
```

Testing:

```bash
$ uv run pytest
```
sigma-computing-cli 0.1.0
CLI tool for managing Sigma data models with Git workflows
Requires Python: >=3.9

# Sigma CLI
A CLI tool for managing Sigma data models with Git. It provides a simple interface for interacting with Sigma's data model APIs
and provides an easy workflow to write, review and deploy Sigma data models as code.

## Quick Start
1. To authenticate, add your Client ID, client secret, and base URL to credentials.yml in the .sigma directory.

``` yaml
profiles:
  default:
    base_url: https://api.staging.us.aws.sigmacomputing.io
    client_id: your_client_id
    client_secret: your_client_secret
```
2. Next install sigma-sdlc
```bash
pip install sigma-sdlc
```
3. Sync your data models:
```bash
sigma sync
```
You're ready to go!

## Features
* Authentication: A simple way to generate an auth token using a client and secret from Sigma
* Sync data models from Sigma to your Git repo: Sigma is the source of truth for data model code. The sync command makes sure your remote repo incorporates all changes made in Sigma
* Deploy data models to Sigma: Deploy all changes made locally to Sigma


## Essential Commands
* `sigma login`: Authenticates with Sigma and stores credentials
* `sigma sync`: Syncs data models from Sigma to your local repo
* `sigma deploy`: Deploys data models to Sigma

## Example Workflow
1. Make sure you have authenticated with `sigma login`
2. Sync data models from Sigma to your local repo with `sigma sync`
3. Make changes to the data models in your local repo
4. Deploy the changes to Sigma with `sigma deploy`
scopinator 2026.1.26
A library for controlling telescopes (initially Seestars)
Requires Python: >=3.12

# Scopinator

A library for controlling telescopes (initially Seestars).

## Example commands

uv run scopinator status
uv run scopinator discover
uv run scopinator version
uv run scopinator device-state --all --host 192.168.42.41
uv run scopinator device-state --all --json --host 192.168.42.41
uv run scopinator device-state --all --json --host 192.168.42.41 | fx
uv run scopinator capture-video --host 192.168.42.41 --duration 10
uv run scopinator monitor
uv run scopinator monitor --host 192.168.42.41
uv run scopinator monitor --host 192.168.42.41 --json
uv run scopinator monitor --host 192.168.42.41 -i pi_get_time
uv run scopinator stream-images --host 192.168.42.41 --show-events
uv run scopinator stream-images --host 192.168.42.41 --compact
uv run scopinator stream-images --host 192.168.42.41 --compact --scenery --save scenery.mp4
uv run scopinator stream-images --host 192.168.42.41 --compact --scenery --save scenery.mp4 --save-video
uv run scopinator stream-images --host 192.168.42.41 --compact --save scenery.mp4 --save-video --count 50 --scenery
uv run scopinator repl
SCOPINATOR_DEBUG=false  uv run scopinator repl 
SCOPINATOR_TRACE=true SCOPINATOR_DEBUG=true uv run scopinator stream-images --host 192.168.42.41 --compact

## Versioning

This project uses [CalVer](https://calver.org/) versioning in a SemVer-compatible format:

**Format: `YYYY.MM.PATCH`**

- `YYYY`: Full year (e.g., 2025)
- `MM`: Month without zero-padding (e.g., 8 for August)
- `PATCH`: Patch version for bug fixes within the month (starts at 0)

This format is compatible with Semantic Versioning where:
- `YYYY` acts as the MAJOR version
- `MM` acts as the MINOR version
- `PATCH` acts as the PATCH version

Example: `2025.8.0` means the first release in August 2025.