semvec/pypi-packages huggingface dataset:
OTF-General 0.1.0
Alchemical binding free‐energy workflow
License: MIT
Requires Python: >=3.12

# OTF General

Implementation of On-The-Fly (OTF) Optimization for alchemical binding free energy simulations using thermodynamic integration in AMBER20. See [10.26434/chemrxiv-2023-rtpsz](https://doi.org/10.26434/chemrxiv-2023-rtpsz) for details.

## Setup

1. Create a directory, clone otf_general.
2. Install [Anaconda](https://docs.anaconda.com/anaconda/install/).
3. Install dependencies:
   - pymbar==4.0.3
   - alchemlyb==2.3.1
   - scipy==1.8.1
   - AMBER20
   - GAUSSIAN 09 or GAUSSIAN 16 (for ligand parameterization)

## Algorithm

### On-The-Fly Resource Optimization for Binding Free Energy Simulations

1. Perform an initial run of the simulation.
2. Apply Automatic Equilibration Detection (AED) and decorrelation:
   - Split gradient data in half and bin it into histograms.
   - Calculate the Jensen-Shannon (JS) distance between the histograms.
3. Evaluate the JS distance:
   - If JS distance < 0.1:
     - Terminate simulation (converged).
   - Else:
     - Check if simulation time is less than 6.5 nanoseconds (ns):
       - If yes:
         - Proceed to Step 4 (short additional simulation).
       - Else:
         - Check if there are more than 50 decorrelated samples:
           - If yes:
             - Terminate simulation (sufficient decorrelated samples).
           - Else:
             - Proceed to Step 4 (short additional simulation).
4. Run a short additional simulation and increment the simulation time.
5. Evaluate total computed simulation time:
   - If total simulation time < 10.5 ns:
     - Repeat from Step 2.
   - Else:
     - Terminate simulation (time limit reached).
rijndael3d 1.1.1
An enhanced version of Rijndael encryption
License: MIT
Requires Python: >=3.13

# Rijndael3D
Rijndael3D is my work-in-progress extension of the Rijndael cipher that works in 512-bit 4x4x4 blocks of bytes. This module uses new layer-based permutation algorithms together with modified versions of regular Rijndael components to utilize the 3 dimensional structure of blocks.
This module is programmed in pure Python, it implements finite-field arithmetic in GF(2<sup>8</sup>) and is boosted by the [`numba`](https://numba.pydata.org/) module internally.

## Cipher Specifications
- Key size: 512 bits
- Block size: 512 bits
- Number of rounds: 16 rounds
- Structure: substitution–permutation network
- Padding method: pseudo-randomized (seeded) padding using the SHA512 of the key.
- Supported modes: the current version of Rijndael3D supports the following modes; `ECB`, `CBC`, `CTR`, and `GCM`.

## Disclaimer
This module was built as a fun project to learn cryptography and cryptanalysis. It is not designed to withstand side channel attacks or other advanced cryptanalysis techniques.

## Installation
This module is available only on PyPI, installation via pip:
```
pip install rijndael3d
```

## Basic Usage
Because the block size is 512 bits, the keys and initialization vectors must all be in the matching size of 512 bits.

The basic usage of this module is as follows (CTR mode for example):

Importing the appropriate functions:
```
from rijndael3d.modes.ctr import ctr_encrypt, ctr_decrypt
```

Encrypting:
```
encrypted = ctr_encrypt(plaintext, key, iv)
```

Decrypting:
```
decrypted = ctr_decrypt(ciphertext, key, iv)
```

## Advanced Usage
If you want to utilize the internal functions of this module or take a closer look at them, this is the section for you. 

The functionality of this module are segmented into the appropriate files and directory:
- `block.py`:            All internal block manipulation functions.
- `cipher.py`:           Round performing and single block encryption/decryption.
- `constants.py`:        Contains all the constants used.
- `debug_operations.py`: Debug-related functions, not used in normal usage of the module.
- `gf_arithmetic.py`:    The implementation for GF(2<sup>8</sup>) arithmetic.
- `key_schedule.py`:     The key scheduling algorithm.
- `padding.py`:          The padding mechanism.
- `utils.py`:            Utility functions.
- The `modes` directory that contains the code for each mode of operation.
tryppy 0.1.0
Kurze Beschreibung deines Pakets
License: MIT
Requires Python: >=3.6

# tryppy

**Tryppy** is an open-source Python package designed to simplify segmentation, feature extraction, and classification of microscopy data from *Trypanosoma brucei*.  
It has been developed specifically for the **TrypTag** dataset. The performance on other microscopy datasets has not been evaluated and may vary.

## How to install
We provided several options to make the functionality of tryppy available to you. You can choose to install the package via pip or github into your python environment. Alternatively you can choose to use our code via the provided Docker container. This is especially usefull for an easy to use proof of concept, when trying out new data.

### From Pypi
```pip install tryppy```

Here you find the [official pypi website](TODO).

### From Github
```pip install git+https://github.com/himmiE/tryppy.git```

### Using Docker Hub (recommended)
An official Docker image is available to run `tryppy` without installing Python or any dependencies locally.
If you have Docker installed, you can pull the latest image with:

```docker build -t tryppy:latest .```

```docker run tryppy:latest```

This launches an interactive Python shell with `tryppy` preinstalled.
## How to use
No matter which approach you choose, you may want to look at the *config.json* file. (describe where it is to be found) This file is to be edited by you whenever you want to change something about the workflow. It is probably a good idea to save changes in a new config file, in case you break something. You can also change the filename to have different versions. You will be able to choose the right config file later in your code.

### The Config File
When you first run your code a basic config-file will be created for you. ...

| option        | description   | example_input |
| ------------- |:-------------:|---------------|
| left foo      | right foo     |![This is an alt text.](/image/sample.webp "This is a sample image.")|
| left bar      | right bar     ||
| left baz      | right baz     ||

### The Data

### Use In Code


```
import NAME_OF_PACKAGE

# define the path for your data.
# if you have a custom config.json file, it should go here.
data_path = directory_where_data_should_do

# if you are handling multiple tasks with this package or are experimenting
# with different setups, you can rename the config file and pass the filename
# (relative to your defined data_path).

obj_name = NAME_OF_PACKAGE(data_path)
# alt: 
# obj_name = NAME_OF_PACKAGE(data_path, config_filename = 'save_all_config.json')

obj_name.run()

```


## License

TODO
GeoDSKit 0.2.0
A modern comprehensive geographic datasets handler kit.
License: MIT
Requires Python: <3.12,>=3.8.1

# GeoDSKit

A modern comprehensive geographic datasets handler kit.

![kfRdDh](https://songshgeo-picgo-1302043007.cos.ap-beijing.myqcloud.com/uPic/kfRdDh.png)

## Features

- [ ] Search and automatically download [NOAA](https://www.ncei.noaa.gov/) datasets.
- [ ] Handle local CMIP6 datasets with standard naming convention in batch.
- [x] NetCDF4 file handler.
- [x] Find and filter geospatial dataset files.

## Installation

```bash
pip install geo-dskit
```
firesense 0.10.2
AI-powered fire detection system using Gemma 3N E4B vision model
License: MIT
Requires Python: >=3.11
Keywords: ai, computer-vision, fire-detection, gemma, safety, video-analysis, wildfire

# FireSense

[![Python 3.11+](https://img.shields.io/badge/python-3.11+-blue.svg)](https://www.python.org/downloads/)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

FireSense is a video feed analyzer that detects fires, powered by the Gemma 3N vision model.

<a href="https://youtu.be/16kw5rZLims">
  <img src="images/presentation.png" alt="FireSense Demo" width="800px">
</a>

## Pipeline

<img src="images/pipeline.png" alt="FireSense Pipeline" style="max-width: 800px;">



## Quick Start

### Installation

```bash
# Install pypi package
pip install firesense

or

# Install from source code:
uv pip install -e .
```

### Command Line Usage

```bash
# Analyze a YouTube video
firesense analyze <youtube_video_id>

# Launch demo with local server
firesense demo <youtube_video_id> --local

```



https://github.com/user-attachments/assets/b8fdba5b-bd2d-44c6-be4e-8fb6499b62a8





Ngrok Integration
```bash
# setup ngrok
ngrok config add-authtoken <your_ngrok_auth_key>

# Launch demo with local server and ngrok tunnel
firesense demo <youtube_video_id> --local --ngrok

```

### Python Usage

```python
from firesense import setup_model, infer

# Setup model
model, tokenizer = setup_model()

# Run inference
inference_result = infer(model, tokenizer, system_prompt, user_prompt, image_path)
```

## Features

- 🚀 **Fast Development**: Leverages uv for 10-100x faster dependency installation
- 📦 **Modern Packaging**: PEP 621 compliant with pyproject.toml
- 🔍 **Type Safety**: Full mypy strict mode support (uv run mypy src)
- ✅ **Testing**: Comprehensive pytest setup with coverage



## Contributing

1. Fork the repository
2. Create a feature branch (`git checkout -b feature/amazing-feature`)
3. Make your changes
4. Run tests and checks (`make check`)
5. Commit your changes (`git commit -m 'Add amazing feature'`)
6. Push to the branch (`git push origin feature/amazing-feature`)
7. Open a Pull Request

## Testing

```bash
# Install the project with development dependencies using:
uv pip install -e ".[dev]"

# Run the tests with:
uv run pytest

```

## Type Safety

```bash
# Full mypy strict mode support 
uv run mypy src
```

## Releasing

New releases are manually pushed to pypi:

```bash

make publish
```

## License

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