semvec/pypi-packages huggingface dataset:
pyacquisition 0.1.13
Python-based data acquisition
Requires Python: >=3.11

![PyAcquisition](docs/logo.png)

`pyacquisition` is a powerful Python package designed to simplify the process of recording scientific data and controlling laboratory instruments. It abstracts away the complexities of instrument communication, task scheduling (both concurrent and sequential), data recording, and logging, allowing you to focus on the science. Whether you're managing a single instrument or orchestrating a complex experimental workflow, `pyacquisition` provides a framework that simplifies the process dramatically.

Check out the [installation](basic/installation.md) and [getting started](basic/getting_started.md) pages to get going.

## Objectives

**Be an 'all-python' solution** for interfacing with instruments and automating experimental procedures. Python has become the first choice of many for data analysis and scripting. We don't want to have to learn a second language just for interfacing with hardware or generating a GUI. You need *only* use python (and possibly a `.toml` config file).

**Be up and running in minutes**, not hours. `pyacquisition` is designed to be simple and 'batteries-included'. We want to absolutely minimize your development time in all major use-cases.

**Be 'one-size-fits-most'**. There will inevitably be cases that are not well suited to the workflow offered by `pyacquisition`, but it is hoped that we can help in the majority of instances. We've tried to design for maximum flexibility whilst keeping the API reasonably simple.

**Forget the GUI**. User interfaces are difficult and time consuming. Writing a robust GUI in Qt may well take longer than writing the rest of your experiment and analysis code combined. `pyacquisition` generates the entire UI programmatically. 

**Offer minimal barrier to entry** for those who are not advanced python users. Whilst it will be helpful to understand the basics of object oriented and asynchronous programming, getting going with `pyacquisition` is as simple as composing a `.toml` configuration file and running a two-line script. Adding custom functionality can mostly be accomplished by following some worked examples in most cases.

## A Short Example

A short configuration file interfacing with a Stanford Research Instruments SR 830 lock-in amplifier:

```toml title="my_configuration_file.toml"
[experiment]
root_path = "C://data"

[data]
path = "my_data_folder"

[instruments]
clock = {instrument = "Clock"}
lockin = {instrument = "SR_830", adapter = "pyvisa", resource = "GPIB0:7:INSTR"}

[measurements]
time = {instrument = "clock", method = "timestamp_ms"}
voltage = {instrument = "lockin", method = "get_x"}
```

A short script running the experiment from the configuration file:

```python title="experiment_script.py"
from pyacquisition import Experiment

my_experiment = Experiment.from_config('my_configuration_file.toml')
my_experiment.run()
```
scipion-chem-toxcsm 0.2
Scipion framework plugin for the use of toxCSM software tool
Keywords: scipion toxCSM scipion-3.0 cheminformatics

.. |organization| replace:: scipion-chem
.. |repository| replace:: scipion-chem-toxCSM

======================================================
Toxicity prediction of small ligands scipion plugin
======================================================
**Documentation under development, sorry for the inconvenience**
Scipion framework plugin for the use of toxCSM software tool.
  
========================================
Install this plugin
========================================
You will need to use `Scipion3 <https://scipion-em.github.io/docs/docs/scipion
-modes/how-to-install.html>`_ to run these protocols.


- **Install the stable version**

    Through the plugin manager GUI by launching Scipion and following **Others** >> **Plugin Manager**

    or

.. parsed-literal::

    scipion3 installp -p \ |repository|\ 


- **Developer's version**

    1. Download repository:

    .. parsed-literal::

        git clone \https://github.com/\ |organization|\ /\ |repository|\ .git

    2. Install:

    .. parsed-literal::

        scipion3 installp -p /path/to/\ |repository|\  --devel
  
========================================
Protocols
========================================
This plugin contains the following protocols:

**None for now**

========================================
Packages & enviroments
========================================
Packages installed by this plugin can be located in ``/path/to/scipion/software/em/``.


As of today, Scipion does not automatically uninstall the conda enviroments created in the installation process when uninstalling a plugin, so keep this list in mind if you want to clean up some disk space if you need to uninstall this one.


========================================
Changelog
========================================
All the recent version changes can be found `here <https://github.com/scipion-chem/scipion-chem-toxCSM/blob/devel/CHANGES.rst>`_.
midas-timesim 2.1.1
A midas module for a time simulator.
Requires Python: >=3.10

# Midas Time Simulator

## Description

This package contains a midas *timesim* module, which contains a simulator that tracks time and is able to manipulate it within the simulation.

The intended use-case for the time simulator is to be used inside of midas.
However, it can be used in any mosaik simulation scenario.

Version: 2.1

## Installation

This package will installed automatically together with `midas-mosaik` if you opt-in for the `full` extra. 
It is available on pypi, so you can install it manually with

```bash
pip install midas-timesim
```

## Usage

The complete documentation is available at https://midas-mosaik.gitlab.io/midas.

### Inside of midas

To use the time simulator inside of midas, simply add `timesim` to your modules:

```yaml
    my_scenario:
      modules:
        - timesim
        # - ...
```

This is sufficient for the timesim to run. 
However, additional configuration is possible with:

```yaml
    my_scenario:
      # ...
      timesim_params:
        start_date: 2020-01-01 01:00:00+0100
```

All of the core simulators that have support time inputs will then automatically connect to the *timesim* simulator. 
The scope *timesim* will be created automatically but no other scopes are supported.

### Any Mosaik Scenario

If you don't use midas, you can add the `timesim` manually to your mosaik scenario file. 
First, the entry in the `sim_config`:

```python
    sim_config = {
        "TimeSimulator": {"python": "midas_timesim.simulator:TimeSimulator"},
        # ...
    }
```

Next, you need to start the simulator (assuming a `step_size` of 900):

```python    
    timesim_sim = world.start("TimeSimulator", step_size=900)
```

Finally, the model needs to be started:

```python
    timesim = timesim_sim.Timegenerator()
```

Afterwards, you can define `world.connect(timesim, other_entity, attrs)` as you like.

## License

This software is released under the GNU Lesser General Public License (LGPL). 
See the license file for more information about the details.
onerun 0.1.0
OneRun python SDK
Requires Python: >=3.10

# OneRun Python SDK

A Python SDK for interacting with the OneRun API to run simulations and conversations.

## Installation

```bash
uv add onerun
```

## Quick Start

```python
import onerun

# Initialize the client
client = onerun.Client(
    base_url="https://api.onerun.com",
    api_key="your-api-key"
)

# List simulations
simulations = client.simulations.list(project_id="your-project-id")

# Get a specific simulation
simulation = client.simulations.get(
    project_id="your-project-id",
    simulation_id="sim-123"
)

# List conversations in a simulation
conversations = client.simulations.conversations.list(
    project_id="your-project-id",
    simulation_id="sim-123"
)
```

## Worker Example

Create a worker to process conversations:

```python
import asyncio
import onerun
from onerun.connect import WorkerOptions, run

async def handle_conversation(context):
    """Process a conversation"""
    print(f"Processing conversation {context.conversation_id}")
    
    # Your conversation processing logic here
    await asyncio.sleep(1)  # Simulate work

# Set up worker options
options = WorkerOptions(
    project_id="your-project-id",
    agent_id="your-agent-id",
    client=onerun.Client(),
    entrypoint=handle_conversation,
    task_poll_interval=5,
    max_concurrent_tasks=10
)

# Run the worker
run(options)
```

## Configuration

The SDK can be configured using environment variables:

- `ONERUN_API_BASE_URL`: Base URL for the OneRun API
- `ONERUN_API_KEY`: Your API key for authentication
rnit-vanna-static 0.1.0
Static snapshot of Vanna SQL generation library (for testing/offline use)
Requires Python: >=3.7
Keywords: sql nlp gpt openai database query natural-language

# RNIT Vanna Static

A static snapshot of the Vanna SQL generation library. This package contains a frozen copy of Vanna code for specific use cases.

## ⚠️ Important Note

**For most users, we recommend using the main `rnit-vanna` package instead:**
```bash
pip install rnit-vanna  # Recommended - always uses latest Vanna
```

This static version is only for:
- Testing with a specific Vanna version
- Offline environments with dependency conflicts
- Educational purposes to understand Vanna internals

## Installation

```bash
pip install rnit-vanna-static
```

## Why Two Packages?

- **`rnit-vanna`** (Recommended): A wrapper that always uses the latest official Vanna
- **`rnit-vanna-static`** (This package): A frozen snapshot of Vanna code

## Usage

This package works exactly like the original Vanna:

```python
from rnit_vanna.openai import OpenAI_Chat
from rnit_vanna.chromadb import ChromaDB_VectorStore

class MyVanna(ChromaDB_VectorStore, OpenAI_Chat):
    def __init__(self, config=None):
        ChromaDB_VectorStore.__init__(self, config=config)
        OpenAI_Chat.__init__(self, config=config)

vn = MyVanna(config={'api_key': 'your-openai-key', 'model': 'gpt-4o-mini'})
```

## Limitations

- **No automatic updates** - Frozen at a specific Vanna version
- **May become outdated** - Missing new features and bug fixes
- **Larger package size** - Contains copied code

## License

MIT - Based on the original Vanna library
hibob-public-mcp 0.4.0
HiBob MCP server integration.
Requires Python: >=3.8

# hibob-public-mcp

A FastMCP server for HiBob integration.

## Installation

```bash
pip install hibob-public-mcp
```

## Usage

After installation, you can run the MCP server with uvx:

```bash
uvx run mcp-server:mcp
```

## Configuration

Set the `HIBOB_API_TOKEN` environment variable with your HiBob API token.

## License

MIT
bot-safe-agents 1.1
A library for fetching a list of bot-safe user agents.
Requires Python: >=3.8

# Bot Safe Agents

A library for fetching a list of bot-safe user agents.

Made for educational purposes. I hope it will help!

## Table of Contents

* [How to Install](#how-to-install)
	* [Standard Install](#standard-install)
	* [Build and Install From the Source](#build-and-install-from-the-source)
* [Usage](#usage)

## How to Install

### Standard Install

```bash
pip3 install bot-safe-agents

pip3 install --upgrade bot-safe-agents
```

### Build and Install From the Source

Run the following commands:

```bash
git clone https://github.com/ivan-sincek/bot-safe-agents && cd bot-safe-agents

python3 -m pip install --upgrade build

python3 -m build

python3 -m pip install dist/bot-safe-agents-1.1-py3-none-any.whl
```

## Usage

Get all user agents:

```python
import bot_safe_agents

user_agents = bot_safe_agents.get_all()
print(user_agents)

# do something
```

Get a random user agent:

```python
import bot_safe_agents

user_agents = bot_safe_agents.get_random()
print(user_agents)

# do something
```
boardfarm3-docsis 1.0.1
An add-on to boardfarm that contains DOCSIS specific libraries.
Requires Python: >=3.9

# Boardfarm DOCSIS

This is the repo  that will contain DOCSIS specific tests and libraries for use for testing a docsis CM, CMTS, or other devices in a typical DOCSIS environment

To use this boardfarm plugin on Ubuntu, you must install:

```sh
# TCL for encoding of an MTA config file
sudo apt update
sudo apt install tcllib

# docsis for running docsis commands
sudo apt install automake libtool libsnmp-dev bison make gcc flex git libglib2.0-dev libfl-dev
git clone https://github.com/rlaager/docsis.git
cd docsis
./autogen.sh
./configure
make
sudo make install
```

## Execute tests

Please see the the demo test suite that utilizes some of the use-cases
from the ```boardfarm-docsis``` plugin.

```bash
.
└── tests
    ├── __init__.py
    ├── docsis
    │   ├── __init__.py
    │   └── test_demo_docsis_1.py
    ├── pytest.ini
    └── tr069
        ├── __init__.py
        └── test_demo_tr069_1.py
```

**_NOTE:_**  In order to run these test you will have to install pytest-boardfarm.

```bash
pip install boardfarm3[docsis,pytest]
```

Sample run command:

```bash
pytest \
    --rootdir=. \
    --capture=tee-sys \
    --board-name <cpe-name> \
    --env-config <testbed_env.json>  \
    --junitxml ./results/pytest_run_report.xml \
    --ldap-credentials "username:password"  \
    --inventory-config <lab_devices.json> \
    --html=./results/pytest_run_report.html  \
    --self-contained-html  \
    --save-console-logs=./results  \
    ./boardfarm-docsis/tests/ \
    --skip-contingency-checks
```
rsa-id-number 0.1.0
South African ID number utilities
Requires Python: >=3.11
Keywords: utilities, development


# rsa-id-number

Utilities for working with South African ID numbers.

## RSA ID Number Format

```
+-------------------------+
|8|8|0|1|2|3|5|1|1|1|0|8|8|
+-------------------------+
|Y|Y|M|M|D|D|S|S|S|S|C|A|Z|
+-------------------------+
```

- **YYMMDD**: The first 6 digits represent the date of birth (*23 January 1988*)
- **SSSS**: The next 4 digits are used to define the individual's gender (*Male*)
  - *Female*: 0000 - 4999
  - *Male*: 5000 - 9999
- **C**: The next digit is used to classify citizenship (*SA citizen*)
  - *SA citizen*: 0
  - *Permanent resident*: 1
  - *Refugee*: 2
- **A**: The next digit was used until 1980s to classify race
- **Z**: The last digit is used as a checksum digit to verify the number (*Valid*)

# Installation

```
$ pip install rsa-id-number
```

# Usage

```
>>> import rsaidnumber
>>> id_number = rsaidnumber.parse('8801235111088')
>>> id_number.valid
True
>>> id_number.date_of_birth
datetime.datetime(1988, 1, 23, 0, 0)
>>> id_number.gender
<Gender.MALE: 2>
>>> id_number.citizenship
<Citizenship.SA_CITIZEN: 1>
>>> id_number = rsaidnumber.parse('8801235111080')
Traceback (most recent call last):
  ...
ValueError: '8801235111080' contains an invalid checksum digit!
>>> id_number = rsaidnumber.parse('8801235111080', False)
>>> id_number.valid
False

Support for temporary ID numbers issued to refugees can be opted into:
>>> id_number = rsaidnumber.parse('8012215312288', allow_refugee=True)
>>> id_number.valid
True
```

# Contributing

Setup your development environment by running:

```
$ make
```

this will create a new Python *virtualenv*, install all necessary dependencies and run the tests.
quool 7.0.11
Quantitative Toolkit - a helper in quant developing
Requires Python: >=3.10
Keywords: quant, framework, finance

# Quool

Quool is a Python framework designed specifically for quantitative investment research. It aims to provide a flexible and efficient set of tools to help researchers and developers quickly implement data management, factor analysis, trading recording, and strategy evaluation functionalities. With Quool, users can focus on strategy and factor research without spending excessive time on data management and infrastructure setup.

## Features

- **Data Management**: Offers a unified interface for managing and accessing financial market data, supporting both intraday and daily data processing.
- **Factor Research**: Simplifies the process of factor development and testing, supporting factor definition, storage, analysis, and performance evaluation.
- **Trading Recording**: Provides flexible Recorder classes for recording and managing trade data and model execution data.
- **Strategy Evaluation**: Integrates strategy evaluation tools, supporting calculations of various performance metrics and result visualization.

## Installation

Currently, the Quool framework is not available on PyPI. You can install it from the source code as follows:

```bash
git clone https://github.com/your-username/quool.git
cd quool
pip install .
```

## Quick Start

Here are the basic steps to conduct factor research and strategy evaluation using Quool:

### Define a Factor

First, inherit the `BaseFactor` class to define your own factor. For example, define a factor that calculates the Volume Weighted Average Price (VWAP):

```python
from quool import BaseFactor

class VWAPFactor(BaseFactor):
    def get_vwap(self, date: pd.Timestamp):
        # Implement the calculation logic for VWAP
        pass
```

### Calculate Factor Values

Instantiate your factor class and use the `get` method to calculate factor values for a specific date range:

```python
vwap_factor = VWAPFactor(uri="./path/to/factor/data")
vwap_values = vwap_factor.get("vwap", start="2021-01-01", stop="2021-12-31")
```

### Evaluate Strategies

Use the `TradeRecorder` or other recorder classes to record your trading activities and use the `evaluate` method to assess strategy performance:

```python
from quool import TradeRecorder

# Record trading activities
trade_recorder = TradeRecorder(uri="./path/to/trade/data")
trade_recorder.record(date="2021-01-01", ...)

# Evaluate strategy performance
performance = trade_recorder.evaluate(...)
```

## Contributing

Contributions in the form of issue reports and pull requests are welcome on GitHub.

## License

Quool is released under the MIT license.