semvec/pypi-packages huggingface dataset:
iceduck 0.1.0
DuckDB wrapper with iceberg writer
Requires Python: >=3.12

# iceduck
DuckDB wrapper with iceberg writer

## usage

### duckdb 
```
import iceduck as duckdb

with duckdb.connect() as con:  
        con.sql("CREATE TABLE test (i INTEGER)")
        con.sql("INSERT INTO test VALUES (42)")
        df = con.execute("select * from test").fetch_df()
        print(df) 
```

### duckdb with Iceberg ( using local sqllite catalog )
Create a local folder
```
mkdir warehouse
```

```
import iceduck as duckdb

with duckdb.connect() as con:  
        con.sql("CREATE TABLE test (i INTEGER)")
        con.sql("INSERT INTO test VALUES (42)")
        
        warehouse_path = "./warehouse"
        params = {
                'type': 'sql',
                "uri": f"sqlite:///{warehouse_path}/pyiceberg_catalog.db",
                "warehouse": f"file://{warehouse_path}",
        }
    
        catalog = con.load_catalog(name='local', **params)

        #create a namespace
        if catalog._namespace_exists("default"):
            print("Namespace already exists")
        else:
            print("Creating namespace") 
            catalog.create_namespace("default")
          
       
        query_result = con.execute("select * from test")
        result = query_result.upsert_iceberg('default.test_iceberg')
        print(result)
```

### Read iceberg table

``` 
import iceduck as duckdb

with duckdb.connect() as con: 
    warehouse_path = "./warehouse"
    params = {
            'type': 'sql',
            "uri": f"sqlite:///{warehouse_path}/pyiceberg_catalog.db",
            "warehouse": f"file://{warehouse_path}",
    }
    
    catalog = con.load_catalog(name='local', **params)
    table = catalog.load_table("default.test_iceberg")
    print(table.scan().to_arrow())
```
jsepp 0.1.10
a package for general environmental data processing

## JSEPP
### dbutils
#### MySQLConn
1. __init__(host: str, user: str, password: str, db: str, port: int)
2. excute_one(comm)
3. excute_all(comm)
4. insert_confirm(comm)
5. insert(comm)
6. confirm()
7. rollback()
#### MongoConn
1. __init__(user:str, password:str, host:str, port:int, db:str)
2. fetch_one(tablename:str, filter: dict)
3. update_one(tablename:str, filter:dict, data:dict)
4. insert_one(tablename:str, data:dict)
UnifiedAI 1.5.5
A python package that simplifies and unifies the usage of multiple AI APIs
Requires Python: >=3.11

UnifiedAI
=========

UnifiedAI is a Python package that simplifies the usage of multiple AI APIs by providing a single, unified API. Currently, it supports OpenAI, Anthropic, Google, and Ollama AI APIs.


## Features

- Single API for multiple AI providers.
- Easy switching between different AI models.
- Simplified authentication and API key management.


Installation
============


    pip install UnifiedAI


Usage
========


Creating an AI instance
```python

API = AI(instance_name,api_provider,api_key,model_name)

```

Usage and methods of using one AI instance

```python  
from UnifiedAI import *

API = AI("gpt4","openai","OPENAI_API_KEY","gpt-4o")


#default is "You are a helpful assistant"
API.set_instructions("You are a sarcastically helpful assistant.")


#default is 512
API.set_max_tokens(100)


# add context without an api call
API.add_context("My Name is John.")


print(API.get_response("what is my name?"))

    
#history is a list object of all the user messages and assistant responses. 
print(API.history)


#print the input token usage of the model
print(API.usage.input_tokens)

#print the output token usage of the model
print(API.usage.output_tokens)


    
```

Use multiple AI instances at once using a Batch instance.


```python
    
from UnifiedAI import *
import json

gpt = AI("gpt","openai","OPENAI_API_KEY","gpt-4o")
claude = AI("claude","anthropic","ANTHROPIC_API_KEY","claude-3-5-sonnet-latest")
gemini = AI("gemini","google","GEMINI_API_KEY","gemini-1.5-pro")
llama = AI("llama","ollama",None,"llama3.2") 


models  = Batch([gpt, claude, gemini,llama])

models.set_instructions("You are a sarcastically helpful assistant.")

models.set_max_tokens(100)

models.add_context("My name is John.")

# get_response returns a dictionary object with
# the model names and their responses
print(json.dumps(models.get_response("what is my name?"),indent=4))

# print the output token usage of each model
print(models.usage["gpt"].output_tokens)
print(models.usage["claude"].output_tokens)
print(models.usage["gemini"].output_tokens)
print(models.usage["llama"].output_tokens)

```

Compare responses with different system instructions. 

```python
from UnifiedAI import *
import json

angry = AI("angry","openai","OPENAI_API_KEY","gpt-4o")
sarcastic = AI("sarcastic","openai","OPENAI_API_KEY","gpt-4o")
sad = AI("sad","openai","OPENAI_API_KEY","gpt-4o")

angry.set_instructions("Answer in a angry way.")
sarcastic.set_instructions("Answer in a sarcastic way.")
sad.set_instructions("Answer in a sad way.")


emotions = Batch([angry,sarcastic,sad])


emotions.set_max_tokens(100)


print(json.dumps(emotions.get_response("what is 1 + 1?"),indent=4))


print(emotions.usage["angry"].output_tokens)
print(emotions.usage["sarcastic"].output_tokens)
print(emotions.usage["sad"].output_tokens)

```
dl24-dash 0.1.3
A tool for DL24 electronic load device with support for data visualization using dash.
Requires Python: >=3.11

# DL24-Dash

A Python-based CLI tool for monitoring and visualizing data from DL24 electronic load devices. This tool provides real-time monitoring capabilities and data visualization through an interactive dashboard.

## Features

- Real-time discharge monitoring
- Automatic data logging to CSV files
- Interactive data visualization dashboard
- Support for comparing multiple discharge sessions
- Bluetooth serial communication with DL24 devices

## Prerequisites

- Python 3.x
- Bluetooth connectivity
- DL24 electronic load device

## Installation

1. Install using pip:
```bash
pip install dl24-dash
```

Or using UV (faster alternative):
```bash
# Install UV if you haven't already
curl -LsSf https://astral.sh/uv/install.sh | sh

# Install DL24-Dash
uv tool install dl24-dash
```

2. Set up the environment:
```bash
uv sync
```

## Development Setup

For development or if you want to run from source:

1. Install Astral UV (Python package manager):
```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

2. Set up the development environment:
```bash
uv sync
```

## Usage

### Connecting the Device

1. Connect your DL24 device via Bluetooth in serial port mode
2. The device should be available at `/dev/rfcomm0` (path may vary depending on your system)

### Monitoring Tool

Start a new monitoring session:
```bash
uv run dl24-dash monitor --start-new-session --current 4 test_discharge
```

Parameters:
- `--start-new-session`: Initiates a new monitoring session
- `--current 4`: Sets the discharge current to 4A
- `test_discharge`: Session name for data storage

The monitoring dashboard will be available at [http://127.0.0.1:8050/](http://127.0.0.1:8050/)

### Plotting Tool

Compare multiple discharge sessions:
```bash
uv run dl24_dash/main.py plot data1 data2 data3
```

The tool will:
- Scan specified directories for CSV files
- Generate an interactive comparison chart
- Display results at [http://127.0.0.1:8050/](http://127.0.0.1:8050/)

## Help

For additional information and command options:
```bash
uv run dl24_dash/main.py --help
```
streamlit-video-editor 0.0.12
A Streamlit custom component to display a simple video editor.
Requires Python: >=3.6

# Video Editor Component for Streamlit

A Streamlit custom component to display a simple video editor interface.


## Installation

First install Streamlit (of course!) then pip-install this library:

```bash
pip install streamlit
pip install streamlit-video-editor
```


## Example

```python
# Streamlit Video Editor Component Example

import streamlit as st
from streamlit_video_editor import video_editor

# use full page width
st.set_page_config(page_title="Video Editor Example", layout="wide")

# load video file
video_file = st.file_uploader("Upload a video", type=["mp4", "mov"])

if video_file:
    # display video editor
    editor_response = video_editor(video_file.path)
    st.write("Editor output:", editor_response)
```


![Component Example](https://github.com/antunsz/streamlit-video-editor/raw/main/component-example.png)


## Contributing

Contributions are welcome! Please open an issue or submit a pull request on [GitHub](https://github.com/antunsz/streamlit-video-editor).

## Author

Carlos André Antunes ([@antunsz](https://github.com/antunsz))
ord-schema 0.3.99
Schema for the Open Reaction Database
Requires Python: >=3.10

# Open Reaction Database: Schema (ord-schema)

[![DOI:10.1007/978-3-319-76207-4_15](https://zenodo.org/badge/DOI/10.1021/jacs.1c09820.svg)](https://doi.org/10.1021/jacs.1c09820)
[![PyPI version](https://badge.fury.io/py/ord-schema.svg)](https://badge.fury.io/py/ord-schema)

This repository contains the schema for the Open Reaction Database initiative; please see the documentation
at https://docs.open-reaction-database.org.

This repository does not contain the database itself; that is stored
in [ord-data](https://github.com/open-reaction-database/ord-data). Rather, `ord-schema` is
designed to store the database schema and tools for creating, validating, and submitting data to the database.

## Installation

```shell
$ pip install ord-schema
```

## Examples

The `examples/` directory contains examples of dataset creation and use. To run locally, install with:

```shell
$ pip install "ord-schema[examples]"
```

Click here to run the examples with Binder:
[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/open-reaction-database/ord-schema/HEAD?labpath=examples)

## Development

To install in editable/development mode:

```shell
$ git clone https://github.com/open-reaction-database/ord-schema.git
$ cd ord-schema
$ pip install -e .
```

If you make changes to the protocol buffer definitions, [install](https://grpc.io/docs/protoc-installation/) `protoc`
and run `./compile_proto_wrappers.sh` to rebuild the wrappers.

## Conventions

### 1. convention: compound stoichiometry

##### Created: 2023.07.04

##### Last updated: 2023.07.04

##### Description: 
1. The preferred field for compound stoichiometry is the map `Compound.features` or `ProductCompound.features`.
2. The key should be "stoichiometric_coefficient" or "stoichiometric_ratio".
3. The value should be a `Data` message with its `float_value` representing the compound's stoichiometric 
coefficient or ratio.

##### Related links: 
[#683](https://github.com/open-reaction-database/ord-schema/issues/683) 
[#684](https://github.com/open-reaction-database/ord-schema/pull/684)
hello-NOO 0.0.3
A small personal example package

---
# hello-NOO Python Package

This is an example repository for a python package, for my own reference.


---
PyPI:

[![PyPi Version](https://img.shields.io/pypi/v/hello-NOO.svg)](https://pypi.org/project/hello-NOO/)
[![PyPi Version](https://img.shields.io/pypi/dm/hello-NOO.svg)](https://pypi.org/project/hello-NOO/)

GitHub: 

[![GitHub Tag](https://img.shields.io/github/v/tag/NeonOrangeOrange/hello-NOO)](https://github.com/NeonOrangeOrange/hello-NOO)
[![GitHub Downloads](https://img.shields.io/github/downloads/NeonOrangeOrange/hello-NOO/total)](https://neonorangeorange.github.io/hello-NOO/)
[![GitHub License](https://img.shields.io/github/license/NeonOrangeOrange/hello-NOO)](https://github.com/NeonOrangeOrange/hello-NOO/blob/main/LICENSE)
[![GitHub Pages Website](https://img.shields.io/website?url=http%3A//neonorangeorange.github.io/hello-NOO/)](https://neonorangeorange.github.io/hello-NOO/)

---
## Install

Not that you would want to, but you can install with 

```
pip install hello-NOO
```

Developer install

1. Clone this repository and `cd` into it.
2. Create a virtual environment: `python3 -m venv .venv`
3. Activate the virtual environment: (linux) `source .venv/bin/activate`
4. Install the package locally: (linux) `pip install -e ./[dev,docs]`


---
## Building

```bash
# Build a source distribution (stored in dist/)
python -m build --sdist

# Build a wheel (stored in dist/)
python -m build --wheel

# Run a test to check all the builds in dist
twine check dist/*
```



---
## Upload to PyPi

Once your account is set up, run

```text
twine upload --verbose --repository pypi dist/*
```



---
## Other Notes

To reset the installation

```
pip freeze --exlucde hello-NOO | xargs pip uninstall -y
pip uninstall hello-NOO
```


---
## Resources

<https://pypi.org/classifiers/>

<https://packaging.python.org/en/latest/guides/writing-pyproject-toml/#classifiers>
bbj-argos 0.0.1
ML evaluation and logging platform for healthcare
Requires Python: <3.12,>=3.9

# Argos Tracker Getting Started
- Clone Repo
- Make sure Anaconda is installed
- Create conda env with ```conda env create --name argos-tracker --file=environment.yml```
- To update previously created envs use ```conda env update --file environment.yml --prune```

## Jupyter Lab
- Activate conda env with ```conda activate argos-tracker```
- Create project specific ipykernel if it has not been created yet:
```
python -m ipykernel install --user --name argos-tracker --display-name "argos-tracker"
```
- Start jupyter lab: ```jupyter lab```
- Open client using link provided on start
- Open test_notebook_mimic.ipynb and select the argos-tracker ipykernel

## MLflow
- Open a new terminal window and activate the argos-tracker env
- Start mlflow: ```mlflow server --host 127.0.0.1 --port 8787 --app-name mlflow_cors```

## Argos Dashboard
- In a third terminal window activate the argos-tracker env
- Go to the reports_dashboard directory ```cd reports_dashboard```
- Run ```npm ci``` to install dependencies for Vue frontend
- The following error may occur if using ubuntu with a version older than 24.04: 
```
node: /lib/x86_64-linux-gnu/libstdc++.so.6: version `GLIBCXX_3.4.31' not found (required by /home/user/anaconda3/envs/argos-tracker/bin/../lib/libnode.so.127)
```
- Start client with ```npm run dev```