semvec/pypi-packages huggingface dataset:
opentouch-interface 0.2.0
Interface to connect to touch sensors
Requires Python: >=3.10


# OpenTouch Interface

A Python package designed to provide a unified interface for various touch sensors. It simplifies the process of interacting with touch sensors by providing a consistent API regardless of the specific sensor being used.

We also provide an easy-to-use web interface that lets you connect to the sensors and show their data stream without the need to code.

---

## Overview
- **Unified API**: Interact with multiple types of touch sensors using a single, consistent API.
- **Web Dashboard**: Manage sensors, record/replay data, and annotate data directly through a web interface.
- **Easy Configuration**: Use YAML config files to quickly set up and manage sensors.

**Supported sensors**:
- [Digit](https://digit.ml/)
- [Digit360](https://digit.ml/digit360.html)
- [GelSight Mini](https://www.gelsight.com/gelsightmini/)

## Installation

OpenTouch Interface requires Python 3.10+ (tested on Ubuntu 24.04).

#### Method 1: Install via `pip`

```bash
pip install opentouch-interface
```

#### Method 2: From source

```bash
git clone https://github.com/lasr-lab/opentouch-interface
cd opentouch-interface
pip install .
```

## Getting started

You can connect touch sensors to the OpenTouch Interface in two main ways:

### 1. Using the Dashboard (Web Interface)

<p align="center">
<img src="./docs/dashboard.gif" alt="dashboard" />
</p>

Start the dashboard. If you run into issues, try reconnecting your sensors and restarting the dashboard.
```bash
opentouch-dashboard
```

#### Adding Sensors to the Dashboard
Add sensors either by manually entering details or by providing a YAML config file. For example, your YAML might look like:
```yaml
group_name: Robotic hand  # Group name.
path: test.touch          # File path where data should be saved (optional).

sensors:      # List of sensors belonging to that group
  - ...       # Sensor 1
  - ...       # Sensor 2

payload:      # List of input elements used for data annotations (optional).
  - ...       # e.g., text input
  - ...       # e.g., slider
```
Sensors are bundled in groups. Within a group **sensor names must be unique**.
An example config file is provided as [`group.yaml`](examples/config/group.yaml). There, you also find example configs of all supported sensors.

The payload can be used for data annotations. You can find an overview of supported widgets at [`payload.md`](docs/payload.md).

### 2. Using Code

For programmatic control, please refer to the [`demo.py`](examples/record_data.py) example.
- Run with the default config ([`digit.yaml`](examples/config/digit.yaml))
    ```bash
    python examples/simple/demo.py
    ```

- Or specify a config file:
    ```bash
    python examples/simple/demo.py --config-name gelsight.yaml
    ```
---

## Contribution
We welcome contributions! Pleaes check out our [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.

---

## License

This project is licensed under the MIT License. See the [LICENSE](LICENSE) file for more details.
tiktok-username-finder 0.1.0
A Python library to find TikTok usernames by email
Requires Python: >=3.6

# TikTok Username Finder

A Python library to find TikTok usernames by email.

## Installation

```bash
pip install tiktok-username-finder
```

## Usage

```python
from tiktok_username_finder import find_tiktok_username

email = "test@example.com"
result = find_tiktok_username(email)

if result["status"] == "success":
    print(f"Username: {result["username"]}")
else:
    print(f"Error: {result["message"]}")
```
```
academic-publication-manager 0.1.3
Simple academic publication manager GUI.
Requires Python: >=3.8
Keywords: writing, research

# academic-publication-manager

Simple academic publication manager GUI.

![logo](https://raw.githubusercontent.com/trucomanx/AcademicPublicationManager/main/screenshot.png)

## 1. Installing

To install the package from [PyPI](https://pypi.org/project/academic-publication-manager/), follow the instructions below:


```bash
pip install --upgrade academic-publication-manager
```

Execute `which academic-publication-manager` to see where it was installed, probably in `/home/USERNAME/.local/bin/academic-publication-manager`.

### Using

To start, use the command below:

```bash
academic-publication-manager
```
## 2. More information

If you want more information go to [doc](https://github.com/trucomanx/AcademicPublicationManager/blob/main/doc) directory.

## 3. Buy me a coffee

If you find this tool useful and would like to support its development, you can buy me a coffee!  
Your donations help keep the project running and improve future updates.  

[☕ Buy me a coffee](https://ko-fi.com/trucomanx) 

## 4. License

This project is licensed under the GPL license. See the `LICENSE` file for more details.
resgraph 0.1.0
A Python library for graph global/node resilience and robustness metrics
Requires Python: >=3.8

# resgraph

`resgraph` is a Python package for computing **network resilience and robustness metrics** on graphs built with [NetworkX](https://networkx.org).

It provides a unified framework for analyzing **global** and **local** measures of vulnerability, connectivity, and fault tolerance across diverse network structures.

---

## Features

- **Global graph resilience metrics**  
  Evaluate robustness at the whole-network level, including connectivity, efficiency, and structural integrity.

- **Local (node-level) resilience metrics**  
  Quantify the vulnerability and importance of individual nodes under various attack or failure scenarios.

- **Wide coverage of methodologies**  
  Includes **structural**, **spectral**, **flow-based**, and **attack-based** resilience measures.

- **Extensible design**  
  Modular API built on NetworkX — add your own custom metrics with minimal effort.

- **Research and engineering ready**  
  Useful for resilience studies in infrastructure networks, biological systems, social graphs, and beyond.

---

## Installation

Install from [PyPI](https://pypi.org/project/resgraph):

```bash
pip install resgraph
rootlab-lib 0.8.2
RootLab data analysis tools
Requires Python: >=3.7

# rootlab-lib
A library of data analysis tools for the RootLab at CWRU. This library contains functions commonly used for data analysis in the lab. For obvious reasons, data used for the modules tests is not be shared.

## Instructions
### Pip
With basic pip, use:
```
pip install rootlab-lib
```

### Spyder
If using Spyder (Conda is your package manager) or you do not have pip (you can check this by opening a terminal and entering `pip`), you MUST download python [here](https://www.python.org/downloads/) and change the interpreter for Spyder to the downloaded python version. When you download python using the link above, note the installation folder of the interpreter and copy it to your clipboard so that you can paste the path in Spyder. To change the path to the interpreter in Spyder, Select `Tools`, `Settings`, then `Python Interpreter`. At the top of this page, check the box that allows you to enter a custom interpreter, paste the path you copied earlier. Restart Spyder, and enter the command it tells you to use to fix any issues with the new interpreter. It should be something like `pip install spyder-kernels`. You can now run `pip install rootlab-lib` without issue. You may need to restart Spyder again for the changes to take effect.

If you already have python installed, then you must find out where your python interpreter is located on your system. This can be down by opening a terminal and typing `where python`. You can also just google it if this doesn't work!

## Documentation
You can read function documentation by opening the file `rootlab_lib.html` in the `doc` folder.
hamplots 1.1.6
Realtime plots for ham radio band conditions
Requires Python: >=3.10

# Hamplots

![](https://raw.githubusercontent.com/G1OJS/hamplots/refs/heads/main/plots/Rx_40m_FT8.png)

### Hamplots
Produces various plots based on current ham radio band conditions, based on reports from pskreporter.
Currently set up to support this repository, which uses GitHub actions to update the plots periodically and put them on the web, 
for example: [this page](https://g1ojs.github.io/hamplots/docs/heatmaps.html).

However, you can install and run the Python used to generate the plots and use it yourself.

### Installation:

```
pip install hamplots
```

### More coming soon
jcb 0.1.0
JEDI Configuration Builder
Requires Python: >=3.6
Keywords: JEDI, JCSDA, NOAA, NASA

# JEDI Configuration Builder

### Repository status:

[![JCB Tests](https://github.com/NOAA-EMC/jcb/actions/workflows/basic_testing.yaml/badge.svg?branch=develop)](https://github.com/NOAA-EMC/jcb/actions/workflows/basic_testing.yaml)

### Installation

For the latest development version from PyPI (published automatically on pushes to develop):

``` shell
pip install jcb
```

For development or to install from source:

``` shell
git clone https://github.com/noaa-emc/jcb
cd jcb

# Optional step if you want to run the client integration tests
./jcb_client_init.py  # May first require `pip install pyyaml` if it is not available

pip install --prefix=/path/to/where/you/want/installed .

# Run the tests
pytest
```

### Description

How to use from the command line:

``` shell
jcb render dictionary_of_templates.yaml jedi_config.yaml
```

The below shows two examples of calling jcb from a python client. In each case you have to provide a dictionary that describes all the ways that you want to render the templates in the contained JEDI YAML files.

First jcb provides a convenient single line call passing in the dictionary of templated and getting back the dictionary. The dictionary of templates has to contain an `algorithm` key telling the system which JEDI algorithm you want to run.

``` python
import jcb

jedi_config_dict = jcb.render(dictionary_of_templates)
```

For situations where you wish to create YAML files for several algorithms using the same dictionary of templates you can access the class directly.

``` python
import jcb

jcb_obj = jcb.Renderer(dictionary_of_templates)
jedi_dict_2_a = jcb_obj.render('hofx4d')
jedi_dict_2_b = jcb_obj.render('variational')
```
dismew 0.2.0
Debugger tool for Logstash's Grok parsing language.
Requires Python: >=3.11
Keywords: Debugger, Grok, TUI, Textualize

# Dismew

A debugger for Logstash's Grok parsing language. Supports all ecs-v1 patterns (AWS, Java, Firewalls, etc.) listed [here](https://github.com/logstash-plugins/logstash-patterns-core/tree/main/patterns/ecs-v1). This is suitable solution to those who have a more terminal-centric workflow in their work, you can e.g. create a shortcut to launch the program from you editor, as if it were part of it.

## Installation

Use [Pipx](https://pipx.pypa.io/latest/installation/) to run it in an isolated environment (recommended)

```bash
pipx install dismew
```

or with pip

```bash
pip install dismew
```

## Example

![example-v0.1.0](https://codeberg.org/spuzkov/dismew/raw/branch/main/examples/dismew-v0.1.0-example.png)

## Things I that need completion before V1 can be released

- [ ] Add pattern suggestions

- [ ] Faster everything

- [ ] Highlighting for matches

- [x] Support both full matching and partial

- [ ] Allow to continue from previous state, meaning pattern, sample and outcome stay as they were on program launch.

- [ ] Display hints on how to fix broken pattern

- [ ] Documentation on patterns with examples, so that user can easily check what patterns suits their usecase.

## Develop

Project management is with [Hatch](https://hatch.pypa.io/1.12/).

Clone this repository

```bash
git clone https://codeberg.org/spuzkov/dismew.git
cd dismew
```

Create an environment

```bash
hatch env create
```

Attach to the environment

```bash
hatch shell
```

Open new terminal window/pane/tab for debugging, and run

```bash
textual console
```

Run in debugging mode

```bash
textual run --dev /src/dismew/app.py
```

## Contributing

All contributions are welcome (except those that have been made with LLMs).
Please respect this request of **not** contributing generated code.

### What ways you can contribute

- Write issues
- Create feature requests
- Write code
- Anything you can think of really