semvec/pypi-packages huggingface dataset:
brainstate 0.2.10
A State-based Transformation System for Brain Modeling.
Requires Python: >=3.10
Keywords: computational neuroscience, brain-inspired computing, brain simulation, brain modeling, spiking neural networks


# A ``State``-based Transformation System for Brain Modeling



<p align="center">
  	<img alt="Header image of brainstate." src="https://raw.githubusercontent.com/chaobrain/brainstate/main/docs/_static/brainstate.png" width=40%>
</p> 



<p align="center">
	<a href="https://pypi.org/project/brainstate/"><img alt="Supported Python Version" src="https://img.shields.io/pypi/pyversions/brainstate"></a>
	<a href="https://github.com/chaobrain/brainstate/blob/main/LICENSE"><img alt="LICENSE" src="https://img.shields.io/badge/License-Apache%202.0-blue.svg"></a>
  	<a href='https://brainstate.readthedocs.io/?badge=latest'>
        <img src='https://readthedocs.org/projects/brainstate/badge/?version=latest' alt='Documentation Status' />
    </a>
    <a href="https://badge.fury.io/py/brainstate"><img alt="PyPI version" src="https://badge.fury.io/py/brainstate.svg"></a>
    <a href="https://github.com/chaobrain/brainstate/actions/workflows/CI.yml"><img alt="Continuous Integration" src="https://github.com/chaobrain/brainstate/actions/workflows/CI.yml/badge.svg"></a>
    <a href="https://pepy.tech/projects/brainstate"><img src="https://static.pepy.tech/badge/brainstate" alt="PyPI Downloads"></a>
    <a href="https://doi.org/10.5281/zenodo.14970015"><img src="https://zenodo.org/badge/811300394.svg" alt="DOI"></a>
</p>


## Installation

You can install ``brainstate`` via pip:

```bash
pip install brainstate --upgrade
```

Alternatively, you can install `BrainX`, which bundles `brainstate` with other compatible packages for a comprehensive brain modeling ecosystem:

```bash
pip install BrainX -U
```

## Documentation

The official documentation is hosted on Read the Docs: [https://brainstate.readthedocs.io/](https://brainstate.readthedocs.io/)



## See also the ecosystem

``brainstate`` is one part of our brain simulation ecosystem: https://brainmodeling.readthedocs.io/
sofia-redux 1.4.2
SOFIA data reduction pipelines
Requires Python: >=3.11

SOFIA Data Reduction Pipelines
==============================

.. image:: http://img.shields.io/badge/powered%20by-AstroPy-orange.svg?style=flat
    :target: http://www.astropy.org
    :alt: Powered by Astropy Badge

.. image:: https://zenodo.org/badge/DOI/10.5281/zenodo.17980054.svg
    :target: https://doi.org/10.5281/zenodo.17980054
    :alt: DOI Badge


SOFIA Redux (`sofia_redux`) contains data processing pipelines and algorithms
for instruments on the Stratospheric Observatory for Infrared Astronomy
(SOFIA).

Currently, the SOFIA instruments supported by this package are the FORCAST
and FLITECAM imaging and spectroscopic instruments, the FIFI-LS integral field
spectrometer, the HAWC+ imaging and polarimetric instrument, and the EXES
high resolution spectrometer.

SOFIA raw and processed data can be accessed from the
`SOFIA archive <https://irsa.ipac.caltech.edu/applications/sofia/>`__.
Archived data may not match the results of data processed
with this pipeline software.

SOFIA pipelines are developed internally by the
`SOFIA Data Center <https://www.irs.uni-stuttgart.de/en/research/satellitetechnology-and-instruments/SOFIA-Data-Center/>`__
software team, then are published publicly at the
`SOFIA Redux GitHub project
<https://github.com/SOFIA-Data-Center/sofia_redux>`__.
Contributions and feedback are welcome via the GitHub project.

For more information about installing and using this package, see
the `online documentation <https://pages.github.tik.uni-stuttgart.de/IRS-SOFIA-Data-Center/sofia_redux/>`__,
or `docs/install.rst <docs/install.rst>`__ in the source distribution.

License
-------

This project is Copyright (c) SOFIA Data Center,
Institute of Space Systems, University of Stuttgart,
funded through the German Aerospace Agency DLR under grant 50OK2404,
formerly maintained by the Universities Space Research Association
under Government Prime Contract Number NNA17BF53C and licensed under
the terms of the BSD 3-Clause license.

This package is released under the BSD 3-clause license by written permission
from Dr. Attila Kovacs, copyright holder of the CRUSH software, which is the
original work of authorship for the sofia_redux.scan module.

This package is also based upon the
`Astropy package template <https://github.com/astropy/package-template>`_
which is licensed under the BSD 3-clause license.

See the LICENSE.rst for more information.
notifsh 0.2.1
Python SDK for notif.sh event hub
Requires Python: >=3.11
Keywords: async, events, notif, notifsh, pubsub, webhooks, websocket

# notifsh

Python SDK for [notif.sh](https://notif.sh) event hub.

## Installation

```bash
pip install notifsh
```

## Quick Start

```python
import asyncio
from notifsh import Notif

async def main():
    # Uses NOTIF_API_KEY env var by default
    async with Notif() as n:
        # Emit an event
        await n.emit('leads.new', {'name': 'John', 'email': 'john@example.com'})

        # Subscribe to events (auto-ack by default)
        async for event in n.subscribe('leads.*'):
            print(f"Received: {event.topic} - {event.data}")

asyncio.run(main())
```

## Configuration

```python
from notifsh import Notif

# Using environment variable (recommended)
# Set NOTIF_API_KEY=nsh_your_api_key
client = Notif()

# Or pass API key directly
client = Notif(api_key='nsh_your_api_key')

# With custom server
client = Notif(server='http://localhost:8080')
```

## Emitting Events

```python
async with Notif() as n:
    result = await n.emit('orders.created', {
        'order_id': '12345',
        'amount': 99.99,
    })
    print(f"Event ID: {result.id}")
```

## Subscribing to Events

```python
async with Notif() as n:
    # Subscribe to multiple topics
    async for event in n.subscribe('orders.*', 'payments.*'):
        print(f"{event.topic}: {event.data}")

    # Manual acknowledgment
    async for event in n.subscribe('orders.*', auto_ack=False):
        try:
            process(event.data)
            await event.ack()
        except Exception:
            await event.nack('5m')  # Retry in 5 minutes

    # Consumer groups (load-balanced)
    async for event in n.subscribe('jobs.*', group='worker-pool'):
        await process_job(event.data)

    # Start from beginning
    async for event in n.subscribe('orders.*', from_='beginning'):
        print(event.data)
```

## Error Handling

```python
from notifsh import Notif, AuthError, APIError, ConnectionError

try:
    async with Notif() as n:
        await n.emit('test', {'data': 'value'})
except AuthError:
    print("Invalid API key")
except APIError as e:
    print(f"API error ({e.status_code}): {e}")
except ConnectionError as e:
    print(f"Connection failed: {e}")
```

## Requirements

- Python 3.11+
- httpx
- websockets

## License

MIT
zeughaus-mcp 0.1.4
MCP Server - Agentic Workbench backed by Nixery
Requires Python: >=3.10

# zeughaus-mcp

MCP Server - Agentic Workbench backed by Nixery.

Execute commands in ephemeral containers with any combination of Nix packages.

## Installation

### Docker (recommended)

Docker is the recommended installation method because it provides **workspace isolation** - the MCP server itself runs in a container with access only to your specified workspace directory.

```bash
docker run --rm -i \
  -v /var/run/docker.sock:/var/run/docker.sock \
  -v /path/to/workspace:/workspace \
  -e NIXERY_REGISTRY_URL=nixery.zeughaus.dev \
  -e HOST_WORKSPACE_ROOT=/path/to/workspace \
  ghcr.io/gtarkin/zeughaus_mcp:latest
```

### uvx (alternative)

> **Note:** When running via uvx, the MCP server has full access to the host system. Use Docker for better isolation.

```bash
uvx zeughaus-mcp
```

## Configuration

Environment variables:

| Variable | Required | Default | Description |
|----------|----------|---------|-------------|
| `NIXERY_REGISTRY_URL` | Yes | - | Nixery registry URL (see below) |
| `HOST_WORKSPACE_ROOT` | Yes | - | Workspace path to mount into containers |
| `DOCKER_NETWORK_MODE` | No | `host` | Docker network mode |
| `CONTAINER_TIMEOUT_SECONDS` | No | `300` | Container execution timeout |

## Nixery Registries

[Nixery](https://nixery.dev) is a Docker-compatible registry that builds container images on-the-fly from Nix packages.

### Available Registries

| Registry | Channel | Description |
|----------|---------|-------------|
| `nixery.zeughaus.dev` | nixos-25.11 | Self-hosted instance for zeughaus-mcp (recommended) |
| `nixery.dev` | nixos-unstable | Public Nixery instance by Google |

### nixery.zeughaus.dev (Recommended)

The default registry for zeughaus-mcp. This is a self-hosted Nixery instance with:
- **Nix Channel:** `nixos-25.11` (stable packages)
- **Source:** [github.com/NixOS/nixpkgs](https://github.com/NixOS/nixpkgs)
- **Build timeout:** 600 seconds

### nixery.dev (Alternative)

The public Nixery instance maintained by Google. Use this if you prefer:
- **Nix Channel:** `nixos-unstable` (latest packages)
- No dependency on third-party infrastructure

To use the public registry, set:
```
NIXERY_REGISTRY_URL=nixery.dev
```

## MCP Client Configuration

### Claude Desktop (Docker - recommended)

```json
{
  "mcpServers": {
    "zeughaus": {
      "command": "docker",
      "args": [
        "run", "--rm", "-i",
        "-v", "/var/run/docker.sock:/var/run/docker.sock",
        "-v", "/path/to/workspace:/workspace",
        "-e", "NIXERY_REGISTRY_URL=nixery.zeughaus.dev",
        "-e", "HOST_WORKSPACE_ROOT=/path/to/workspace",
        "ghcr.io/gtarkin/zeughaus_mcp:latest"
      ]
    }
  }
}
```

### Claude Desktop (uvx)

```json
{
  "mcpServers": {
    "zeughaus": {
      "command": "uvx",
      "args": ["zeughaus-mcp"],
      "env": {
        "NIXERY_REGISTRY_URL": "nixery.zeughaus.dev",
        "HOST_WORKSPACE_ROOT": "/path/to/workspace"
      }
    }
  }
}
```

## License

MIT
pyshielder 1.0.4
A robust tool for Python code obfuscation and encryption using Cython.
Requires Python: >=3.6

# pyshielder - Python Code Shield

![Python Version](https://img.shields.io/badge/python-3.x-blue.svg)
![License](https://img.shields.io/badge/license-MIT-green.svg)

`pyshielder` is a powerful tool to protect your Python code. It combines advanced multi-layer bytecode obfuscation with native compilation to create highly secure executable scripts.

## Features

- **Advanced Layering**: Compiles code to bytecode, serializes with Marshal, compresses with Zlib, encodes with Base64, and obfuscates the structure.
- **Strong Encryption**: Wraps the obfuscated payload in a secure loader encrypted with rolling-key XOR.
- **Native Compilation**: The final loader is compiled into a native C binary using Cython and GCC, executing directly in memory.
- **Tamper Resistant**: No original source code or simple bytecode is visible. Reverse engineering requires reconstructing multiple layers of obscured logic.
- **Self-contained**: The output is a single Python script that self-compiles and executes.

## Installation

```bash
pip install pyshielder
```

*Note: You need `gcc` (or `clang`) and `python3-dev` installed on your system to use the encryption tool and to run the generated protected scripts.*

## Usage

### Command Line Interface

You can use `pyshielder` directly from the command line:

```bash
# Encrypt a file
pyshielder my_script.py

# Specify output directory
pyshielder my_script.py protected_script.py
```

### Python API

```python
from pyshielder import encrypt

# Encrypt a script string
code = "print('Hello, protected world!')"
loader_code = encrypt(code)

# Save the loader to a file
with open("protected_script.py", "w") as f:
    f.write(loader_code)
```

## License

MIT License - see [LICENSE](LICENSE) for details.
ms2function 0.1.1
Deep learning model for MS2 data annotation
Requires Python: >=3.8

# MS2Function

MS2Function provides MS2 spectrum annotation and metabolite set analysis powered by
MS2BioText models. Large model/data assets are hosted on Hugging Face Hub and are
downloaded automatically on first use.

## Install

```bash
pip install ms2function
```

Or for local development:

```bash
pip install -e .
```

## Assets (Hugging Face Hub)

Default asset repo: `cgxjdzz/ms2function-assets`

The package looks for the following files:

- `models/best_model.pth`
- `models/config.json`
- `data/hmdb_subsections_WITH_NAME.jsonl`
- `data/all_jsonl_embeddings.pt`

Environment overrides:

- `MS2FUNCTION_ASSET_DIR` (use local assets directory)
- `MS2FUNCTION_ASSET_REPO` (override HF repo id)
- `HUGGINGFACE_HUB_TOKEN` or `HF_TOKEN` (for private repos)

## Quickstart (single spectrum)

```python
from pathlib import Path
from MS2Function import run_single

json_input = {
    "peaks": [[100.1, 200.0], [150.2, 300.0]],
    "precursor_mz": 250.3,
}

result = run_single(json_input, project_root=Path(r"d:\NTU\MS2Function"))
print(result)
```

## Quickstart (metabolite set)

```python
from pathlib import Path
from MS2Function import run_set

result = run_set(
    r"d:\path\to\your.csv",
    project_root=Path(r"d:\NTU\MS2Function"),
)
print(result)
```
jal 2026.1.1
Just Another Ledger - project to track personal financial records
Requires Python: >=3.8.1

# JAL 
Just Another Ledger is a project for personal finance tracking.

It was designed to keep records of personal incomes/spendings and investments with up-to-date information about account's balances and portfolio value.

### Main features
- multiple accounts with different currencies (base currency is russian rouble but might be changed in future versions)
- 5 types of transactions: 
    1. Generic income/spending operations that may be split into several categories
    2. Asset and money transfers between accounts (with currency conversion if required)
    3. Buy/Sell operation for securities (jal supports stocks, ETFs, options, partial support of bonds and futures)
    4. Dividend for stocks and Interest payments for bonds
    5. Corporate actions for stocks (Split, Symbol change, Merger, Spin-Off, Stock dividend)
    6. Term deposits. 
- basic reports:
    1. Daily history of account balance.
    2. Portfolio asset allocation for a given date.
    3. Monthly income/expenditure by category. 
    4. Investment profit/loss and history of payments for an assets. 
    5. Closed deals summary.
- stock/ETF quotes updates for US (Yahoo), EU (Euronext), CA (TSX) and RU (MOEX) exchanges traded stocks
- Broker statement import:
    1. Russian: Uralsib broker (zipped xls), KIT Finance (xlsx), PSB broker (xls), Open broker (xml).
    2. International: Interactive Brokers Flex statement (xml), Just2Trade (xls).
- Investments report for tax declaration preparation for Russia and Portugal.  
Russian tax estimation for open positions.
- *experimental* Download russian electronic slips from russian tax authority (FNS). This function requires authorization and `pyzbar` package installation for QR recognition.  
You may authorize via SMS, FNS personal account or ESIA/Gosuslugi. QR code may be scanned from camera, clipboard image or image file on disk.

Full description is available at Github - *[English](https://github.com/titov-vv/jal/blob/master/docs/README.md), [Русский](https://github.com/titov-vv/jal/blob/master/docs/README.ru.md)*

Support: [jal@gmx.ru](mailto:jal@gmx.ru?subject=%5BJAL%5D%20Help) or [Telegram](https://t.me/jal_support)
shrecc 0.0.4
SHRECC: Smooth Hourly Resolution Electricity Consumption Calculation
Requires Python: >=3.10

# SHRECC

Simple Hourly Resolution Electricity Consumption Calculation

## Description

SHRECC package is a python package directly compatible with Brightway2 or Brightway2.5 to create time-aware electricity databases. For any given year and countries (check availability on https://api.energy-charts.info/), download and prepare data for low-voltage electricity consumption.

## Features

- **High-resolution electricity mixes** – Generates electricity life cycle inventories (LCIs) with **hourly** resolution, enhancing accuracy for life cycle assessment (LCA).
- **Brightway2/2.5 compatibility** – Seamlessly integrates with Brightway, allowing direct use in existing LCA models.
- **Dynamic temporal representation** – Users can select electricity mixes by **hour, month, or season**, addressing fluctuations in renewable energy generation and consumption.
- **Automated data retrieval** – Pulls electricity production, trade, and consumption data from the **Energy Charts API**, ensuring up-to-date datasets.
- **Ecoinvent matching** – Aligns with **ecoinvent classifications**, converting from ENTSO-E datasets.
- **User-controlled updates** – Enables **one-time or recurring** updates, allowing continuous tracking of electricity mix evolution over time.
- **Optimized impact assessments** – Helps reduce uncertainty and improve **decision-making for electricity-intensive technologies** by considering real-time electricity mix variations.

## Documentation

The full documentation is hosted at [Read the Docs page for shrecc](https://shrecc.readthedocs.io/en/latest/)

## Installation

`shrecc` can be installed from pypi or from source.

### From pypi

The package is published at [pypi.org/projects/shrecc](https://pypi.org/project/shrecc).
You can install it with pip (or any other pypi compatible util like `uv` or `poetry` as follows:

```
pip install shrecc
```

### From source 

To install shrecc from source, clone the code and then install the package and if necessary the dependencies manually.


## Usage

You can find usage examples in the Jupyter notebook in this repo: [notebooks/example.ipynb](notebooks/example.ipynb)
_and_ in the documentation at [read the docs](https://shrecc.readthedocs.io/en/latest/content/notebooks/notebooks.html).


## Contributing

Please take a look at the [DEVELOPPING.md](https://git.list.lu/shrecc_project/shrecc/-/blob/main/DEVELOPPING.md) file for details on how to contribute code to the repository.

## License

Copyright © 2025 Luxembourg Institute of Science and Technology
Licensed under the MIT License.

## Authors

* Sabina Bednářová (<sabina.bednarova@list.lu>)
* Thomas Gibon (<thomas.gibon@list.lu>)
pointcloudcrafter 1.2.4
Tools for Handling, Manipulating and Analyzing of Point Clouds
Requires Python: >=3.10
Keywords: point cloud, LiDAR, C++, ROS2, PCL

<div align="center">
    <img src="docs/assets/logo.svg" alt="pointcloudcrafter" width="600" style="margin-bottom: 30px;">
</div>

<div align="center">

A toolkit for extracting, manipulating, and evaluating point clouds and 3D spatial maps. Includes functions for processing, analyzing, and visualizing point clouds, designed to streamline workflows in 3D mapping and general point cloud handling. Ideal for researchers and developers working with LiDAR, SLAM, and 3D spatial data.

[![Linux](https://img.shields.io/badge/os-linux-blue.svg)](https://www.linux.org/)
[![Docker](https://badgen.net/badge/icon/docker?icon=docker&label)](https://www.docker.com/)
[![ROS2humble](https://img.shields.io/badge/ros2-humble-blue.svg)](https://docs.ros.org/en/humble/index.html)
[![PyPI](https://github.com/TUMFTM/PointCloudCrafter/actions/workflows/pypi.yml/badge.svg)](https://github.com/TUMFTM/PointCloudCrafter/actions/workflows/pypi.yml)
[![docs](https://github.com/TUMFTM/PointCloudCrafter/actions/workflows/docs.yml/badge.svg)](https://github.com/TUMFTM/PointCloudCrafter/actions/workflows/docs.yml)
</div>

<h2> Install </h2>

```bash
    pip install pointcloudcrafter
```

<h2> Usage </h2>

We provide a standalone Pip package, which is self-contained, so you do not have to worry about any dependencies and possible conflicts. We also provide the tool as ROS2 package. Both feature the full functionality, so you can decide what suits your needs best.

For rosbag-processing:

```bash
    pointcloudcrafter-rosbag -h

    ros2 run pointcloudcrafter rosbag -h
```

For file-processing:

```bash
    pointcloudcrafter-file -h

    ros2 run pointcloudcrafter file -h
```

<h2> Documentation</h2>

For more details on the features and how to use them, take a look at the [documentation](https://TUMFTM.github.io/PointCloudCrafter) hosted on GitHub Pages:  
[**https://TUMFTM.github.io/PointCloudCrafter**](https://TUMFTM.github.io/PointCloudCrafter)

<h2> Cloning without test data (recommended) </h2>

This repository uses Git LFS for large test files (22 MB).
Most users do not need them.

Clone without downloading LFS files:

```bash
    GIT_LFS_SKIP_SMUDGE=1 git clone https://github.com/TUMFTM/PointCloudCrafter.git
```

To download them later:

```bash
    git lfs pull
```

## Contact

[Dominik Kulmer](mailto:dominik.kulmer@tum.de)  
[Maximilian Leitenstern](mailto:maxi.leitenstern@tum.de)  
Institute of Automotive Technology, School of Engineering and Design, Technical University of Munich, 85748 Garching, Germany