semvec/pypi-packages huggingface dataset:
harp-python 0.4.1
A low-level interface for loading binary Harp protocol data
Requires Python: >=3.9.0

# harp-python

A low-level interface to data collected with the [Harp binary protocol](https://harp-tech.org/protocol/BinaryProtocol-8bit.html).

## How to install

The source code is currently hosted on [GitHub](https://github.com/harp-tech/harp-python).

Binary installers for the latest released version are available at the [Python Package Index (PyPI)](https://pypi.org/project/harp-python) and can be installed using `pip`.

```sh
pip install harp-python
```

The list of changes between each release can be found [here](https://github.com/harp-tech/harp-python/releases).

## Data model 

The interface makes use of a Pydantic data model generated from Harp device schema definitions. The schema data classes are used to automatically generate binary readers for each device.

All binary data files from a single device need to be stored in the same folder alongside the device meta-schema, named `device.yml`. Each register file should have the following naming convention `<deviceName>_<registerAddress>.bin`.

For example, for a dataset collected with a `Behavior` device, you might have:

```
📦device.harp
 ┣ 📜Behavior_0.bin
 ┣ 📜Behavior_1.bin
...
 ┗ 📜device.yml
```

## How to use

### Create device reader object from schema

```python
import harp
reader = harp.create_reader("device.harp")
```

### Read data from named register

```python
reader.OperationControl.read()
```

### Access register metadata

```python
reader.OperationControl.register.address
```

### Create device reader object with UTC datetime format

```python
reader = harp.create_reader("device.harp", epoch=harp.REFERENCE_EPOCH)
```

### Read data with message type information

```python
reader.OperationControl.read(keep_type=True)
```

### Read data from a specific file

```python
reader.OperationControl.read("data/Behavior_10.bin")
```
quickwindow 0.1.0
Python bindings for the GLFW library (pyglfw fork)
Requires Python: >=3.10

# quickwindow

Python bindings for the GLFW library, fork of [pyglfw](https://github.com/pyglfw/pyglfw).

> [!NOTE]
> `pip install quickwindow==0.1.0`

```python
from quickwindow import quick_window, loop

with quick_window():
    for dt, events in loop():
        print(f"Δtime: {dt}\nevents: {events}")
```

> [!IMPORTANT]
> `libglfw3` dynamic library must be in path

```python
_lib = None
match platform.system():
    case "Windows":
        _lib = cdll.glfw3
    case "Darwin":
        _lib = cdll.LoadLibrary('libglfw.3.dylib')
    case _:
        _lib = cdll.LoadLibrary('libglfw.so.3')
```

## LICENSE
```
MIT License

Copyright (C) 2013 Roman Valov
Copyright (c) 2025 George Watson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
```
descartkit 2025.4.2.1
A Python toolkit for advanced data processing and API interactions
Requires Python: >=3.10


# descartkit

### LLM

#### Three steps to use models

##### Step1, llm_config.yaml

matter that needs attention
1. custom_model_name used for models.get_model_instance()
2. custom_model_name.name should specify the name of the model supported by the current company

```yaml
models:
  openai:
    custom_model_name:
      name: "gpt-4o"
      short_name: "OIG4"
      company: "openai"
      max_input_token: 8100
      max_output_token: 2048
      top_p: 0.5
      top_k: 1
      temperature: 0.5
      input_token_fee_pm: 30.0
      output_token_fee_pm: 60.0
      train_token_fee_pm: 0.0
      keys:
        - name: "openai_key1"
        - name: "openai_key2"

  siliconflow:
    qw-72b-p:
      name: "Qwen/QVQ-72B-Preview"
      short_name: "QW-72B-P"
      company: "siliconflow"
      max_input_token: 8100
      max_output_token: 2048
      top_p: 0.5
      top_k: 1
      temperature: 0.5
      input_token_fee_pm: 30.0
      output_token_fee_pm: 60.0
      train_token_fee_pm: 0.0
      keys:
        - name: "siliconflow_1"

```

##### Step2, llm_keys.yaml

1. The keys name of the model in llm_config.yaml corresponds to llm_keys.yaml one by one

```yaml
keys:
  openai_key1: "xx"
  openai_key2: "xx"
  anthropic_key1: "your_anthropic_api_key_1"
  anthropic_key2: "your_anthropic_api_key_2"
```

##### Step3, load models

```python
from descartkit.llm.config import load_models_from_yaml
from descartkit.llm import LLMClient

async def main():
  
    # The first method
    models = load_models_from_yaml(config_file="examples/llm_config.yaml", keys_file="examples/llm_keys.yaml")
    print(models.list_models())

    resp = await models.get_model_instance("gpt-4o").chat("who r u?")
    print(resp)

    # The second method
    client = LLMClient(config_file="llm_config.yaml", keys_file="llm_keys.yaml")
    print(client.list_models())
    resp = await client.chat("qw-72b-p", "who r u?", system_prompt="")
    print(resp)
    async for chunk in client.chat_stream("qw-72b-p", "who r u?", system_prompt=""):
        print(chunk)

if __name__ == '__main__':
    import asyncio
    asyncio.run(main())
```
bricoleur 0.0.3
Tools for 'bricoleurs' who engage is the art of 'bricolage.'

# In brevi

**bricoleur** is a Python library for 'bricoleurs' who engage is the art of 'bricolage.'

Why **bricoleur**?

- Equivalent Python functions that are available online and in construction calculators.
- Develop a free open source package.

# Documentation

Full documentation is available at [https://bricoleur.readthedocs.io/en/latest/](https://bricoleur.readthedocs.io/en/latest/).

# References

To cite this repository, please use:

@software{bricoleur,
  author  = {Gilles Pilon},
  title   = {bricoleur},
  url     = {https://github.com/gillespilon/bricoleur},
  version = {0.0.3},
  date    = {2025-04-02}
}
xtr-api 5.0.7
xtr-api

This Python library simplifies the creation of extraction APIs to streamline file parsing for data science workflows. It provides intuitive abstractions for reading and transforming data from diverse file formats—like CSV, JSON, and more—letting you focus on insights rather than low-level parsing details. By centralizing and standardizing your data ingestion process, it accelerates development and ensures consistent, reliable results for any data science project.
hipcheck-sdk 0.2.1
An SDK for developing Hipcheck plugins
Requires Python: >=3.10

Welcome to the Python SDK for writing plugins for the [Hipcheck][hipcheck-site] analysis tool.

# User / Plugin Developer Information

The guide for developing plugins with this SDK can be found [here][python-sdk-guide].

The API documentation for this package can be found [here][python-sdk-api-docs].

A dummy example plugin using the SDK can be found [here][sdk-example-plugin].

# Python SDK Developer Information

You must have `uv` installed. Installation instructions can be found
[here](https://docs.astral.sh/uv/getting-started/installation/).

## Running unit tests

From `sdk/python`, run
```bash
uv run pytest ./tests
```

## Regenerating auto-generated code

The contents of `src/hipcheck_sdk/gen` is generated Python code from multiple
sources. Some files are generated by the `grpcio` Python library using the
Hipcheck protobuf protocol spec. An additional file contains Python classes
automatically derived from the Hipcheck `Target` object schema. To regenerate
these files, you can run the following:

```bash
uv run scripts/update-gen.py
```

## Testing example plugin listening on port

From `sdk/python`, run
```bash
uv run tests/example-plugin/main.py --port <PORT>`.
```

Or from `hipcheck` repository root, run
```bash
uv run --project sdk/python sdk/python/tests/example-plugin/main.py --port <PORT>
```

## Testing example plugin in Hipcheck analysis

From the Hipcheck repository root, use a policy with the following `plugins`
entry:

```
    plugin "mitre/example" version="0.0.0" manifest="sdk/python/tests/example-plugin/local-plugin.kdl"
```

Currently, this will get through configuration and receive the query from
Hipcheck core, but the plugin will appear as an error in the final report
because it is not currently written to accept `Target` objects.

## Building the HTML

From `docs/`, run the following:

```bash
uv run make html # Build the html in the build/ directory
cp -r build/html <DESTINATION_DIR>
```

[hipcheck-site]: https://hipcheck.mitre.org/
[python-sdk-guide]: https://hipcheck.mitre.org/docs/guide/making-plugins/python-sdk/
[python-sdk-api-docs]: https://hipcheck.mitre.org/sdk/python/hipcheck_sdk.html
[sdk-example-plugin]: https://github.com/mitre/hipcheck/blob/main/sdk/python/tests/example-plugin/test_main.py
jam-todos-cli 0.6.3
A simple and colorful To-Do List CLI
Requires Python: >=3.11

# To-Do CLI
A simple, colorful to-do list in your terminal!

## Install
pip install jam-todo-cli

## Usage
- Add a task: `todo add "eat candy"`
- List tasks: `todo list`
- Complete a task: `todo complete 1`
- Delete a task: `todo delete 1`