semvec/pypi-packages huggingface dataset:
poulet-py 0.1.3
A library which hosts various neuroscience python methods
Requires Python: <3.14,>=3.10
Keywords: poulet_py

# Poulet Py – Neuroscience Python Library from Poulet Lab
A modular Python library for neuroscientific hardware control, data analysis, and experimental setups.

[![Unit Tests](https://github.com/poulet-lab/poulet_py/actions/workflows/test-suite.yml/badge.svg?branch=main)](https://github.com/poulet-lab/poulet_py/actions/workflows/test-suite.yml)

## Overview
Poulet provides a collection of tools for neuroscience researchers, including:
* Hardware communication (e.g., serial devices, DAQ interfaces)
* Data analysis utilities
* Experimental workflow automation

The library is organized into these core modules:

|Module        |Description|
| --------     | ------- |
|**config**    |It contains the SETTINGS and LOGGER constants for loading environmental variables and logging.|
|**converters**|For converting different filetypes to common data science (h5, plk, etc.).|
|**hardware**  |Low-level drivers and interfaces for external devices (e.g., amplifiers, stimulator).|
|**tools**     |Helper functions (serializers, generators, file I/O) – typically class-free.|
|**utils**     |High-level interactive tools for experiments and data processing.|

## Installation
### Minimal Installation
```sh
pip install -U .
```

### Optional Dependencies
Install specific modules:
```sh
pip install -U .[hardware]          # Only hardware dependencies
pip install -U .[tools,utils]       # Tools + utilities

# Special case for seq or all:
pip install -U git+https://github.com/LJMUAstroecology/flirpy.git
pip install -U .[seq]

pip install -U .[all]               # Everything
```

### Development Mode (Editable Install)
```sh
pip install -U git+https://github.com/LJMUAstroecology/flirpy.git
pip install -U -e .[all]            # For contributors
```

## Configuration
The config/ folder includes:
* settings.py – Environment variables for dynamic configuration (avoid hardcoded values).
* Custom logger – Use instead of print() for better debugging.

Example:
```python
from poulet_py import LOGGER
LOGGER.info("Starting trial...")
```

## Examples
Check the examples/ folder for usage scripts, such as:
* examples/oscilloscope.py – Oscilloscope like visualization.

## Contributing
We welcome contributions! Follow these guidelines:

1. Branching
  * Work on a dedicated branch (git checkout -b your-feature).
  * Submit PRs to the dev branch (PRs to main will be rejected).
  
2. Code Standards
  * Tests: Add unit tests in tests/ (mirroring the module structure).
  * Documentation: Use docstrings and update __init__.py for lazy loading.
  * Type hints: Recommended for new functions.

3. Commit Messages
  * Use semantic prefixes (e.g., feat:, fix:, docs:).
libre-linkup-py 0.2.5
Unofficial libre linkup python client
Requires Python: >=3.9

# Libre-linkup-py

## TL;DR

Unofficial client to get your glucose readings from the LibreLinkUp API in Python.
Supports Python 3.9 and above

## Contents

- [Installation](#installation)
- [Usage](#usage)
- [Examples](#examples)
- [Contributing](#contributing)

## Installation

    pip install libre-linkup-py

## Usage

Note: I recommend using something like [python-dotenv](https://pypi.org/project/python-dotenv/) to manage your environment variables.

1. Create a .env file with the following contents:

```bash
LIBRE_LINK_UP_USERNAME=...
LIBRE_LINK_UP_PASSWORD=...
LIBRE_LINK_UP_URL=https://api-eu2.libreview.io
LIBRE_LINK_UP_VERSION=4.16.0  # Optional
```

The url for `LIBRE_LINK_UP_URL` may be different depending on where you live, current [options](src/libre_link_up/types.py), also see [here](https://gist.github.com/khskekec/6c13ba01b10d3018d816706a32ae8ab2) for more information.

2. Paste this code into a file and run it:
```python
from libre_link_up import LibreLinkUpClient
import os
import dotenv
import json

dotenv.load_dotenv()

client = LibreLinkUpClient(
    username=os.environ["LIBRE_LINK_UP_USERNAME"],
    password=os.environ["LIBRE_LINK_UP_PASSWORD"],
    url=os.environ["LIBRE_LINK_UP_URL"],
    version="4.16.0",
)
client.login()
glucose_data = client.get_latest_reading()
print(json.dumps(glucose_data.model_dump(), sort_keys=True, indent=4))
```

The output should look something like:
```json
{
    "high_at_the_time": false,
    "low_at_the_time": false,
    "unix_timestamp": 1709830900.0,
    "value": 7.9,
    "value_in_mg_per_dl": 143.0
}
```

## Examples

See the [examples](examples/) directory for more examples.

## Contributing

If you find a bug :bug:, please open a [bug report](https://github.com/smpurkis/libre-linkup-py/issues/new?assignees=&labels=bug&template=bug_report.md&title=).
If you have an idea for an improvement or new feature :rocket:, please open a [feature request](https://github.com/smpurkis/libre-linkup-py/issues/new?assignees=&labels=Feature+request&template=feature_request.md&title=).
aiokalshi 0.1.0
An asyncio-native Kalshi API.
Requires Python: >=3.12

# An async-native, fully type-hinted Python client for Kalshi

`aiokalshi` provides a friendly interface into Kalshi's REST API (websocket support is in development). The library offers the benefits of asynchronous code, editor autocomplete, and parity with Kalshi's API while being easy to use and not requiring authentication.

## Installation
```bash
uv add aiokalshi
```
```bash
pip install aiokalshi
```

## Usage
`aiokalshi` uses the same structure as Kalshi's documented RESTful API. Every query parameter available is provided in a typed fashion, meaning you get autocomplete when customizing your queries.

Every response includes all of the available data and makes use of Pydantic.

```python
from httpx import AsyncClient
from aiokalshi import Kalshi

async def main():
    async with AsyncClient(follow_redirects=True) as client:
        # Make a client
        kalshi = Kalshi(client)

        # Get markets
        # Convention: list for grabbing paginated things, get for grabbing one-off queries
        markets = await kalshi.markets.list()
        markets_one = await kalshi.markets.list(limit=1)

        # Get one market
        market = await kalshi.markets.get(markets_one.markets[0].ticker)

        # Get the orderbook for a market
        orderbook = await kalshi.markets.orderbook.get(market.ticker, depth=5)

        # Get trades for a market
        trades = await kalshi.markets.trades.list(market.ticker, limit=10)

        # Get candlestick data for a market
        candlesticks = await kalshi.markets.candlesticks.get(
            series_ticker="SERIES-TICKER",
            market_ticker=market.ticker,
            start_ts=1700000000,
            end_ts=1700086400,
            period_interval=60  # 1 hour intervals
        )

        # Get events
        events = await kalshi.events.list(status="open", limit=10)

        # Get a specific event
        event = await kalshi.events.get(events.events[0].event_ticker)

        # Get event metadata
        metadata = await kalshi.events.metadata.list(event.event.event_ticker)

        # Get series by category
        series_list = await kalshi.series.list(category="Science and Technology")

        # Get a specific series
        if series_list.series:
            series = await kalshi.series.get(series_list.series[0].ticker)
```

## Status
This project is under rapid development. Expect breaking changes.