semvec/pypi-packages huggingface dataset:
ul-key 1.2.1
UL-Key An indispensable assistant in data encryption.
Requires Python: >=3.7

# Install
```shell
pip install ul-key==version
```


## Example
```python
from ulkey import encode_ul, decode_ul

encoded = encode_ul("hello world!", seed="ul-key", mode="dynamic")
decoded = decode_ul(encoded, seed="ul-key", mode="dynamic")

print(encoded)
print(decoded)
```


### Examples console use
```none-key
ulkey-encode "text"
````
_________________

```key
ulkey-encode "Текст" --key "мой_секретный_ключ"
```
simple-talking-anime-avatar 0.0.6
A simple python package to generate image or video of a talking avatar based on text or audio.
Requires Python: >=3.10

# simple_talking_anime_avatar
Simple python package to generate talking anime avatar video.

![Talking avatar example](https://github.com/snow884/simple_talking_anime_avatar/raw/master/speaking_avatar_example.gif "Speaking avatar gif")

## Installation

```
pip install simple_talking_anime_avatar
```

## Usage

Here is how to use this package to generate an image of a woman pronuncing the letter 'u'
```
import cv2

from src.simple_talking_anime_avatar.avatar_gen import get_image_speaking

image_avatar_speaking_u = get_image_speaking("u")
cv2.imwrite("speaking_avatar_u.png", image_avatar_speaking_u)
```

This will generate an image looking something like this:

![Pronuncing u](https://github.com/snow884/simple_talking_anime_avatar/raw/master/speaking_avatar_u.png "Pronuncing u")

Here is how to generate the video at the top using the library pyttsx3. Note that pyttsx3 works differently on different systems. There is also other packages for generating speech from text.
```

import pyttsx3

from src.simple_talking_anime_avatar.speech_to_vid import get_speaker_video

engine = pyttsx3.init()
voices = engine.getProperty("voices")

engine.setProperty("rate", 110)

engine.setProperty("voice", "com.apple.voice.compact.en-AU.Karen")

engine.say("Hello everyone! This is a test of speaking avatar python package.")
engine.save_to_file(
    "Hello everyone! This is a test of speaking avatar python package.", "test.wav"
)
engine.runAndWait()

get_speaker_video("test.mp4", "test.wav", 30)
```
totalrecon 0.1.0
Passive recon extractor and AI summarizer for CTFs, red teams, and open-source recon tooling.
Requires Python: >=3.8

# totalrecon

[![PyPI version](https://img.shields.io/pypi/v/totalrecon?color=brightgreen)](https://pypi.org/project/totalrecon/)

**totalrecon** is a lightweight Python library for passive reconnaissance. It extracts subdomains, emails, and S3 buckets from text and PDF files, and uses a fine-tuned AI model to summarize sensitive infrastructure mentions.

>  Built for red teamers, bug bounty hunters, CTF players, and cyber analysts.

---

## Features

- Extract intelligence from plaintext and PDF files  
- Detect subdomains, emails, and AWS S3 buckets  
- Summarize recon info with a fine-tuned `flan-t5-small` model  
- Offline and lightweight — no OpenAI key required  
- Trained on synthetic recon examples tailored for real-world use  

---

## Installation

```bash
pip install totalrecon
```

Or from source:

```bash
git clone https://github.com/josh1643/totalrecon.git
cd totalrecon
pip install .
```

---

## Quick Start

### Python Example

```python
from totalrecon.extract import extract_from_text

text = '''
Found subdomain: api.dev.example.com
Email: admin@example.com
S3 bucket: s3://backup-prod-private
'''

results = extract_from_text(text)

print(results["domains"])          # ['api.dev.example.com']
print(results["emails"])           # ['admin@example.com']
print(results["s3_buckets"])       # ['s3://backup-prod-private']
print(results["recon_summaries"])  # ['Possible backup S3 bucket exposed via dev subdomain.']
```

---

## About the Model

This project uses a fine-tuned `FLAN-t5-small` model hosted on the Hugging Face Hub:

🔗 https://huggingface.co/wassermanrjoshua/totalrecon-flan-t5

- Summarizes cyber recon and passive intel  
- Runs **entirely offline** after first load  
- No setup required — model is automatically downloaded on first use

This means:
- You don’t need to clone or manually download any model files
- Just `pip install totalrecon` and run it — the model loads when needed


---

## Contributing

Contributions welcome!  
1. Fork the repo  
2. Create a feature branch  
3. Open a pull request  

---

## License

MIT License — see [`LICENSE`](LICENSE) for full terms.

---

## Author

Created by Joshua Wasserman for real-world recon workflows and open-source tooling.

- GitHub Repository: [https://github.com/josh1643/totalrecon](https://github.com/josh1643/totalrecon)

---
r3frame 2025.0.25
A simple and powerful pygame framework

![logo](https://github.com/r3shape/koncept/blob/main/koncept/assets/r3-sticker.png?raw=true)  
![PyPi Package version](https://img.shields.io/pypi/v/r3frame?style=for-the-badge&logo=pypi&logoColor=white&label=r3frame&labelColor=black&color=white&link=https%3A%2F%2Fpypi.org%2Fproject%2Fr3frame%2F2025.0.2%2F
)  
![GitHub Stars](https://img.shields.io/github/stars/r3shape/r3frame?style=for-the-badge&label=stars&labelColor=black&color=white)
![License](https://img.shields.io/badge/mit-badge?style=for-the-badge&logo=mit&logoColor=white&label=License&labelColor=black&color=white)

## What is r3frame?  
**r3frame** is a game development framework designed to help developers create games with **more speed and less hassle**. It provides a structured foundation for handling scenes, objects, UI, input, and rendering, so you can focus on making games instead of reinventing the wheel.  

## Why Use r3frame?  
- **Save Time** â€“ No need to build a game structure from scratch.  
- **Better Organization** â€“ Scenes, assets, and objects are neatly managed.  
- **Pygame, but Better** â€“ All the flexibility of Pygame, with added convenience.  

## Features  
- **Modularity** â€“ Manage your game with a clean and modular API.  
- **Scene & Object Management** â€“ Easily define and switch between game scenes.  
- **Custom UI System** â€“ Buttons, text fields, and interface-scripting made simple.  
- **Asset Loading** â€“ Load images and sprite sheets efficiently.  
- **Input Handling** â€“ Keyboard and mouse events with built-in support.  
- **Partitioning Systems** â€“ Efficient object management for game worlds of many sizes.  

## Installation  
Install **r3frame** via pip:  

```sh
pip install r3frame
```

## Contributing  
Want to help improve **r3frame**? Feel free to contribute by submitting issues, suggesting features, or making pull requests!  

## License  
**r3frame** is open-source under the **MIT License.**
cabana 0.0.1
Collagen fibre analyser for quantifying collagen fibre architecture in IHC and fluorescence microscopy images.

[//]: # (# CABANA - Collagen Fibre Analyzer)
![image](cabana.png)
[![PyPI version](https://badge.fury.io/py/cabana.svg)](https://pypi.org/project/cabana/1.0.1/)
[![Documentation Status](https://readthedocs.org/projects/cabana/badge/?version=latest)](https://cabana.readthedocs.io/en/latest/?badge=latest)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)

CABANA (CollAgen FiBre ANAlyzer) is a comprehensive toolkit for analyzing collagen fibre architecture in immunohistochemistry (IHC) and fluorescence microscopy images. It provides:

- Automated detection and quantification of collagen fibres
- Analysis of fibre orientation, length, and thickness
- Gap analysis for inter-fibre and intra-fibre spaces
- Interactive parameter optimization interface
- Batch processing for large datasets

CABANA combines advanced computer vision algorithms with an intuitive user interface, making it accessible to researchers without extensive programming experience while providing detailed quantitative data for comprehensive analysis of collagen architecture.

## System Requirements

- **Processor (CPU):** Intel Core i7, AMD Ryzen 7, or higher recommended
- **Memory (RAM):** Minimum 16 GB, 32 GB recommended
- **GPU:** NVIDIA GeForce GTX/RTX series with at least 10 GB VRAM recommended
- **Python:** 3.8 or newer


## Quick Installation

Install CABANA using pip:

```bash
pip install -U cabana
```
or install the latest version on GitHub:

```bash
pip install git+https://github.com/lxfhfut/Cabana.git
```

After installation, you can launch the CABANA GUI by running:

```bash
python -m cabana
```

Alternatively, you can import CABANA in your Python code for customized analysis (**see examples in Tutorials**):

```python
import cabana
```

## Documentation

Comprehensive documentation is available at:
[https://cabana.readthedocs.io/en/latest/](https://cabana.readthedocs.io/en/latest/)

## Tutorials

We provide an interactive Jupyter notebook tutorial to help you get started:
[CABANA Tutorial](https://cabana.readthedocs.io/en/latest/_static/tutorial.ipynb)

## Citation

If you use CABANA in your research, please cite:
<!--
```
Magenau A, et al. (2025). CABANA: A comprehensive toolkit for collagen fibre analysis in biomedical imaging. Journal of XYZ. DOI: XYZ
```-->

## License

CABANA is released under the MIT License.

## Contact

For questions and support, please contact:
- Xufeng Lin - <x.lin@garvan.org.au>
- Astrid Magenau - <a.magenau@garvan.org.au>
TuModeloDeClientes-Navarro 4.0.3
Modelo de clientes para practicar Herencia, modulos y polimorfismo en Python

# Para ejecutar pueden poner pip instal TuModeloDeClientes_Navarro
# y luego se meten al PATH que les indica vscode, se meten a la carpeta
# TuModeloDeClientes_Navarro/main para entrar al script principal del programa
# 
# Consigna
# Crea  un programa que permita el modelamiento de Clientes en una página de compras.
#  Se debe utilizar Programación Orientada a Objetos.

# Se evaluará el uso correcto de atributos y métodos. Crea un paquete redistribuible con el programa creado.

# Objetivos
# Demostrar la comprensión de los conceptos de “Clases” y “Objetos”

# Ejecutar correctamente el uso de paquetes y librerías.

# Requisitos
# Clases (para cliente),

# Atributos de instancia (opcional alguno de clase)

# Métodos (por fuera de los magic methods)

# Uso de módulos/paquetes

# Generación de paquete redistribuible

# Recomendaciones
# "La Clase Cliente debe tener mínimo 4 atributos,

# Se debe utilizar el método init, para definir uno o más de los atributos del punto anterior

# Se debe utilizar el método str() para darle nombre a los objetos.

# Aparte, genera 2 métodos por fuera de los magic methods

# Para crear el paquete distribuible también como adicional el archivo de la Pre entrega #1.
FigArea 0.1.0
Library for calculating the area of geometric shapes
Requires Python: >=3.7


# Geometry

Лёгкая Python-библиотека для вычисления площади геометрических фигур.

---

## Возможности

- Вычисление площади круга по радиусу.
- Вычисление площади треугольника по трём сторонам (формула Герона).
- Вычисление площади прямоугольника.
- Проверка, является ли треугольник прямоугольным.
- Лёгкое расширение для других фигур.

---

## Установка

```bash
pip install geometry
```

# Быстрый старт
```python
from geometry import Circle, Triangle

# Площадь круга
c = Circle(5)
print(c.area())  # 78.53981633974483

# Площадь треугольника
t = Triangle(3, 4, 5)
print(t.area())  # 6.0

# Проверка на прямоугольность
print(t.is_right_angled())  # True
```
# Требования
Python 3.7+

Библиотека math (входит в стандартную библиотеку Python)

# Тестирование
Тесты находятся в папке tests/.

Для запуска всех тестов:

```bash

python -m unittest discover tests
```

# Лицензия
Этот проект распространяется под лицензией MIT.

# Автор
Kirill Domitin — domitin@gmail.com
nevora 0.1.0
Nevora: Transform raw sales and returns data into Nevada chart format for warranty and reliability analysis.
Requires Python: >=3.7



```markdown
# 📦 Nevora
---

# Nevora: Transform Warranty and Reliability Data with Ease

Nevora helps you seamlessly convert sales and returns data into Nevada chart format — the essential starting point for warranty analysis, survival modeling, and reliability forecasting.  
Built for engineers, analysts, and data scientists who want clean, analysis-ready data without the manual grind.

---
[pyproject.toml](pyproject.toml)
## 🚀 Key Features
- 📊 Nevada Chart Converter: Instantly pivot raw sales/returns into a professional Nevada matrix.
- ⏳ Auto Time Bucketing: Monthly, quarterly, yearly — you choose.
- 🔍 Ready for Survival Analysis: Your first step to reliability modeling.
- 🛠️ Future Enhancements: Plot Nevada charts, fit survival curves, reliability forecasts.
- 🧹 Clean API: Simple, minimalistic, and powerful.

---

## 📥 Installation

```bash
pip install nevora
```

---

## ⚡ Quickstart

```python
import pandas as pd
from nevora import NevadaConverter

# Load your sales/returns data
df = pd.read_csv('sales_returns.csv')

# Convert to Nevada format
converter = NevadaConverter(time_bucket='M')  # 'M' = monthly bucketing
nevada_matrix = converter.to_nevada_format(df)

# View the output
print(nevada_matrix)
```

> 🎯 Tip: You can use any custom time bucket like `'Q'` (quarterly), `'Y'` (yearly) based on your needs.

---

## 📈 Upcoming Roadmap
- 🎨 Plot beautiful Nevada charts automatically
- ⏱️ Fit Kaplan-Meier and Weibull survival models
- 🔮 Forecast warranty returns and reliability metrics
- 🌎 Export datasets for external tools like ReliaSoft and Minitab

---

## 💬 Why Nevora?
Warranty analysis and reliability modeling start with good data.  
Nevora automates the most painful and error-prone step, letting you focus on insights — not spreadsheet wrangling.

---

## 🤝 Contributing
Pull requests, feature suggestions, and issue reports are warmly welcome.  
Let's make warranty and reliability analysis effortless for everyone.

---

## 📄 License
MIT License
redbuild 2.3.0
magic containerized builds
Requires Python: <4.0,>=3.9


# redbuild

magic containerized builds

## overview

redbuild enables software to be built in pre-defined environments using the power of containerization. with `podman` installed, any supported project can be built with a single command. projects provide a `build.docker` and `build.sh` for defining the build environment and build steps.

`redbuild`: just add water!

## install stable version from pypi

```sh
# with pipx (recommended)
pipx install redbuild
# with vanilla pip
pip install redbuild
```

## build from source

To build redbuild2, we will use the redbuild1 shell script to bootstrap the build environment and build redbuild2.
    
```sh
./bootstrap/redbuild.sh
```

this will output `./redbuild.bin` which you can symlink to one of your `$PATH` directories.

Here is a suggested setup:

```sh
mkdir -p ~/.bin
ln -s $(pwd)/redbuild.bin ~/.bin/redbuild
```

Now, you can run `redbuild` from anywhere!

## try the example!

```sh
cd example
redbuild build
```

## detailed usage

### creating the build environment and build script

1. create a `build.docker` file in the project root. this file should contain a `FROM` directive for the base image to use for the build environment. the build environment should contain all the tools necessary to build the project.
it's also very important that the last line of the dockerfile is `CMD ["/bin/bash", "-l"]`. this is necessary for redbuild to work.

    an example `build.docker`:

    ```dockerfile
    FROM debian:bookworm-slim

    # install dependencies
    RUN apt-get update && apt-get install -y \
        bash \
        curl wget xz-utils \
        gcc make libc6-dev libcurl4 \
        git libxml2 \
        && rm -rf /var/lib/apt/lists/* && apt autoremove -y && apt clean


    # install dlang
    RUN curl -fsS https://dlang.org/install.sh | bash -s install ldc-1.30.0 \
        && echo "source ~/dlang/ldc-1.30.0/activate" >> ~/.bashrc

    # set up main to run bash (necessary for redbuild)
    CMD ["/bin/bash", "-l"]
    ```

2. create a `build.sh` file in the project root. this file should contain the steps necessary to build the project. the build script should be written to be run in the build environment.

    `build.sh`:

    ```sh
    #!/bin/bash
    dub build --compiler ldc2 -B release
    ```

that's it! now you can build the project with `redbuild build`, copy it into the project root, and run it. you can also open an interactive shell in the build environment with `redbuild shell`.