semvec/pypi-packages huggingface dataset:
streamlit-bookmark 0.1.2
Streamlit component that allows you to bookmark chat messages in your apps
Requires Python: >=3.7

# streamlit-bookmark

Here is a Streamlit component that allows you to **bookmark chat messages** in your apps, for later reference or anything else.
The code is based on [streamlit-feedback by Trubrics](https://github.com/trubrics/streamlit-feedback)

## Install

```sh
pip install streamlit-bookmark
```

## Examples

- See the streamlit_app_example.py.

## Usage

This component holds a single function:

```python
from streamlit_bookmark import streamlit_bookmark
bookmark_state = streamlit_bookmark(on_submit=some_callback_function,
                key=SOME_COMPONENT_KEY,
                disable_component=True)
bookmark_state
# ===> {'bookmark': True}
```


Could be used with these parameters:

```python
def streamlit_bookmark(
    on_submit=None,
    disable_component=None,
    key=None,
):
    """Creates a new instance of "streamlit_bookmark". Receives the current bookmark status for a given Streamlit compnent and calls a function upon submission.

    Parameters
    ----------
    on_submit: callable
        An optional callback invoked when feedback is submitted. This function must accept at least one argument, the feedback response dict,
        allowing you to save the feedback to a database for example. Additional arguments can be specified using `args` and `kwargs`.
    disable_component: str
        An optional boolean to disable the component. Can be used to pass state from one component to another.
    key: str or None
        An optional key that uniquely identifies this component. If this is
        None, and the component's arguments are changed, the component will
        be re-mounted in the Streamlit frontend and lose its current state.

    Returns
    -------
    dict
        The user response

    """
```
For the code example, see [here](streamlit_app_example.py).
dynotree 0.0.5
Dynotree - Dynamic Kd tree
Requires Python: >=3.6



<p align="center">
  <img width="50%" height="auto" src="./logo.svg">
</p>


# Dynotree

[![pre-commit](https://github.com/quimortiz/dyn_kdtree/actions/workflows/pre-commit.yml/badge.svg)](https://github.com/quimortiz/dyn_kdtree/actions/workflows/pre-commit.yml)
[![C/C++ CI](https://github.com/quimortiz/dyn_kdtree/actions/workflows/c-cpp.yml/badge.svg)](https://github.com/quimortiz/dyn_kdtree/actions/workflows/c-cpp.yml)
[![PyPI version](https://badge.fury.io/py/dynotree.svg)](https://badge.fury.io/py/dynotree)



Dynamic Kd-Tree in C++ and Python: Euclidean, SO(2), SO(3) and more!

The underlying KD-tree implementation is based on [bucket-pr-kdtree](https://github.com/jkflying/bucket-pr-kdtree), but dynotree supports non-Euclidean spaces and custom compound spaces. State spaces can be defined at both compile and runtime for both efficiency and flexibility.

The C++ library is header-only, with Eigen as single dependency, and we provide Python bindings for fast development and prototyping.


# Try it out!

## PYTHON

### PIP Package

```bash
pip3 install dynotree
```

A first example:
[rrt_free.py](test/python/rrt_free.py)

A second example:
[rrt.py](https://github.com/quimortiz/dyn_kdtree/blob/main/test/python/rrt.py)

### Python from source

## C++

Test and examples are in  [main.cpp](https://github.com/quimortiz/dyn_kdtree/blob/main/src/main.cpp)

```bash
git clone --recurse-submodules https://github.com/quimortiz/dyn_kdtree
cd dyn_kdtree
mkdir build
cd build
cmake ..
make
./main
```

use
```
./main --run_test=NAME_OF_TEST
```
to run only one example or test


# Development

## Create Python Package (locally)

Create wheels 
```
CMAKE_ARGS="-DBUILD_PYTHON_BINDINGS=1" python3 -m build
```
Wheels will be in `dist/` directory. Install the wheels with
(adjust package and python version accordingly)

```
pip3 install dist/dynotree-0.0.4-cp38-cp38-linux_x86_64.whl 
```



## Create Python Package and Upload to PYPI (locally)




## Create wheels

for publishing in pypi
```bash
docker pull quay.io/pypa/manylinux2014_x86_64
docker run -it -v $(pwd):/io quay.io/pypa/manylinux2014_x86_64 /io/build-wheels.sh
python3 -m twine upload wheelhouse/*
```

upload to  testpypi
```bash
python3 -m twine upload --repository testpypi wheelhouse/*
```


for creating local package:
```bash
TODO
```


# Why dyn_kdtree?

* Faster than OMPL and simpler than NIGH
* Dynamic: Add points one by one -- Ideal for Motion Planning
* Support Euclidean, SO(2), SO(3) and any combination
* Performant and flexible C++ code based on Eigen.
* Single Header File
* Python Bindings for easy integration
* Extendable with custom spaces!


# Python Bindings

## Option 1

## Option 2

## Option 3


# Dependencies

Python: No dependencies


C++ Code: Eigen

Develop: Eigen and Boost Testing

# Interface

See this for examples.

# Benchmark

Check this repo for benchmark against
* [bucket-pr-kdtree](https://github.com/jkflying/bucket-pr-kdtree)
* OMPL
* Nigh
* ...


# Roadmap

Code is Stable, currently used in ...