semvec/pypi-packages huggingface dataset:
footium-api 0.1.10
python api for the footium game
Requires Python: >=3.9

# footium_api
python api for footium


## Tutorials

```
pip install footium_api[notebooks]
```

- [setup](./notebooks/setup_notebook.ipynb) run this to set up for your wallets, clubs etc
- [my_players](./notebooks/my_players.ipynb) --> how to get your players
- [next_fixtures](./notebooks/next_fixtures.ipynb) --> get next features for your clubs
- [formations](./notebooks/my_players.ipynb) --> get the formations supported
lie_groups_py 0.2.0
Functions for the lie groups SE(2), SO(2), and SO(3), and SE(3).
Requires Python: <4.0,>=3.13

# LieGroupsPy
Functions for the Lie Algebra group SE(2) and SE(3)

$$ SE(2) =
\begin{bmatrix}
    R_{11} & R_{12} & t_1 \\
    R_{21} & R_{22} & t_2 \\
    0 & 0 & 1
\end{bmatrix} $$

where:
- \( $\mathbf{R} \in SO(2) $\) is the **rotation matrix**.
- \( $\mathbf{t} \in \mathbb{R}^2 $\) is the **translation vector**.

  
$$ SE(3) =
\begin{bmatrix}
    R_{11} & R_{12} & R_{13} & t_1 \\
    R_{21} & R_{22} & R_{23} & t_2 \\
    R_{31} & R_{32} & R_{33} & t_3 \\
    0 & 0 & 0 & 1
\end{bmatrix} $$

where:
- \( $\mathbf{R} \in SO(3) $\) is the **rotation matrix**.
- \( $\mathbf{t} \in \mathbb{R}^3 $\) is the **translation vector**.

This representation is commonly used in **robotics and computer vision** for rigid body transformations.

<p align="center" width="80%">
    <img width="500" alt="Screenshot 2025-03-31 at 9 37 41 AM" src="https://github.com/user-attachments/assets/15d5f56c-32f8-4e18-bb05-bf84c1b48fdc" />
</p>


## Install
To install the library run: `pip install lie_groups_py`

## Development
0. Install [Poetry](https://python-poetry.org/docs/#installing-with-the-official-installer)
1. `make init` to create the virtual environment and install dependencies
2. `make format` to format the code and check for errors
3. `make test` to run the test suite
4. `make clean` to delete the temporary files and directories
5. `poetry publish --build` to build and publish to https://pypi.org/project/lie_groups_py/


## Usage
```
"""Basic docstring for my module."""

import matplotlib.pyplot as plt
import numpy as np
from loguru import logger

from se3_group import se3


def main() -> None:
    """Run a simple demonstration."""
    pose_0 = se3.SE3(
        xyz=np.array([0.0, 0.0, 0.0]),
        rot=np.eye(3),
    )
    pose_1 = se3.SE3(
        xyz=np.array([[2.0], [4.0], [8.0]]),
        roll_pitch_yaw=np.array([np.pi / 2, np.pi / 4, np.pi / 8]),
    )

    logger.info(f"Pose 1: {pose_0}")
    logger.info(f"Pose 2: {pose_1}")

    fig = plt.figure()
    ax = fig.add_subplot(111, projection="3d")
    pose_0.plot(ax)
    pose_1.plot(ax)

    for t in np.arange(0.0, 1.01, 0.1):
        pose_interp = se3.interpolate(pose_1, pose_0, t=t)
        pose_interp.plot(ax)
        logger.info(f"Interpolated Pose at t={t:.2f}: {pose_interp}")

    plt.axis("equal")
    ax.set_xlabel("x-axis")
    ax.set_ylabel("y-axis")
    ax.set_zlabel("z-axis")
    plt.tight_layout()
    plt.show()


if __name__ == "__main__":
    main()

```
vineetb-osqp 0.0.6
OSQP: The Operator Splitting QP Solver
Requires Python: >=3.8

[![PyPI version](https://badge.fury.io/py/osqp.svg)](https://badge.fury.io/py/osqp)
[![Python 3.8‒3.13](https://img.shields.io/badge/python-3.8%E2%80%923.13-blue)](https://www.python.org)
[![Build](https://github.com/osqp/osqp-python/actions/workflows/build_default.yml/badge.svg)](https://github.com/osqp/osqp-python/actions/workflows/build_default.yml)

# OSQP Python
Python wrapper for [OSQP](https://osqp.org): The Operator Splitting QP solver.

The OSQP (Operator Splitting Quadratic Program) solver is a numerical
optimization package for solving problems in the form

$$\begin{array}{ll}
    \mbox{minimize} & \frac{1}{2} x^T P x + q^T x \\
    \mbox{subject to} & l \le A x \le u
\end{array}
$$

where $\( x \in \mathbf{R}^n \)$ is the optimization variable and $\( P \in \mathbf{S}^{n}_{+} \)$ is a positive semidefinite matrix.

## Installation
To install `osqp` for python, make sure that you're using a recent version of `pip` (`pip install --upgrade pip`)
and then use ``pip install osqp``.

To install `osqp` from source, clone the repository (`git clone https://github.com/osqp/osqp-python`)
and run `pip install .` from inside the cloned folder.

## Documentation
The interface is documented [here](https://osqp.org/docs/interfaces/python.html).
scad2gltf 0.1.0b1
Create GLTF files from OpenSCAD files.
Requires Python: >=3.9
Keywords: GLTF, OpenSCAD, conversion

# scad2gltf

scad2gltf is a python library for converting openscad code into colour gltf files using OpenSCAD and [pygltflib](https://gitlab.com/dodgyville/pygltflib).

scad2gltf was inspired by [colorscad](https://github.com/jschobben/colorscad) but does not use code from it.
dyad-app 0.1.7
Add your description here
Requires Python: >=3.10

# Dyad: AI Coding Mentor & Pair Programmer

Dyad is an **open-source**, **standalone** AI tool that levels up your coding skills and helps you build real-world software. It’s more than a code generator—it’s a dedicated mentor and practical companion that runs locally, connects to your codebase, and complements—not replaces—your IDE.

https://github.com/user-attachments/assets/51fd27a5-ade6-41b5-ab32-7788fc5b3231

Check out the [Dyad site](https://dyad.sh/) to see more videos of what Dyad looks like in action.

## What Dyad Offers

### Mentoring

- **Conversational AI:** Chat with Dyad like a teammate—it asks thoughtful questions and keeps the conversation flowing.
- **Personalized Tips:** Get bite-sized, tailored advice to master AI-assisted coding.
- **Human Expertise:** Access practical software engineering insights from senior engineers via screencasts.

### Pair Programming

- **Codebase Integration:** Reference files with `#file.py`—no more copying and pasting.
- **Easy Code Changes:** Apply AI-suggested edits with one click and review them in a side-by-side diff.
- **Expert Reviews:** Catch bugs and improve code quality with best-practice feedback.

### Learning Community

- Join [Dyad Academy](https://academy.dyad.sh/) for premium videos on AI coding tools, software engineering fundamentals, and building SaaS apps.

### Hackable

- Dyad is **hackable**—build custom agents in Python—and works with any LLM.

## Get Started

### Install

```sh
pip install dyad
```

### Run

From your project's root directory, run:

```sh
dyad
```

## Why Dyad?

- **Standalone Simplicity:** Complements your IDE without cluttering it.
- **Skill Growth:** Learn _how_ and _why_ AI suggests code in a full-screen chat UI.
- **Practical Focus:** Built for real-world coding, not just academic exercises.

> _"AI helped me go from basic Python to creating a UI framework used by thousands. Dyad isn’t just about writing code—it’s about leveling up your skills."_  
> — Will Chen, Creator of Dyad

Give Dyad a try and explore the [docs](https://docs.dyad.sh) for more.
filemint 0.1.0
A utility for generating test files in various formats
Requires Python: >=3.7

# FileMint

A Python utility for generating test files in various formats. FileMint makes it easy to create test datasets for development, testing, and demonstrations.

## Features

- Generate structured CSV files with consistent columns
- Generate unstructured text files with random content
- Generate binary files of specified sizes
- Generate intentionally malformed CSV files for testing error handling
- Command-line interface for easy file generation

## Installation

```bash
pip install filemint
```

## Usage

### Command Line

Generate test files using the command-line interface:

```bash
# Generate default set of test files (10 of each type)
filemint

# Specify output directory
filemint --output-dir my_test_files

# Specify number of each file type
filemint --csv 5 --txt 10 --bin 3 --invalid 2
```

### Python API

```python
from filemint.generators import generate_test_files

# Generate test files with default settings
files = generate_test_files(output_dir="test_files")

# Customize the number of each file type
files = generate_test_files(
    output_dir="test_files",
    num_csv=5,
    num_txt=10,
    num_binary=3,
    num_invalid=2
)

# Generate individual files
from filemint.generators import generate_csv, generate_txt, generate_binary, generate_invalid_csv

# Generate a CSV file with 20 rows
csv_file = generate_csv("output_dir", "data.csv", num_rows=20)

# Generate a text file with 50 lines
text_file = generate_txt("output_dir", "notes.txt", num_lines=50)

# Generate a 1MB binary file
binary_file = generate_binary("output_dir", "data.bin", size_in_kb=1024)

# Generate an invalid CSV file with 15 rows
invalid_file = generate_invalid_csv("output_dir", "bad_data.csv", num_rows=15)
```

## Development

### Setup

1. Clone the repository
2. Create and activate a virtual environment
3. Install development dependencies

```bash
git clone https://github.com/yourusername/filemint.git
cd filemint
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate
pip install -e ".[dev]"
```

### Testing

Run tests using pytest:

```bash
pytest
```

## License

This project is licensed under the MIT License - see the LICENSE file for details.
hyperSel 5.7
A Python-based web automation and data scraping framework
Requires Python: >=3.6


# HyperSel

## Overview

HyperSel is a Python-based framework for web automation and data scraping. It simplifies crawling, automating interactions, and data extraction from web pages. It is built with various robust tools to handle dynamic and complex web interactions efficiently, offering features such as headless browsing, proxy support, and API sniffing.

## Features

- **Headless Browsing**: Supports headless mode for efficient and faster crawls.
- **Proxies**: Integration for rotating proxies, ensuring anonymity and bypassing restrictions.
- **Playwright and Selenium Support**: Utilizes Playwright and Selenium for browser automation, providing flexible tools for interacting with websites.
- **Undetected ChromeDriver**: Uses undetected ChromeDriver to bypass detection by anti-scraping mechanisms.
- **WebDriver Manager**: Automatically manages and updates drivers.
- **Recursive Crawling**: Supports recursive crawling to traverse multiple levels of web pages.
- **API Sniffer**: Built-in API request sniffer to intercept and extract data from API calls made by websites.
- **Regex Tools**: Built-in regex utilities for parsing and extracting data from web pages.
- **Logging**: Comprehensive logging to track scraping sessions and errors.

## Installation

To set up HyperSel, follow the steps below:

1. **Clone the Repository**:
   ```bash
   git clone https://github.com/foreandr/hyperSel.git
   ```

2. **Install Dependencies**:
   Navigate to the project directory and install the required Python packages:
   ```bash
   cd hyperSel
   pip install -r req.txt
   ```

3. **Install from PyPI**:
   You can also install HyperSel directly from PyPI using pip:
   ```bash
   pip install hyperSel
   ```

## Usage

Once installed, you can import and start using HyperSel in your projects. Example usage:

```python
import hyperSel
# Your web automation code here
```

## Contributing
Feel free to submit issues and pull requests. Contributions are welcome!

## License
This project is licensed under the MIT License.
codemetrica 0.1.0
A package for calculating metrics and detecting code smells
Requires Python: >=3.10

# Codemetrica

A Python library for calculating code metrics and detecting code smells in Python codebases using tree-sitter.

## Features

- Comprehensive code metrics calculation
- Code smell detection
- Support for analyzing Python files, classes, and methods
- Easy-to-use API
- Powered by tree-sitter for robust parsing

## Prerequisites

- Python 3.10 or higher
- GCC compiler (for building tree-sitter grammar)
- Git (for cloning tree-sitter repository)

## Installation

```bash
# Clone the repository
git clone https://github.com/yourusername/codemetrica.git
cd codemetrica

# Install the package
pip install -e .
```

The installation process will:
1. Clone the tree-sitter-python repository
2. Build the tree-sitter grammar
3. Install the package in development mode

## Quick Start

```python
from codemetrica import File, GodClass

# Analyze a Python file
f = File("example.py")

# Get all classes in the file
classes = f.get_classes()

# Check for code smells
for class_obj in classes:
    if GodClass.detect(class_obj):
        print(f"Found God Class: {class_obj.name}")
```

## Available Metrics

### Size Metrics
- Lines of Code (LOC)
- Source Lines of Code (SLOC)
- Kilo Lines of Code (KLOC)
- Comment Lines of Code (CLOC)
- Number of Methods (NOM)
- Number of Classes (NOC)
- Number of Fields (NOF)
- Number of Public Methods (NOPM)

### Complexity Metrics
- Cyclomatic Complexity (CC)
- Weighted Methods per Class (WMC)
- NPath Complexity
- Essential Complexity
- Halstead Metrics
- Nested Block Depth (NBD)
- Decision Density

### Object-Oriented Metrics
- Depth of Inheritance Tree (DIT)
- Number of Children (NOC)
- Response for a Class (RFC)
- Coupling Between Objects (CBO)
- Lack of Cohesion of Methods (LCOM)
- And more...

## Available Code Smells

### General Smells
- Broken Modularization
- Complex Conditional
- Deficient Encapsulation
- Dispersed Coupling
- Empty catch clause
- And more...

### Class Level Smells
- Brain Class
- Class Data Should Be Private
- Complex Class
- Data Class
- God Class
- Large Class
- Lazy Class

### Method Level Smells
- Abstract Function Call From Constructor
- Brain Method
- Complex Method
- Long Method
- Long Parameter List

## Development

To build the tree-sitter grammar manually:

```bash
# Clone tree-sitter-python if not already done
git clone https://github.com/tree-sitter/tree-sitter-python.git

# Build the grammar
gcc -shared -o build/my-languages.so -I./tree-sitter-python/src tree-sitter-python/src/parser.c -fPIC
```

## License

MIT License
djangocms-zb-filer 1.1.2
Zibanu Filer Plugin for Django CMS
Requires Python: >=3.9
Keywords: djangocms, django, zibanu, filer

Django CMS Zibanu Filer Extension
-----------

Django CMS Zibanu Filer Extension es un complemento para django CMS que le permite agregar publicaciones a su sitio, con
archivos, fecha de publicación, fecha de despublicación, icono, etc.
Al agregar en su sitio puede elegir mostrar una categoría.

![](preview.png)

Utiliza archivos administrados por Django Filer .

Utiliza PDF generados por xhtml2pdf .


Documentación
-----------

Ver requerimientos en el archivo setup.cfg para dependencias adicionales:

python 3.9+ < 4.0 - django 3.2.11 - django CMS 3.9.0 - django-filer 2.1.2 - xhtml2pdf 0.2.7

Asegúrese de que django-filer esté instalado y configurado correctamente.

Instalación
-----------

1. Correr pip install djangocms-zb-filer
2. Añadir 'djangocms_zb_filer' a su INSTALLED_APPS
3. Correr "python manage.py migrate"
4. Incluya en urls.py de su proyecto la URLconf de Django CMS Zibanu Filer Extension antes de la de cms.urls así:    

    
    urlpatterns = [
       path('admin/', admin.site.urls),
       path('djangocms_zb_filer/', include('djangocms_zb_filer.urls')),
       path('', include('cms.urls')),
    ]

5. Inicie el servidor de desarrollo y visite http://su_servidor/admin/
    para crear una publicación (Necesitará que la aplicación Admin esté habilitada).

![](panel_admin.png)

Configuración
------
Tenga en cuenta que las plantillas proporcionadas son mínimas por diseño. 
Los puede adaptar y anular según los requisitos de su proyecto.

Este complemento proporciona una plantilla default para todas las instancias. Puede proporcionar opciones de plantilla 
adicionales agregando la constante DJANGOCMS_ZB_FILER_TEMPLATES en su settings.py:

    DJANGOCMS_ZB_FILER_TEMPLATES = [
        ('template_mejorado', _('Template Mejorado')),
    ]

Tendrá que crear la carpeta template_mejorado dentro de templates/djangocms_zb_filer/ de lo contrario, obtendrá un error de 
plantilla que no existe. Puede hacer esto copiando la carpeta default dentro de ese directorio y renombrándola a
template_mejorado.
masterclass 0.1.0
Definitive Python singleton implementation
Requires Python: >=3.12

# Masterclass

[![PyPI version](https://img.shields.io/pypi/v/masterclass.svg)](https://pypi.org/project/masterclass/)
[![Python versions](https://img.shields.io/pypi/pyversions/masterclass.svg)](https://pypi.org/project/masterclass/)
[![PyPI downloads](https://img.shields.io/pypi/dm/masterclass.svg)](https://pypi.org/project/masterclass/)

One class to rule them all: the definitive singleton implementation for Python. Thread-safe, type-friendly, elegantly simple.
grimoire-log 0.1.0
A simple Python logger, that prints in a JSON format
Requires Python: >=3.6

# Grimoire Logger

Grimoire Logger is a lightweight Python logging library that outputs logs in a
structured JSON format. It is designed to make log parsing and analysis easier,
especially in distributed systems or environments where structured logging is
essential.

## Features

- **JSON-formatted logs**: Logs are output in a machine-readable JSON format.
- **Multiple log levels**: Supports `info`, `warn`, `error`, and `debug` levels.
- **Timestamped logs**: Each log entry includes a timestamp for better
  traceability.
- **Source identification**: Automatically includes the source file in the log
  output.

## Installation

You can install Grimoire Logger by cloning this repository to a local place or
by using `pip`:

```bash
git clone https://github.com/luquor/grimoire.git
cd grimoire
---
pip install grimoire_log
```

## Usage

Here’s a quick example of how to use Grimoire Logger:

```python
from grimoire import Logger

logger = Logger()

logger.info("This is an info message.")
logger.warn("This is a warning message.")
logger.error("This is an error message.")
logger.debug("This is a debug message.")
```

### Example Output

```json
{
  "timestamp": "2023-10-01 12:34:56",
  "level": "info",
  "source": "example.py",
  "message": "This is an info message."
}
```
KMC 1.0.1
KMC - Keyboard Mouse Connect - Forward keyboard and mouse input to another machine via a software communication protocol like ethernet.
Requires Python: >=3.11
Keywords: connect, input, keyboard, kmc, kvm, kvmswitch, mouse, share, sharing

<!--
SPDX-FileCopyrightText: 2025 Anthony Zimmermann

SPDX-License-Identifier: GPL-3.0-only
-->

# KMC - Keyboard Mouse Connect

Forward keyboard and mouse input to another machine via a software communication protocol like ethernet.

Find installation examples below for using KMC. The examples include the installation of KMC itself plus systemd service configurations to enable a seamless integration into the system start. KMC itself does not deal with a secure connection at all. Other applications like ssh tunnels can be used to create encrypted connections.

## Running KMC client

With a client configuration file `kmc.conf`, kmc client could be executed like this:

```bash
kmc -c kmc.conf
```

### Example installation via pipx

Using pipx, we can install kmc globally via the following command:

```bash
sudo PIPX_HOME=/opt/pipx PIPX_BIN_DIR=/usr/local/bin pipx install kmc
```

With kmc installed globally, a systemd service could be installed into '~/.config/systemd/user/kmc.service':

```ini
# Filename: kmc.service
[Unit]
Description=KMC client
After=network.target

[Service]
Environment=DISPLAY=:0
ExecStart=/usr/local/bin/kmc -c ~/.config/kmc.conf
Restart=always

[Install]
WantedBy=default.target
```

The systemd service could be enabled to load automatically on boot:

```bash
systemctl --user enable kmc
```

### Example client configuration

```
# Filename: kmc.conf
[display.tcp.kmc-server-host]
host = kmc-server-host-hostname
port = 12345
keymap = <shift>+<ctrl>+<up>
```

## Running KMC server

With a server configuration file `kmc-server.conf`, kmc server can be executed like this:

```bash
kmc-server -c kmc-server.conf
```

### Example installation via pipx

Using pipx, we can install kmc globally via the following command.

```bash
sudo PIPX_HOME=/opt/pipx PIPX_BIN_DIR=/usr/local/bin pipx install kmc
```

With kmc installed globally, a systemd service could be installed.

```ini
# Filename: kmc-server.service
[Unit]
Description=KMC server
After=network.target

[Service]
Environment=DISPLAY=:0
ExecStart=/usr/local/bin/kmc-server -c /etc/kmc-server.conf
Restart=always

[Install]
WantedBy=multi-user.target
```

The systemd service could be enabled to load automatically on boot:

```bash
systemctl enable kmc-server
```

### Example server configuration

```
# Filename: kmc-server.conf
[display.tcp.kmc-server-host]
host = 0.0.0.0
port = 12345
```

---

**KMC Version 1.0.1<!-- VERSION -->**

---
gedi-canopy-height 1.2.1
generates rasters of canopy height from the Global Ecosystem Dynamics Investigation (GEDI) mission
Requires Python: >=3.10

# `gedi-canopy-height` Python Package

[![CI](https://github.com/JPL-Evapotranspiration-Algorithms/gedi-canopy-height/actions/workflows/ci.yml/badge.svg)](https://github.com/JPL-Evapotranspiration-Algorithms/gedi-canopy-height/actions/workflows/ci.yml)

The `gedi-canopy-height` Python package generates rasters of the [Global Forest Canopy Height 2019](https://glad.umd.edu/dataset/gedi/) dataset derived from Global Ecosystem Dynamics Investigation (GEDI).

[Gregory H. Halverson](https://github.com/gregory-halverson-jpl) (they/them)<br>
[gregory.h.halverson@jpl.nasa.gov](mailto:gregory.h.halverson@jpl.nasa.gov)<br>
NASA Jet Propulsion Laboratory 329G

## Prerequisites

This packages uses the `wget` command line tool and the `gdal` command line tools.

On macOS, these can be installed with Homebrew:

```
brew install wget
```

```
brew install gdal
```

These tools can also be installed with `mamba`:

```
mamba install wget
```

```
mamba install gdal
```

## Installation

This package is available on PyPi as a [pip package](https://pypi.org/project/gedi-canopy-height/) called `gedi-canopy-height` with dashes.

```bash
pip install gedi-canopy-height
```

## Usage

Import this package as `gedi_canopy_height` with under-scores.

```python
from gedi_canopy_height import load_canopy_height
```

## References

P. Potapov, X. Li, A. Hernandez-Serna, A. Tyukavina, M.C. Hansen, A. Kommareddy, A. Pickens, S. Turubanova, H. Tang, C.E. Silva, J. Armston, R. Dubayah, J. B. Blair, M. Hofton (2020) Mapping and monitoring global forest canopy height through integration of GEDI and Landsat data. Remote Sensing of Environment, 112165[^1^][5].