semvec/pypi-packages huggingface dataset:
cmdtools 1.0.2
A collection of tools relating to transfer operators

[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/zib-cmd/cmdtools/HEAD?filepath=examples)
[![Documentation](https://readthedocs.org/projects/cmdtools/badge/?version=latest)](https://cmdtools.readthedocs.io/en/latest/?badge=latest)
[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.4749330.svg)](https://doi.org/10.5281/zenodo.4749330)

# cmdtools

This Python library implements a suite of tools used and/or developed in the [Computational Molecular Design](https://www.zib.de/numeric/cmd) group of the Zuse Institute Berlin.


## Installation

Install with `pip install cmdtools`
    (If you want to use the SLEPc library for sparse Schur decompositions install cmdtools with the extra slepc, i.e. `pip install "cmdtools[slepc]"`)

Note: It seems that `pip` has problems installing SLEPc. However, using conda you can install it with `conda install -c conda-forge petsc slepc petsc4py slepc4py`.

## Contents
*  `pcca`: An implementation of (generalized) PCCA⁺ using the Schur decomposition
*  `ajc`: A sparse implementation of the augmented jump chain
*  `diffusionmaps`: Diffusionmaps with sparse support and out of sample extensions
*  `galerkin`: Trajectory based estimation of the transfer operator using a Galerkin projection onto Gaussian RBFs
*  `gillespie`: Trajectory simulation from a generator
*  `newton_generator`: Multi-step estimation of the generator via the Newton polynomial
*  `picking_algorithm`: Given a set of datapoints, pick n points such that they are distributed as evenly / equidistant as possible
*  `sqra`: The Square Root approximation, estimating the generator for the diffusion in a given potential
*  `voronoi`: Voronoi clustering of trajectories and estimation of the transfer operator with different metrics and center strategies.
*  `diffusion`: A collection of dynamical systems (So far the double- and triple-well)


If you use cmdtools in your research, please [cite](CITATION.bib) our work.
livechat 0.1.0
A program to display images and gif on other computers within same network.
Requires Python: >=3.8

# Python Live Chat  

Python Live Chat is a Python application that allows users to send images and GIFs to selected computers on a local network running the script. The images are displayed in full screen for a specified duration.  

## System Requirements  

- **Windows**: Windows 10, Windows 11 (not tested on earlier versions).  
- **Linux**: Tested on Xubuntu but should work on other distributions.  
- **macOS**: Not tested.  

## Requirements  

Before running the script, ensure you have the required libraries installed. Install them using the following command:  
```bash
pip install -r requirements.txt  
```

## Usage  

1. Clone the repository or download the project files.  
2. Navigate to the project directory.  
3. Run the application using the following command:  

``` bash
   python run.pyw  
```

4. A window will appear, allowing you to:  
   - **Select connected users**: Users running the script on the same local network are automatically detected and listed as connected.  
   - **Specify an image or GIF path**: Supports both local file paths and publicly accessible web URLs. Note: URLs requiring authentication will not work.  
   - **Set the display duration**: Choose how long the image or GIF should remain on the screen.  
   - Click **Send** to transmit the image or GIF to all selected users.  

## Screenshots  

![Screenshot of Python Live Chat](assets/screenshots/screenshot_0.png)  

---

### Additional Notes  

- **Supported URL types**: Any publicly accessible image URL can be used, provided it doesn't require authentication.  
- **No duration limit**: There is no restriction on how long an image can be displayed.
flipvision 0.0.1
Detect tricks done on skateboard
Requires Python: >=3.9

# WT9011DCL-data-parsing

## Installation

1. Create python virtual environment e.g. venv:
```
python3 -m venv venv
source venv/bin/activate
```

2. If you want to just use the package:
```
pip install .
```

For contributors:
```
pip install -e ".[lint]"
pre-commit
```
The -e option is for installing in editable mode - meaning changes in the code under development will be immediately visible when using the package.

To run the package just type:
```
flipvision
```

To listen for imu data type:
```
flipvision -l
```


## Enter nix devshell

cd into the project directory

```
nix develop
```

This will create venv and install dependencies on the first run.
Exit the shell with `exit` command or ctrl-d

## Bleak
[Examples](https://github.com/hbldh/bleak/tree/master/examples)
DevCommit 0.1.4.3
A command-line AI tool for autocommits
Requires Python: >=3.8

# DevCommit

A command-line AI tool for autocommits.

## Features

- Automatic commit generation using AI.
- Easy integration with your Git workflow.
- Customizable options for commit messages.

![DevCommit Demo](https://i.imgur.com/erPaZjc.png)

## Installation

1. **Install DevCommit**  
   Run the following command to install DevCommit:

   ```bash
   pip install devcommit
   ```

2. **Add the `.dcommit` Configuration File**  
   DevCommit uses a configuration file (`.dcommit`) to customize commit settings. Follow these steps to create it:

   - **Option 1: Home Directory**  
     To set up DevCommit globally, create the `.dcommit` file in your home directory:

     ```bash
     echo -e "LOCALE = en\nMAX_NO = 1\nCOMMIT_TYPE = conventional\nMODEL_NAME = gemini-1.5-flash" > ~/.dcommit
     ```

   - **Option 2: Virtual Environment**  
     Alternatively, you can create the `.dcommit` file in your virtual environment’s `config` directory for environment-specific settings:

     ```bash
     mkdir -p $VIRTUAL_ENV/config
     echo -e "LOCALE = en\nMAX_NO = 1\nCOMMIT_TYPE = conventional\nMODEL_NAME = gemini-1.5-flash" > $VIRTUAL_ENV/config/.dcommit
     ```

## Usage

After installation, you can start using DevCommit directly in your terminal:

```bash
devcommit
```
scrippy 1.0.8
"Scrippy framework install helper"
Requires Python: >=3.8

![Version](https://img.shields.io/static/v1?label=version&color=informational&message=1.0.8)
![License](https://img.shields.io/static/v1?label=license&color=orange&message=MIT) ![Language](https://img.shields.io/static/v1?label=language&color=informational&message=Python)

# Scrippy installer

This is the [**Scrippy**](https://codeberg.org/scrippy) framework installer.

## Configure and install [*the Scrippy scripting framework*](https://codeberg.org/scrippy/) with default value

   - With configuration setting confirmation

      ```shell
      export PATH=${HOME}/.local/bin:${PATH}
      pip install scrippy
      scrippy install
      ```

   - Without configuration setting confirmation

      ```shell
      export PATH=${HOME}/.local/bin:${PATH}
      pip install scrippy
      scrippy install -y
      ```

## Configure and install [*the Scrippy scripting framework*](https://codeberg.org/scrippy/) interactively

  ```shell
  pip install scrippy
  scrippy install -i
  ```

## Configure and install [*the Scrippy scripting framework*](https://codeberg.org/scrippy/) from custom configuration file

  ```shell
  pip install scrippy
  scrippy install -c /path/to/config.yml
  ```

### Configuration file example

```yaml
env:
  confdir: ~/.local/share/scrippy/conf
  datadir: ~/.local/share/scrippy/data
  histdir: ~/.local/share/scrippy/hist
  logdir: ~/.local/share/scrippy/log
  reportdir: ~/.local/share/scrippy/reports
  templatedir: ~/.local/share/scrippy/templates
  tmpdir: ~/.local/share/scrippy/tmp
packages:
  scrippy-core: latest
  scrippy-remote: latest
  scrippy-api: latest
  scrippy-mail: latest
  scrippy-git: latest
  scrippy-template: latest
  scrippy-snmp: latest
```

## Uninstall [*the Scrippy scripting framework*](https://codeberg.org/scrippy/)

  ```shell
  scrippy uninstall
  ```

## Uninstall [*the Scrippy scripting framework*](https://codeberg.org/scrippy/) and delete all scippy directories

  ```shell
  scrippy uninstall --prune
  ```
midap 1.0.1
A package for cell segmentation and tracking.
Requires Python: <4,>=3.9
Keywords: Segmentation, Tracking, Biology

# MIDAP: Automated image segmentation and tracking for time-lapse microscopy of bacterial cells.

MIDAP is a flexible and user-friendly software for the automated analysis of
live-cell microscopy images of bacteria growing in a monolayer in microfluidics
chambers.

Through its graphical user interface, a selection of state-of-the-art
segmentation and tracking tools are provided, allowing the user to select the
most suited ones for their particular data set. Thanks to its modular
structure, additional segmentation and tracking tools can easily be integrated
as they are becoming available. After running the automated image analysis, the
user has the option to visually inspect and, if needed, manually correct
segmentation and tracking.

Documentation at https://github.com/Microbial-Systems-Ecology/midap/wiki
termichess 0.1.4
A chess game on your terminal
Requires Python: >=3.10

# Termichess

A game of chess in your terminal. Built using the amazing TUI framework `Textual`.

## Demo

https://github.com/user-attachments/assets/305f1e5b-9c76-474f-b30e-5bee12ac3be8

## Features

- ♟️ Play chess right in your terminal
- 🧠 Stockfish integration for chess engine
- ✅ Move validation and legal move highlighting
- 🎨 Change board themes
- 🤓 Variety of geeky board pieces
- ⚙️ Configuration menu for different options to change on the fly

## Installation

1. Please use Python 3.10 within your favourite venv. I have only tested currently only on `python 3.10`

2. Install Stockfish:

   - On Ubuntu or Debian: `sudo apt-get install stockfish`
   - On macOS with Homebrew: `brew install stockfish`
   - On Windows, download from [Stockfish's official website](https://stockfishchess.org/download/) and add it to your system PATH.

3. Install TermiChess:

`pip install termichess`

## Running the Game

After installation, you can start the game by simply running:

`termichess`

- To exit out at any time , Press `q` .
- To restart the game click on the `Restart` button

## Running via Docker

You can also run `termichess` via Docker if that's what you prefer.

`docker run -it ghcr.io/whiletruelearn/termichess:latest termichess`

Note : Please keep `sound` config to off while using `docker`

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

## License

This project is licensed under the Apache License - see the LICENSE file for details.

## Acknowledgments

- [Textual](https://github.com/Textualize/textual) for the TUI framework
- [python-chess](https://github.com/niklasf/python-chess) for chess logic
- [Stockfish](https://stockfishchess.org/) for the chess engine
pyfy6900-tspspi 0.0.1a2
(Unofficial) control library for the FY6900 function generator
Requires Python: >=3.6

# (Unofficial) control library for the FY6900 function generator

![FY6900 front panel](https://raw.githubusercontent.com/tspspi/pyfy6900/master/doc/fy6900frontside.jpg)

This is a small and simple control library for the FY6900 function generator. It's
a implementation for the [pylabdevs](https://github.com/tspspi/pylabdevs) ```FunctionGenerator```
class.

# Installation

```
pip install pyfy6900-tspspi
```

# Example usage

## Simple setting of predefined waveforms and parameters

```
import numpy as np

from pyfy6900 import fy6900
from labdevices.functiongenerator import FunctionGeneratorWaveform
from time import sleep

with fy6900.FY6900Serial("COM4", debug = True) as fg:
	print(f"Device identifies as {fg.identify()}")

	fg.set_channel_enabled(0, False)
	fg.set_channel_enabled(1, False)

	fg.set_channel_waveform(0, FunctionGeneratorWaveform.SINE)
	fg.set_channel_frequency(0, 1e3)
	fg.set_channel_offset(0, 2.5)
	fg.set_channel_amplitude(0, 5)
	fg.set_channel_enabled(0, True)

	for frq in np.arange(1, 60e6, 100):
		fg.set_channel_frequency(0, frq)
		print(f"Set new frequency {fg.get_channel_frequency(0)}")

	fg.set_channel_enabled(0, False)
```

## Uploading arbitrary waveform generated using numpy

```
import numpy as np
import matplotlib.pyplot as plt

from pyfy6900 import fy6900

from time import sleep

with fy6900.FY6900Serial("COM3", debug = "True") as fg:
	fg.identify()

	t = np.linspace(0, 2 * np.pi, 8192)
	wv = (np.sin(t) + np.sin(2*t) + np.sin(3*t))

	# Display before upload
	plt.plot(t, wv)
	plt.show()

	# Uploading
	fg.upload_waveform(61, wv, normalize = True)

	# Selecting channel waveform
	fg.set_channel_waveform(0, arbitrary = 61)
```