semvec/pypi-packages huggingface dataset:
pyklang 0.2.0
Python interface for Klang
Requires Python: >=3.11

<p align="center">
  <picture>
    <img alt="K-Scale Open Source Robotics" src="https://media.kscale.dev/kscale-open-source-header.png" style="max-width: 100%;">
  </picture>
</p>

<div align="center">

[![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/kscalelabs/ksim/blob/main/LICENSE)
[![Discord](https://img.shields.io/discord/1224056091017478166)](https://discord.gg/k5mSvCkYQh)
[![Wiki](https://img.shields.io/badge/wiki-humanoids-black)](https://humanoids.wiki)
[![Run tests](https://github.com/kscalelabs/klang/actions/workflows/test.yml/badge.svg)](https://github.com/kscalelabs/klang/actions/workflows/test.yml)

</div>

# klang

`klang` is a domain-specific language (DSL) for programming robots. It is used to program robots running the K-Scale operating system.

## Running the Parser

To run the parser on the example file, use the following command:

```bash
cargo run -- examples/clean_up_cans.k
```
optima-cli 1.0.4
OPTIMA CLI
Requires Python: >=3.11

# OPTIM CLI

OPTIM CLI is a powerful command-line interface tool designed to streamline the management and interaction with optimization problems. It provides an efficient way to create, upload, and manage optimization problems and their associated files through simple commands.

## Features

* 🚀 Quick problem creation and management
* 📁 Easy file upload system for problems and instances
* 📋 Comprehensive problem type visualization
* 💻 Both CLI and Python package functionality
* 🔄 Interactive prompts for missing parameters
* 📝 Metadata and README management capabilities

## Installation

### Prerequisites

- **Python 3.11 or higher**

  ```
  # Check your Python version
  python --version

  # Install Python via Homebrew (MacOS)
  brew install python@3.11

  # Or use Conda
  conda create -n optim-env python=3.11
  conda activate optim-env
  ```

### Installing OPTIM-CLI

```
pip install optima-cli
```

## Usage

### Command Line Interface

#### Basic Commands

```
# View all available commands
op

# View problems and problem types
op view-problems
op view-problem-types
```

#### Problem Management

```
# Create a new problem
op create [-u <username>]

# Upload problem files
op upload [-u <username>] [-prob <problem_abbr>] [-p <src_path>]

# Upload problem instances
op upload-instances [-u <username>] [-prob <problem_abbr>] [-p <src_path>]

# Upload README file
op upload-readme [-u <username>] [-prob <problem_abbr>] [-p <src_path>]

# Upload metadata
op upload-metadata [-u <username>] [-prob <problem_abbr>] [-p <src_path>]# View all available commands
op

# View problems and problem types
op view-problems
op view-problem-types
```

**Note:** All command parameters are optional. If omitted, OPTIM CLI will interactively prompt for the required information.

### Python Package Usage

Currently, only the viewing functions are available as a Python package. Other functionality (create, upload, etc.) is still under development and will be added in future releases.

**Available functions:**

```
from optima.commands.op_view import view_problems, view_problem_types

# View available problems
view_problems()

# View problem types
view_problem_types()
```

### License

This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
streamlit-slb-card 1.0.8
Streamlit component that allows to create custom card content for streamlit dashboard
Requires Python: >=3.11

# streamlit-slb-card

Streamlit component that allows to create custom card content for streamlit dashboard

## Installation instructions

```sh
pip install streamlit-slb-card
```

## Release Notes

### 1.0.8
- Fix the card min height

## Usage instructions

```python
import streamlit as st

from streamlit_slb_card import streamlit_slb_card

# sample data

# LineChart
data = {
    "xAxis": ["Nov 1", "Nov 2", "Nov 3", "Nov 4", "Nov 5", "Nov 6"],
    "value": [2, 5.5, 2, 8.5, 1.5, 1],
    "color": "maroon"
}

# PieChart
# data = [
#         { "id": 0, "value": 10, "label": 'Helmet Violation', "color": 'green' },
#         { "id": 1, "value": 32, "label": 'Coverall Violation', "color": 'red' },
#         { "id": 2, "value": 45, "label": 'Glove Violation', "color": 'blue' },
#         { "id": 3, "value": 28, "label": 'Vest Violation', "color": 'orange' }
#     ]

# BarChart
# data = {
#         "name": ["Total Wells", "Total Active", "Total Down"],
#         "value": [45, 30, 15],
#         "color": "green"
#     }

streamlit_slb_card(
    title="Crew Health", 
    titleTextAlign="left",
    titleTextSize="25",
    headerContent=f"<div><div style='font-size:14px;font-weight: bold'>Average Pulse Rate</div><div><span style='font-size:40px'>10</span> beats/min</div></div>",
    showChart=True,    
    chartType="LineChart", # Supported charts -> PieChart, BarChart, LineChart
    chartTitle= "Violation Types",
    chartData=data
)
```
lazypp 0.2.0
A Python package named lazypp
Requires Python: >=3.11

# Lazypp

Lazy execution parallel pipeline.

## Installation

To install Lazypp, simply run:

```bash
pip install lazypp
```

## Usage

1. First, create the input and output `TypedDict`.
2. Inherit from `BaseTask` and override the `task` member function.

Here's an example:

```python
import asyncio
from pathlib import Path
from typing import TypedDict

from lazypp import BaseTask

# Define a base class for your tasks
class TestBaseTask(BaseTask[INPUT, OUTPUT]):
    def __init__(self, input: INPUT):
        super().__init__(
            cache_dir=Path("cache").resolve(),
            input=input,
        )

# Define input and output types
class Fin(TypedDict):
    your_name: str

class Fout(TypedDict):
    output: str

# Define a specific task that says hello
class Hello(TestBaseTask[Fin, Fout]):
    async def task(self, input: Fin) -> Fout:
        await asyncio.sleep(3)  # Simulating a long-running task
        return {"output": f"Hello, {input['your_name']}"}

# Create and execute the task
hello_task = Hello(
    input={"your_name": "John"},
)

print(hello_task.result())
```

## Features

### Cached Output

The output is automatically cached in the `cache_dir` according to the input and the code of the `task` member function. As a result, running the task a second time is much faster than the first execution.

### Parallel Execution

Tasks can be nested, and Lazypp will automatically parallelize these tasks to save time and optimize performance.
ox-vox-nns 0.6.1
A hybrid-ish nearest neighbour search implemented in rust using voxels and hashmaps (/dictionaries)
Requires Python: >=3.8
Keywords: nearest, neighbour, pointcloud

# OxVoxNNS - **Ox**idised **Vox**elised **N**earest **N**eighbour **S**earch

[![PyPI](https://img.shields.io/pypi/v/cibuildwheel.svg)](https://pypi.org/project/ox-vox-nns/)
[![Actions Status](https://github.com/hacmorgan/OxVoxNNS/workflows/CI/badge.svg)](https://github.com/hacmorgan/OxVoxNNS/actions)

A hybrid-ish nearest neighbour search implemented in rust, tailored towards consistent performance, especially on difficult inputs for KDTrees


## Installation
### Precompiled (from PyPI, recommended)
```
pip install ox_vox_nns
```

### Manual
Checkout this repo and enter a virtual environment, then run
```
maturin develop --release
```


## Usage
Basic usage, query a block of query points in **sparse** mode:
```
import numpy as np
from ox_vox_nns.ox_vox_nns import OxVoxNNS

NUM_POINTS = 100_000
TEST_POINTS = np.random.random((NUM_POINTS, 3))

indices, distances = ox_vox_nns.OxVoxNNS(
    search_points=TEST_POINTS,
    max_dist=0.05,
).find_neighbours(
    query_points=TEST_POINTS,
    num_neighbours=1000,
    sparse=True,
)
```

More complex usage, using a single NNS object for multiple *exact* mode queries (e.g. to distribute the `nns` object and perform queries in parallel, or to query from a large number of query points in batches/chunks)
```
# same imports and test data as above

nns = ox_vox_nns.OxVoxNNS(TEST_POINTS, 0.1)

for query_points_chunk in query_points_chunks:
    chunk_indices, chunk_distances = nns.find_neighbours(
        query_points=query_points_chunk,
        num_neighbours=1,
        sparse=False,
    )
```


## Performance
As a rough heuristic:

- Open3D will edge out OxVox on **easier data**, e.g. uniformally distributed points, though OxVox does outperform SciPy and SKLearn's KDTree implementations
- OxVox in exact mode will outperform even Open3D on harder inputs, e.g. with clusters of very dense points
- OxVox in sparse mode or with `epsilon > 0.0` will dramatically outperform KDTrees too. This is not really a fair comparison, but if you don't strictly need the exact `k` nearest neighbours it can be very helpful

See `performance_test_ox_vox_nns.py` for test code.

More thorough tests and interactive visualisations are still being developed to help a prospective user decide quickly if OxVox is worth trying
tjwmd 2.0.0
tjwmd
Requires Python: <4.0,>=3.9

# tjwmd

![PyPI - Version](https://img.shields.io/pypi/v/tjwmd)

## Installation

```shell
pip install tjwmd
```

## Quick Start

```python
from PIL import Image

from tjwmd import TJWMD
from tjwmd.digits_labels import DigitsLabels

dl = DigitsLabels()
dl[0] = ['0', 'Zero']

wmd = TJWMD(
    wm_counter_model_path='yolov8_wmc_v1.pt',
    wm_digits_model_path='yolov8_wmd_v3s.pt',
    digits_labels=dl,
    counter_labels=['counter']
)

img = Image.open('6724502e2cec9d702006b6cc.jpeg')

values, bbox_img = wmd.predict(
    _image=img,
    num_of_digits=6,
    wm_digits_conf=0.1,
    wm_counter_conf=0.1,
    angle=0.0
)
print(values)

bbox_img.show()
```