semvec/pypi-packages huggingface dataset:
pyiron-glass 0.0.12
Workflows for atomistic modeling of oxide glasses

# Workflows for atomistic modeling of oxide glasses

This project aims at setting up pyiron-workflows to perform atomistic simulations for glasses.
This concerns, but is not limited to, generating initial structural models, performing melt-quenching simulations as well as analysing relevant properties. 

Later, these workflows serve as blueprints intended to be used by "Otto", the GlasAgent.
dustr 0.1.10
Rust-based disk usage analyzer with histogram visualization
Requires Python: >=3.9

# Dustr

Dustr is a Rust-based implementation of [duk](https://github.com/wvangeit/duk), a commandline utility that shows disk usage statistics in a directory with a histogram visualization.

## Introduction

Dustr provides the same functionality as duk but with a Rust backend for improved performance. It will show you a histogram of the disk usage in a directory:

```bash
>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>

Statistics of directory "." :

in kByte       in %   histogram            name
4              1.39   #                    .gitignore
4              1.39   #                    setup.py
4              1.39   #                    .travis.yml
4              1.39   #                    README.md
12             4.17   ##                   dist/
12             4.17   ##                   dustr/
12             4.17   ##                   build/
16             5.56   ##                   duk.egg-info/
220            76.39  #################### .git/

Total directory size: 288 kByte
```

## Installation

### From PyPI (once published)

```bash
pip install dustr
```

### From source

First, ensure you have Rust installed (see [rustup.rs](https://rustup.rs/)).

Then install maturin:

```bash
pip install maturin
```

Build and install the package:

```bash
cd dustr
maturin develop  # For development
# OR
maturin build --release  # To build a wheel
pip install target/wheels/dustr-*.whl
```

## Usage

```bash
dustr [directory]
```

Options:

- `--nogrouping`: Don't group thousands with commas
- `--noprogress`: Don't show progress bar (note: Rust version calculates all at once, so this has less effect)
- `--inodes`: Show inode count instead of size
- `--noF`: Don't add file type indicators (/ for directories, @ for symlinks)

## Differences from duk

- **Performance**: Rust backend provides faster directory traversal
- **Implementation**: Uses native Rust file system operations instead of calling `du` command
- **Progress**: Since the Rust implementation calculates all sizes in parallel, progress indication is less granular

## Requirements

- Python >= 3.9
- Rust toolchain (for building from source)

## License

LGPL-3.0-or-later
iflow-mcp_rsc1102-google_calendar_mcp 0.1.0
An MCP server to interact with Google Calendar
Requires Python: >=3.11

# Google Calendar MCP Server ![Anthropic](https://img.shields.io/badge/Anthropic-ffffff?logo=anthropic&logoColor=black) ![Claude](https://img.shields.io/badge/Claude-ffffff?logo=claude&logoColor=orange)

This repository provides a Model Context Protocol (MCP) server that integrates with the Google Calendar API. It allows users to list, create, delete, and update calendar events. The server is designed to work with Anthropic's Claude Desktop as an MCP client.

## 🚀 Features
- Interact with Google Calendar: list, add, delete, and update events
- Seamless integration with Claude Desktop via MCP

---

## 🧰 Prerequisites
- A Google Account
- [Anthropic Claude Desktop](https://claude.ai/download)

---

## 📦 Installation

1. **Install UV Package Manager:**
   Follow the instructions on the [official UV installation guide](https://docs.astral.sh/uv/getting-started/installation/#installation-methods).

2. **Clone the Repository and Set Up Environment:**
   ```bash
   git clone https://github.com/rsc1102/Google_Calendar_MCP.git
   cd Google_Calendar_MCP
   uv sync
   ```

3. **Create Google Cloud Credentials:**
   - Visit [Google Cloud Console](https://console.cloud.google.com/).
   - Create a new project or select an existing one.
   - Enable the **Google Calendar API**.
   - Navigate to **APIs & Services > Credentials**.
   - Click **Create Credentials > OAuth Client ID**:
     - Choose **Desktop app** as the application type.
     - Download the generated `credentials.json` file.
     - Place `credentials.json` inside the `Google_Calendar_MCP` directory.

---

## 🔌 Integration with Claude Desktop

1. **Locate Configuration File:**
   Open the `claude_desktop_config.json` file on your system:

   **Linux/macOS:**
   ```bash
   code ~/Library/Application\ Support/Claude/claude_desktop_config.json
   ```

   **Windows (PowerShell):**
   ```bash
   code $env:AppData\Claude\claude_desktop_config.json
   ```

2. **Add MCP Server Configuration:**
   Add the following to the `mcpServers` section:
   ```json
   {
       "mcpServers": {
           "calendar": {
               "command": "uv",
               "args": [
                   "--directory",
                   "/ABSOLUTE/PATH/TO/PARENT/FOLDER/Google_Calendar_MCP",
                   "run",
                   "calendar_mcp.py"
               ]
           }
       }
   }
   ```

3. **Restart Claude Desktop.**

4. **Create a New Project in Claude Desktop.**

5. **Set Timezone:**
   In the project's knowledge section, define your local timezone using the IANA Time Zone format (e.g., `timeZone="America/New_York"`).

6. **Start Chatting:**
   Begin interacting with Claude to manage your Google Calendar events.   
   **Note:** When using the server for the first time, Google will prompt you to authenticate and grant permission to access your calendar.

---
## 🎬 In Action


https://github.com/user-attachments/assets/75da4943-15c4-4ec2-bc5d-af4af3509031



---

## 📬 Support
For issues or questions, please open an issue in this repository.
pytest-regtest 2.3.6
pytest plugin for snapshot regression testing

![](https://gitlab.com/uweschmitt/pytest-regtest/badges/main/pipeline.svg)
![](https://gitlab.com/uweschmitt/pytest-regtest/badges/main/coverage.svg?job=coverage)


The full documentation for this package are available at
https://pytest-regtest.readthedocs.org

# About

## Introduction

`pytest-regtest` is a plugin for [pytest](https://pytest.org) to implement
**regression testing**.

Unlike [functional testing](https://en.wikipedia.org/wiki/Functional_testing),
[regression testing](https://en.wikipedia.org/wiki/Regression_testing)
does not test whether the software produces the correct
results, but whether it behaves as it did before changes were introduced.

More specifically, `pytest-regtest` provides **snapshot testing**, which
implements regression testing by recording data within a test function
and comparing this recorded output to a previously recorded reference
output.


## Installation

To install and activate this plugin execute:

    $ pip install pytest-regtest


!!! note

     `pytest-regtest` provides some functionality specific to `NumPy`,
     `pandas`, and `polars`. These dependencies are not installed when
     you install `pytest-regtest`. For example, if you are using NumPy
     snapshots, we assume that your production code (the code under
     test) uses NumPy and therefore should be part of your project's
     setup.


## Use case 1: Changing code with no or little testing setup yet
If you're working with code that has little or no unit testing, you
can use regression testing to ensure that your changes don't break or
alter previous results.

**Example**:
This can be useful when working with data analysis scripts, which often
start as one long script and then are restructured into different
functions as they evolve.


## Use case 2:  Testing complex data
If a unit tests contains many `assert` statements to check a complex
data structure you can use regression tests instead.

**Example**: To test code which ingests data into a database one can
use regression tests on textual database dumps.

## Use case 3: Testing NumPy arrays or pandas data frames

If your code generates numerical results, such as `NumPy` arrays,
`pandas` or `polars` data frames, you can use `pytest-regtest` to simply record such
results and test them later, taking into account relative and absolute
tolerances.


**Example**:
A function creates a 10 x 10 matrix. Either you have to write 100
assert statements or you use summary statistics to test your result.
In both cases, you may get little debugging information if a test
fails.
navigator-session 0.8.1
Navigator Session allows us to store user-specific data into session object.
Requires Python: >=3.9.13

# Navigator_Session #

Navigator_Session Allows us to store User-based data into a session Object, this session object exposes an dict-like interface and uses cookies or redis as persistent backend.

* Quick summary
* Version
* [Learn Markdown](https://bitbucket.org/tutorials/markdowndemo)

### Getting Started ###

* Installation
* Configuration
* Dependencies
* Database configuration
* How to run tests
* Deployment instructions

### Requirements ###

* Python >= 3.9
* asyncio (https://pypi.python.org/pypi/asyncio/)
* aiohttp >= 3.8
* Navigator-API >= 2.1

### License ###

Navigator_Session is copyright of Jesus Lara (https://phenobarbital.info) and under Apache 2 license. I am providing code in this repository under an open source license, remember, this is my personal repository; the license that you receive is from me and not from my employeer.
farsounder 0.1.1
Python client to communicate with FarSounder's ARGOS sensors
Requires Python: >=3.13

# Python API Client for Argos data

Python client to communicate with SonaSoft via API.

>[!NOTE]
> This is still under active development and testing. But may serve as an example for
> integration, beyond the lower level example in [sdk repo](https://github.com/farsounder/SDK-Integration-Examples).
> For now the docs are the interfaces and the examples in examples/

## Usage

Clone locally and install (uv add .) or install from pypi like:

```
uv add farsounder
```
(or use pip, etc)

Then - for example to subscribe to `TargetData` messages:

```python
import time

from farsounder import config, requests, subscriber
from farsounder.proto import nav_api_pb2


def main() -> None:

    # Build the configuration:
    # - where is the api running?
    # - what messages do you care about subscribing to?
    # - if ports are changed, they can overridden here
    cfg = config.build_config(
        host="127.0.0.1",
        subscribe=["TargetData"],
    )


    # Pub/Sub
    sub = subscriber.subscribe(cfg)
    # A callback to run when there are new target data messages
    # - don't do a lot of processing in here it will block (thank GIL - for now...)
    # - use sync mechanism if you're accessing shared data (callbacks
    #   run on thread pool [default] or on the receive thread for the message
    #   type)
    def on_targets(message: nav_api_pb2.TargetData) -> None:
        print("Got a TargetData!")
        print("Targets:", len(message.groups))

    # register the callback(s)
    sub.on("TargetData", on_targets)

    # start the receive loop
    sub.start()

    # Req/rep
    # for each of the request / reply endpoints - there are specific
    # get/set functions
    settings = requests.get_processor_settings(cfg)
    print(settings)

    history = requests.get_history_data(
        cfg,
        latitude=41.7223,
        longitude=-71.35,
        radius_meters=500,
    )
    print(history.gridded_bottom_detections)

    time.sleep(1.0)

    # Stop receive loop
    sub.stop()


if __name__ == "__main__":
    main()
```

## Simulated backend

You can run a local simulated backend that publishes dummy messages and responds
to request/reply calls:

```
uv run examples/simulated_backend.py
```

Note: the `examples/` directory is not installed with `uv add farsounder`.
Clone the repo to run the examples locally.

# Development

## Re-generate Protobuf stubs

Protobuf sources live in `proto/`. Generate Python stubs with:

```
uv run --group dev gen-protos
```

Or:

```
uv run tools/gen_protos.py
```

## Tests

Run tests with:

```
uv run --group dev pytest
```
flipcosmo 1.2.2
Field Level Inference Package
Requires Python: >=3.10

<img src="https://github.com/corentinravoux/flip/blob/main/docs/_static/flip_logo.webp?raw=true" width=350>

# flip: Field Level Inference Package

flip is a Python package that uses the maximum likelihood method to fit the growth rate based on the velocity and density fields. The first part of the software is the computation of a covariance matrix from a model power spectrum and the considered coordinates. This part is generalized to work for any linear power spectrum models, both for velocities, densities, and cross-terms, and it is optimized with Hankel transform for any model. In the second part, the covariance is used to create a likelihood by multiplying it by velocities or densities. Finally, this package includes some integrated fitters such as Minuit and MCMC (with emcee) to fit the growth rate of structures.


[![Documentation Status](https://readthedocs.org/projects/flip/badge/?version=latest)](https://flip.readthedocs.io/en/latest/?badge=latest)

## Quick install
```bash
git clone https://github.com/corentinravoux/flip.git
cd flip
pip install .
```
For now, the package requires you to install manually cosmoprimo: pip install git+https://github.com/cosmodesi/cosmoprimo


## Required packages

Mandatory: numpy, scipy, matplotlib, [cosmoprimo](https://github.com/adematti/cosmoprimo), iminuit, emcee, sympy

Optional: classy, pyccl, pypower, GPy, tensorflow 

## Examples

For an example with velocity fit check out: <a target="_blank" href="https://colab.research.google.com/github/corentinravoux/flip/blob/main/notebook/fit_velocity.ipynb">
  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
</a>

For density only: <a target="_blank" href="https://colab.research.google.com/github/corentinravoux/flip/blob/main/notebook/fit_density.ipynb">
  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
</a>

For a joint fit: <a target="_blank" href="https://colab.research.google.com/github/corentinravoux/flip/blob/main/notebook/fit_joint.ipynb">
  <img src="https://colab.research.google.com/assets/colab-badge.svg" alt="Open In Colab"/>
</a>

## Need help?
Documentation available on [ReadTheDoc](https://flip.readthedocs.io/) 

## How to cite

The full description of the core concepts of this package is given [here](https://arxiv.org/abs/2501.16852).
This package was started on the previous work of [@bastiencarreres](https://github.com/bastiencarreres), detail in [this article](https://arxiv.org/abs/2303.01198).
Please cite both paper when using the package.
cyqnt-trd 0.1.8
A cryptocurrency trading toolkit with data fetching, signal generation, and backtesting capabilities
Requires Python: <3.14,>=3.7

# cyqnt_trd

一个用于加密货币交易的工具包，包含数据获取、交易信号生成和回测功能。

## 功能特性

- **数据获取**: 从 Binance 获取期货和现货K线数据
- **交易信号**: 提供多种技术指标因子和信号策略
- **回测框架**: 支持因子测试和策略回测

## 安装

### 方式1: 作为可编辑包安装（推荐用于开发）

```bash
cd /path/to/cyqnt_trd
pip install -e .
```

### 方式2: 直接安装

```bash
cd /path/to/cyqnt_trd
pip install .
```

### 方式3: 从源码安装

```bash
cd /path/to/cyqnt_trd
python setup.py install
```

## 依赖

主要依赖包：
- pandas >= 1.5.0
- numpy >= 1.23.0
- matplotlib >= 3.5.0
- requests >= 2.28.0

Binance SDK 依赖（需要单独安装）：
- binance-sdk-spot
- binance-sdk-derivatives-trading-usds-futures
- binance-sdk-algo
- binance-common

安装依赖：
```bash
pip install -r requirements.txt
```

## 使用方法

### 作为 Python Package 使用

安装后，可以直接导入使用：

```python
# 导入数据获取模块
from cyqnt_trd.get_data import get_and_save_futures_klines, get_and_save_klines

# 导入交易信号模块
from cyqnt_trd.trading_signal.factor import ma_factor, rsi_factor
from cyqnt_trd.trading_signal.signal import ma_signal, factor_based_signal

# 导入回测框架
from cyqnt_trd.backtesting import BacktestFramework, FactorTester, StrategyBacktester

# 使用示例
data = get_and_save_futures_klines("BTCUSDT", interval="1h", limit=100)
framework = BacktestFramework(data_path="data/BTCUSDT_1h.json")
result = framework.test_factor(ma_factor, short_window=5, long_window=20)
```

### 运行示例脚本

```bash
# 作为模块运行
python -m cyqnt_trd.trading_signal.example_usage

# 运行测试脚本
python -m cyqnt_trd.test_script.realtime_price_tracker
```

## 项目结构

```
cyqnt_trd/
├── cyqnt_trd/          # 主包目录
│   ├── __init__.py         # 包初始化文件
│   ├── get_data/           # 数据获取模块
│   │   ├── __init__.py
│   │   ├── get_futures_data.py
│   │   └── get_trending_data.py
│   ├── trading_signal/     # 交易信号模块
│   │   ├── __init__.py
│   │   ├── factor/         # 因子模块
│   │   ├── signal/         # 信号策略模块
│   │   └── selected_alpha/ # Alpha因子模块
│   ├── backtesting/        # 回测框架
│   │   ├── __init__.py
│   │   ├── framework.py
│   │   ├── factor_test.py
│   │   └── strategy_backtest.py
│   └── test_script/        # 测试脚本
├── pyproject.toml          # 包配置文件
├── requirements.txt        # 依赖列表
└── README.md              # 说明文档
```

## 许可证

MIT License

Copyright (c) 2025 Haowen Wang
wfc3tools 1.6.1
Python Tools for HST WFC3 Data
Requires Python: >=3.9

WFC3TOOLS
=========

.. image:: https://github.com/spacetelescope/wfc3tools/actions/workflows/tests.yml/badge.svg?branch=main
    :target: https://github.com/spacetelescope/wfc3tools/actions/workflows/tests.yml
    :alt: tests

.. image:: https://readthedocs.org/projects/wfc3tools/badge/?version=latest
    :target: https://wfc3tools.readthedocs.io/en/latest/?badge=latest
    :alt: Documentation Status

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


For more information please see the `online documentation <https://wfc3tools.readthedocs.io/>`_.

To install using pip:

::

    pip install wfc3tools

    pip install --upgrade wfc3tools # if you already have an older version installed



Contributing
------------

Please open a new issue or new pull request for bugs, feedback, or new features
you would like to see.   If there is an issue you would like to work on, please
leave a comment and we will be happy to assist.   New contributions and
contributors are very welcome!

New to github or open source projects?  If you are unsure about where to start
or haven't used github before, please feel free to contact `HST Help Desk <https://stsci.service-now.com/hst>`_.

Feedback and feature requests?   Is there something missing you would like
to see?  Please open an issue or contact `HST Help Desk <https://stsci.service-now.com/hst>`_.

``wfc3tools`` follows the STScI Code of Conduct and strives to provide a
welcoming community to all of our users and contributors.


License
-------

``wfc3tools`` is licensed under a 3-clause BSD style license (see the ``LICENSE.txt`` file).
CADET 1.0.0
CADET metapackage.
Requires Python: <3.14,>=3.12

[![PyPI version](https://img.shields.io/pypi/v/cadet.svg)](https://pypi.org/project/cadet/)
[![Python](https://img.shields.io/pypi/pyversions/cadet.svg)](https://pypi.org/project/cadet/)
[![License](https://img.shields.io/github/license/cadet/cadet)](LICENSE)
[![CADET version compatibility](https://github.com/cadet/CADET-Metapackage/actions/workflows/test_compatibility.yml/badge.svg)](https://github.com/cadet/CADET-Metapackage/actions/workflows/test_compatibility.yml)

# CADET Platform Metapackage

This package is a **metapackage** for the CADET platform.

It does not provide any importable Python modules itself.
Its only purpose is to install a curated set of CADET Python packages.

## Default packages

Installing `cadet` will install the following packages:

* **CADET-Process**
  Process analysis, optimization, and design toolkit
  PyPI: [https://pypi.org/project/cadet-process/](https://pypi.org/project/cadet-process/)
  Repository: [https://github.com/cadet/CADET-Process](https://github.com/cadet/CADET-Process)

* **CADET-Python**
  Python interface for CADET
  Installed as a dependency of `cadet-process`
  PyPI: [https://pypi.org/project/cadet-python/](https://pypi.org/project/cadet-python/)
  Repository: [https://github.com/cadet/CADET-Python](https://github.com/cadet/CADET-Python)

## Installation

Install the CADET platform metapackage:

```
pip install cadet
```

## Optional dependencies

Install the CADET metapackage plus research data management support:

```
pip install "cadet[rdm]"
```

This additionally installs:

* **CADET-RDM**
  Research data management utilities
  PyPI: [https://pypi.org/project/cadet-rdm/](https://pypi.org/project/cadet-rdm/)
  Repository: [https://github.com/cadet/CADET-RDM](https://github.com/cadet/CADET-RDM)

## Full platform bundle

Install the full platform bundle (currently identical to `cadet[rdm]`):

```
pip install "cadet[all]"
```

The `all` extra exists as a stable entry point if additional optional components are added in the future.

## Important notes

* This is a **metapackage only**.
  There is no `cadet` Python module to import.

* **Do not depend on `cadet` in other Python packages.**
  If you are developing a library, depend directly on the specific CADET components you use, such as `cadet-process` or `cadet-python`.

* This metapackage installs `cadet-core` from PyPI as part of the curated CADET stack.
  Alternative installation channels (for example conda-forge) may also be used if desired.

## Documentation and support

General CADET documentation and project information can be found at:

* [https://www.cadet.github.io](https://www.cadet.github.io)
* [https://github.com/cadet](https://github.com/cadet)

## Contributing and releases

For maintainers and contributors, including details on version management, CI workflows, and the release process, see:

* [`CONTRIBUTING.md`](CONTRIBUTING.md)
qoro-divi 0.7.0
A Python library to automate generating, parallelizing, and executing quantum programs.
Requires Python: <3.13,>=3.11

# Divi

**Divi** is a Python library for generating quantum programs at scale. It allows users to parallelize quantum workloads, manage hardware or simulator execution, and interact with cloud-based compute clusters—all through a simple and flexible API.

Divi is designed to allow researchers, students, and enterprises to deploy quantum workloads efficiently across hybrid and distributed environments.

---

> [!IMPORTANT]
> Divi is under active development and in early stages. Users should expect frequent changes that are likely to be incompatible with previously published versions.

## 🚀 Features

- 🧠 **Smart Job Parallelization**: Automatically parallelizes your quantum programs based on task structure.
- 🌐 **Cloud Execution**: Send jobs to local or remote clusters with minimal configuration.
- 🔌 **Extensible API**: Easily integrate with your existing quantum stack.
- 📦 **Lightweight & Modular**: Install and use only what you need.

---

## 📦 Installation

Divi can be easily installed from Pypi

```bash
pip install qoro-divi
```

## 📚 Documentation

- Full documentation is available at: <https://docs.qoroquantum.net/divi>
- Tutorials can be found in the `tutorials` folder.

## 🧪 Testing

To run the test suite:

```bash
# Run all tests
pytest

# Run only API tests (requires API token)
pytest --run-api-tests
```

**Note:** Some tests require a Qoro API token to test the cloud REST API. Set the `QORO_API_KEY` environment variable or use the `--api-token` option. For local development, you can create a `.env`.