semvec/pypi-packages huggingface dataset:
can-data-2024-explorer 0.4.3
Library for viewing CAN bus data from HSM research machines.

# README - CAN Data Explorer

![iFOS logo](/assets/iFOS_Logo_klein_transparent.png)
![Project logo](/assets/co2forit.png)

___

### Data download and installation

1. Download the CAN data from the [CO2ForIT SharePoint][1].

2. Unzip the CAN data at
`2024Q2_Testdaten_Blankenhain/*/can_ifos_logs/CAN_logs.7z`.

3. If you're viewing this online, download the `CAN_Data_Explorer` directory.

4. Install the conda or [mamba][2]
Environment Manager if you don't have it yet
(You can check if you have it by typing `conda --version` on the command line).
If you only have conda, replace `mamba` with `conda` in the commands below.

5. Navigate to the CAN_Data_Explorer folder in the console. E.g.:

        cd /home/user/Downloads/CAN_Data_Explorer

6. Create a new environment from *environment.yml* file using:

        mamba env create -f environment.yml

### How to run the script

7. Run *CAN_Data_Explorer.py* in that environment. E.g.:

        mamba activate co2forit
        python -m CAN_Data_Explorer

8. Now the GUI should open.
    * Use the *Input Parameters* box to enter the locations of the CAN
    measurement files, the DBC file and the time period.
    * Use the *Fuel Calculator* tab to compute the fuel consumed in that time
    period.
    * Use the *Diagrams* tab to plot diagrams of selected CAN signals.
    The signal selection patterns are applied from top to bottom (like this: ↯);
    every signal is only plotted once.
    The <kbd>?</kbd> button brings up a PDF that explains the available signals.
    Create the diagram by clicking on *Draw the figure.*
    The time needed to create the diagram is proportional to the duration of the
    selected time period.
    You can pan and zoom these diagrams and save them to disk.

9. You can also integrate the functions from this library in your own Python
scripts. See:

        python
        >>> import CAN_Data_Explorer as cde
        >>> help(cde)

[1]: https://rifevdortmund.sharepoint.com/:f:/r/sites/CO2For-IT/Freigegebene%20Dokumente/Daten/2024Q2_Testdaten_Blankenhain?csf=1&web=1&e=rBQQkY.
[2]: https://mamba.readthedocs.io/en/latest/
autorace-tokyo-sports-scraper 0.1.9
東京スポーツのオートレース情報をスクレイピングするライブラリ
Requires Python: >=3.10

# Tokyo Sports Scraper

[![tests](https://github.com/autorace/tokyo-sports-scraper/actions/workflows/tests.yml/badge.svg)](https://github.com/autorace/tokyo-sports-scraper/actions/workflows/tests.yml)
[![publish](https://github.com/autorace/tokyo-sports-scraper/actions/workflows/publish.yml/badge.svg)](https://github.com/autorace/tokyo-sports-scraper/actions/workflows/publish.yml)
![issues](https://img.shields.io/github/issues/autorace/tokyo-sports-scraper)
![pull requests](https://img.shields.io/github/issues-pr/autorace/tokyo-sports-scraper)
[![last commit](https://img.shields.io/github/last-commit/autorace/tokyo-sports-scraper)](https://github.com/autorace/tokyo-sports-scraper/commits/main)
[![pypi](https://img.shields.io/pypi/v/autorace-tokyo-sports-scraper)](https://pypi.org/project/autorace-tokyo-sports-scraper/)
[![python](https://img.shields.io/badge/python-%3E%3D3.10-blue)](https://pypi.org/project/autorace-tokyo-sports-scraper/)
[![license](https://img.shields.io/github/license/autorace/tokyo-sports-scraper)](LICENSE)

東京スポーツのオートレース情報をスクレイピングするライブラリです。

## インストール
```bash
pip install autorace-tokyo-sports-scraper
```

## 使い方
```python
from tokyo_sports_scraper import scrape, Race, Rider

if __name__ == '__main__':
    race_info: Race = scrape('2025/08/04', 5, 8)

    print(f'タイトル: {race_info.title}')
    print(f'サブタイトル: {race_info.subtitle}')
    print(f'天候: {race_info.weather}')
    print(f'気温: {race_info.temperature}')
    print(f'湿度: {race_info.humidity}')
    print(f'走路温度: {race_info.pavement_temperature}')
    print(f'走路状況: {race_info.track_condition}')
    print('---')

    for rider_info in race_info.riders:
        print(f'車番: {rider_info.number}')
        print(f'名前: {rider_info.name}')
        print(f'LG: {rider_info.locker_ground}')
        print(f'期別: {rider_info.registration_term}')
        print(f'年齢: {rider_info.age}')
        print(f'車級: {rider_info.bike_class}')
        print(f'ランク: {rider_info.rank}')
        print(f'審査ポイント: {rider_info.points}')
        print(f'ハンデ: {rider_info.handicap}')
        print(f'試走タイム: {rider_info.trial_time}')
        print(f'試走偏差: {rider_info.trial_deviation}')
        print(f'平均試走タイム: {rider_info.average_trial_time}')
        print(f'平均競走タイム: {rider_info.average_race_time}')
        print(f'最高競走タイム: {rider_info.fastest_race_time}')
        print('---')
```

## ライセンス
Tokyo Sports Scraperは [MITライセンス](LICENSE) の元で公開されています。
qiskit-mps-initializer 0.2.4
Wavefunction initializers for Qiskit based on matrix product states (MPS)
Requires Python: >=3.10

# Qiskit MPS Initializer

![PyPI - License](https://img.shields.io/pypi/l/qiskit-mps-initializer)
![PyPI - Version](https://img.shields.io/pypi/v/qiskit-mps-initializer)
![PyPI - Python Version](https://img.shields.io/pypi/pyversions/qiskit-mps-initializer)

This package provides extra tools on Qiskit enabling you to initialize wavefunctions on a quantum computer using techniques based on matrix product states (MPS).

## User guide

### Installation

The easiest way to get started is using `pip` which installs the package and its dependencies in your project

```bash
pip install qiskit-mps-initializer
```

You can alternatively use `uv`, `poetry` or any other python package manager to install this package.

### Usage

Once you have installed the package, you can import tools from it.

```python
from qiskit_mps_initializer.datatypes import QuantumState

# wavefunction as an array of numbers, could use np.array as well
psi = [1, 3, 1, 2, 7, 8, 0, 1]
# number of layers of two-qubit gates to use for the initializer
number_of_mps_layers = 2

# create the state object
state = QuantumState.from_dense_data(data=psi, normalize=True)

# generate the initializer circuit for this state
circuit = state.generate_mps_initializer_circuit(number_of_layers=number_of_mps_layers)

# the circuit object is a qiskit.QuantumCircuit object which
# means you can do whatever you could natively do in Qiskit
circuit.draw('mpl')
```

### Documentation

The project's documentation is located [here](https://blackwild.github.io/qiskit-mps-initializer/). Check it out for more information.

> [!CAUTION]
> This project is in alpha. This means you should expect drastic changes in the api in later releases.

## Project credits

### Tools

- Project and dependency manager: `uv`
- Linter: `ruff`
- Formatter & style: `ruff`
- Static typechecking: `pyright` (`ty` is currently in beta, `pyrefly` is also another candidate, both built using Rust)
- Unit testing: `pytest` (no Rust-based alternative)
  - Randomization: `hypothesis`
- Documentation: `mkdocs`
  - API auto-generation: `mkdocstrings-python`
  - Theme: `mkdocs-material`

### Dependencies

- Quantum circuits: `qiskit`
- Data modeling & validation: `pydatic`
  - Numpy support: `pydantic-numpy`
- Tensor networks: `quimb`
o2security 0.2.0
A simple library for securely managing tokens and secrets.
Requires Python: >=3.7


# 🛡️ O₂Security - Secure Secrets Management for Python

![PyPI](https://img.shields.io/pypi/v/o2security)
![Python](https://img.shields.io/badge/python-3.12-blue)
![License](https://img.shields.io/badge/license-Apache--2.0-blue)
![GitHub Stars](https://img.shields.io/github/stars/unknownmsv/o2security)

A simple and secure library for managing tokens, API keys, and other secrets in your Python projects. Stop hardcoding secrets and start managing them securely with a local, encrypted vault and a user-friendly web dashboard.

![Dashboard Preview](https://sinamsv.storage.c2.liara.space/Screenshot_2025-08-06-16-10-15-119_com.android.chrome.png)

## ✨ Key Features

| Feature | Description |
|---------|-------------|
| 🔒 **Military-Grade Encryption** | AES-256-GCM encryption for all secrets at rest |
| 🏠 **Local-First Storage** | Secrets stored in `~/.o2security` (never in git) |
| 🖥️ **Web Dashboard** | Beautiful interface for managing secrets |
| 🐍 **Python API** | Simple integration with any Python project |
| ⌨️ **CLI Access** | Manage secrets from terminal with `o2tokman` |
| 🔄 **Automatic Key Rotation** | Built-in security best practices |

## ⚡ Quick Install

```bash
pip install o2security
```

## 🚀 Quick Start

### 1. Launch the Dashboard
```bash
o2tokman
```
Access at: `http://127.0.0.1:5001`

### 2. Create Project & Add Secrets
1. Create new project (e.g. `my-discord-bot`)
2. Add secrets (e.g. `DISCORD_TOKEN`)

### 3. Use in Your Code
```python
from o2security import tokman

# Load secrets
tokman.select_project("my-discord-bot")
bot_token = tokman.get("DISCORD_TOKEN")

# Use in your app
import discord
client = discord.Client()
client.run(bot_token)
```

## 🔐 Security Architecture

```mermaid
graph TD
    A[Master Key] -->|Encrypts| B[Project Vaults]
    B --> C[Secret1]
    B --> D[Secret2]
    B --> E[Secret3]
    style A fill:#4d94db,stroke:#333
    style B fill:#88d8b0,stroke:#333
```

- **Master Key**: 256-bit key stored at `~/.o2security/master.key`
- **Project Vaults**: Individual encrypted JSON files
- **Zero Trust**: Secrets never leave your local machine

## 📚 Full Documentation

For advanced usage and API reference, visit:  
[project.donutmsv.ir](https://project.donutmsv.ir/projects/o2security)

## 💖 Support the Project

If you find O₂Security useful, please consider:

[![Star on GitHub](https://img.shields.io/github/stars/unknownmsv/o2security?style=social)](https://github.com/unknownmsv/o2security)

## 📜 License

Apache-2.0 license - See [LICENSE](LICENSE) for details.

---

*Built with ❤️ and 🐍 by [Unknownmsv](https://github.com/unknownmsv)*
loop-rate-limiters 1.2.0
Loop rate limiters.
Requires Python: >=3.8
Keywords: rate, loop, frequency, regulator, limiter

# Loop rate limiters

[![Build](https://img.shields.io/github/actions/workflow/status/stephane-caron/loop-rate-limiters/main.yml?branch=main)](https://github.com/stephane-caron/loop-rate-limiters/actions)
[![Documentation](https://img.shields.io/github/actions/workflow/status/stephane-caron/loop-rate-limiters/docs.yml?branch=main&label=docs)](https://stephane-caron.github.io/loop-rate-limiters/)
[![Coverage](https://coveralls.io/repos/github/stephane-caron/loop-rate-limiters/badge.svg?branch=main)](https://coveralls.io/github/stephane-caron/loop-rate-limiters?branch=main)
[![Conda version](https://img.shields.io/conda/vn/conda-forge/loop-rate-limiters.svg)](https://anaconda.org/conda-forge/loop-rate-limiters)
[![PyPI version](https://img.shields.io/pypi/v/loop-rate-limiters)](https://pypi.org/project/loop-rate-limiters/)

Simple loop frequency regulators in Python with an API similar to ``rospy.Rate``:

```python
from loop_rate_limiters import RateLimiter
from time import perf_counter

rate = RateLimiter(frequency=400.0)
while True:
    print(f"Hello from loop at {perf_counter():.3f} s")
    rate.sleep()
```

A similar ``AsyncRateLimiter`` class is available for [asynchronous code](https://github.com/stephane-caron/loop-rate-limiters#asynchronous-io).

## Installation

### From conda-forge

```console
conda install -c conda-forge loop-rate-limiters
```

### From PyPI

```console
pip install loop-rate-limiters
```

## Usage

While the example above is synchronous, this library also provides an ``AsyncRateLimiter`` class for [asyncio](https://docs.python.org/3/library/asyncio.html):

```python
import asyncio
from loop_rate_limiters import AsyncRateLimiter

async def main():
    rate = AsyncRateLimiter(frequency=400.0)
    while True:
        loop_time = asyncio.get_event_loop().time()
        print(f"Hello from loop at {loop_time:.3f} s")
        await rate.sleep()

asyncio.run(main())
```

This can be used when there are several tasks executed in parallel at different frequencies.

## See also

- [ischedule](https://github.com/aleksve/ischedule): single-thread interval scheduler in Python