semvec/pypi-packages huggingface dataset:
Gfruit 0.1.1
A package for browser automation and database management
Requires Python: >=3.7

# Gfruit

一个用于浏览器自动化和数据库管理的Python包。

## 简介

Gfruit是一个功能强大的Python库，提供了两个主要模块：

1. `browser_use` - 基于Selenium的浏览器自动化工具
2. `db_manager` - 数据库管理工具

## 安装

### 从PyPI安装（推荐）

```bash
pip install Gfruit
```

### 从源码安装

```bash
git clone https://github.com/yourusername/Gfruit.git
cd Gfruit
pip install .
```

### 从构建的包安装

```bash
pip install dist/gfruit-0.1.0-py3-none-any.whl
```

## 使用方法

### 导入模块

```python
from Gfruit.browser_use import SeleniumBase
from Gfruit.db_manager import DatabaseManager
```

### SeleniumBase 使用示例

```python
# 初始化SeleniumBase
browser = SeleniumBase(ads_id="your_ads_id")

# 初始化WebDriver
driver = browser.init_driver()

# 使用各种浏览器操作方法
browser.button_click("//button[@id='submit']", "点击提交按钮")
```

### DatabaseManager 使用示例

```python
# 初始化DatabaseManager
db = DatabaseManager(host="localhost", user="root", password="password", database="test")

# 使用上下文管理器自动处理连接
with db:
    result = db.fetch_all("SELECT * FROM users")
    print(result)
```

## 开发

### 构建包

```bash
# 安装构建工具
pip install build

# 清理旧的构建文件
rm -rf dist/ build/ *.egg-info src/*.egg-info

# 构建新包
python -m build
```

### 发布新版本

详细说明请参阅 [RELEASE.md](RELEASE.md) 文件。

## 依赖

- keyboard
- requests
- psutil
- selenium
- loguru
- web3
- webdriver-manager
- PyMySQL

## 许可证

MIT
itacart 0.1.0a3
An Equal-Area Parallelogram DGGS for Terrestrial Cadastral Mapping-Designed for Usability and Blockchain Integration.
Requires Python: >=3.8
Keywords: dggs, gis, geospatial, cadastre, blockchain, sdi

# ITACaRT - v0.1.0a3

**PyPI package name reserved. This is a placeholder for the official reference implementation.**

ITACaRT (ITA Cadastral Ellipsoidal Reference Tessellation) is an equal-area parallelogram Discrete Global Grid System (DGGS) designed for terrestrial cadastral mapping, usability, and blockchain integration.

This project was developed at the Technological Institute of Aeronautics (ITA) and is detailed in the scientific paper:

> [Silva, I. N., Shiguemori, E. H., & Dietzsch, G. (2025). *Designing a parallelogram Discrete Global Grid System for terrestrial cadastral mapping.*](http://mtc-m16c.sid.inpe.br/col/sid.inpe.br/mtc-m16c/2025/06.04.13.53/doc/thisInformationItemHomePage.html)

The full conceptual methodology can be found in the article. This package will host the future reference implementation, including algorithms for coordinate transformations, indexing, and topological queries as outlined in the "Future Work" section of the paper.

### Key Features (as per design)
- **Purpose-Oriented:** Designed for cadastral mapping needs.
- **Equal-Area Cells:** Ensures uniform cell sizes based on a sinusoidal projection on the ellipsoid.
- **GNSS Compatibility:** Based on the WGS84 ellipsoid with resolutions down to 1 cm.
- **Compositional Hierarchical Indexing:** A human-readable index designed to represent complex vector features.

**Stay tuned for future development!**
nps-cli 0.1.1
A simple CLI for sampling point clouds from large volumetric datasets
Requires Python: >=3.11

# CLI for Point Cloud Sampling

```
pip install nps-cli
````
### Get started

```zsh
nps --help
Usage: nps [OPTIONS]

Options:
  --cv-path TEXT                  Path to CloudVolume data.  [required]
  --mip INTEGER                   MIP level to use.  [default: 0]
  --timestamp INTEGER             Optional timestamp for the dataset version
                                  (graphene only).
  --sample_svids                  Sample SVIDs in addition to points (default:
                                  False).
  -o, --output-dir DIRECTORY      Output directory.  [default: ./nps_output]
  --worker-type [LocalWorker|LSFWorker|SlurmWorker]
                                  Type of worker to use for sampling.
                                  [default: LocalWorker]
  --num-workers INTEGER           Number of workers for blockwise sampling.
                                  [default: 8]
  --cpus-per-worker INTEGER       Number of CPUs per worker.  [default: 4]
  --queue TEXT                    Queue name (for LSF backend).  [default:
                                  local]
  --fraction FLOAT                Fraction of points to sample [0.0, 1.0].
                                  [default: 0.001]
  --block-size INTEGER...         Block size in voxels (X Y Z).  [default:
                                  128, 128, 128]
  -h, --help                      Show this message and exit.
```

### Example usage

```bash
nps --cv-path precomputed://gs://neuroglancer-janelia-flyem-hemibrain/v1.0/segmentation
```

### Reading Point Clouds

Please refer to the [pocaduck](https://github.com/JaneliaSciComp/pocaduck?tab=readme-ov-file#querying-point-clouds) repo on how to read point clouds from the output directory:

```python
from pocaduck import Query

# Create a query object
query = Query(storage_config=<PATH>) # path to folder where nps output is stored

# Get all available labels
labels = query.get_labels()
print(f"Available labels: {labels}")

# Get all points for a label (aggregated across all blocks)
points = query.get_points(label=12345)
print(f"Retrieved {points.shape[0]} points for label 12345")

# Close the query connection when done
query.close()
```

For optimized point cloud reading, consider [this](https://github.com/JaneliaSciComp/pocaduck?tab=readme-ov-file#running-the-optimization-pipeline).
csfloat.py 0.3.0
A Python wrapper for the csfloat API
Requires Python: >=3.10
Keywords: csfloat, Counter-Strike 2

# csfloat.py
An API wrapper for the CSFloat API written in Python.

Installing
----------

**Python 3.10 or higher is required**

To install the library, you can just run the following command:

```bash
# Linux/macOS
$ python3 -m pip install -U csfloat.py

# Windows
> py -3 -m pip install -U csfloat.py
```

To install the development version, do the following:
```bash
$ git clone https://github.com/PaxxPatriot/csfloat.py.git
$ cd csfloat.py
$ python3 -m pip install -U .
```

Quick Example
--------------

```Python
import asyncio

import csfloat

async def main():
  client = csfloat.Client()
  # Set your personal API key, which you can get from https://csfloat.com/profile -> Developers -> + New Key
  client.set_api_key(api_key="YOUR API KEY HERE")

  # Get all listed CS2 items on csfloat.com and print the name to the console
  listings = await client.fetch_all_listings()
  async for listing in listings:
    print(listing.item.name)

if __name__ == "__main__":
    asyncio.run(main())
```
ansy 1.1.3
A Python package to colorize and format output in the terminal.
Requires Python: >=3.8
Keywords: python, ANSI, ANSI color, color, cli, command-line, terminal, text formatting, color output, ansy, terminal, text styling

# Ansy

[![GitHub Repository](https://img.shields.io/badge/-GitHub-%230D0D0D?logo=github&labelColor=gray)](https://github.com/anas-shakeel/ansy)
[![Latest PyPi version](https://img.shields.io/pypi/v/ansy.svg)](https://pypi.python.org/pypi/ansy)
[![supported Python versions](https://img.shields.io/pypi/pyversions/ansy)](https://pypi.python.org/pypi/ansy)
[![Project licence](https://img.shields.io/pypi/l/ansy?color=blue)](LICENSE)
[![Black](https://img.shields.io/badge/code%20style-black-000000.svg)](black)
[![Automated testing results](https://img.shields.io/github/actions/workflow/status/anas-shakeel/ansy/.github/workflows/test.yml?branch=main)](https://github.com/anas-shakeel/ansy/actions/workflows/test.yml?query=branch%3Amain)
[![PyPI downloads](https://static.pepy.tech/badge/ansy)](https://pypi.org/project/ansy/)

`ansy` (_pronounced ANSI_), inspired by `termcolor`, is a _lightweight python library_ used to style and format output in the terminal.

## ✨ Features

-   Easy text coloring and styling using intuitive functions
-   Support for **4-bit**, **8-bit**, and **24-bit** (truecolor) color modes
-   **Gradients**, **palettes**, and **random color** generation
-   Cross-platform support _(Windows, Linux, macOS)_

### 📦 Installation

Ansy is available on **PyPI** and can be installed with `pip`.

```shell
pip install ansy
```

or Install from source:

```shell
git clone https://github.com/anas-shakeel/ansy.git
cd ansy
pip install .
```

You may also need to install `colorama` (_**Windows** users only_).

### 🚀 Quick Usage

```python
from ansy import colored

print(colored("Hello, World!", fgcolor="cyan", bgcolor="black", attrs=["bold"]))
```

OR 

```python
from ansy import colored_gradient

print(colored_gradient(text, "#00ffff", "#b00b1e"))
```

### 📚 Documentation

Full documentation is available [here](https://anas-shakeel.github.io/ansy/)

### 🤝 Contributing

Contributions are welcome! Check out the [contributing guide](https://anas-shakeel.github.io/ansy/contributing/) to get started.

### 💻 Compatibility

This package has been well-tested across three major platforms (**Windows**, **MacOS**, and **Linux/ubuntu**).

It supports Python versions `3.8` upto `3.13`. it may or may not work on other versions. [See more](https://anas-shakeel.github.io/ansy/compatibility/)

## Preview

![A preview of Ansy in action](https://raw.githubusercontent.com/Anas-Shakeel/ansy/refs/heads/main/docs/images/demo.gif)

Made with ❤️ to make your terminal output more beautiful.
lentezinha 0.1.0
Tiny Lens (AKA 'lentezinha' in pt-BR) for nested dicts in Python
Requires Python: >=3.11

# Lentezinha

Tiny Lens for Python: a single 30 KiB module to improve readability. "Lentezinha" means "little lens" in Brazilian Portuguese.

## Motivation

I don't like to do this: `user.get("profile", {}).get("age"))`, where `user` is a nested dictionary. I'd rather say `user.get("profile.age")`.

## Usage

```python
user = {"name": "Ana", "profile": {"age": 20}}

from lentezinha import read
read(user, "profile.age")  # == 20

from lentezinha import update
update(user, "profile.age", lambda a: a + 1)  # Updates age to 21
```

You can use a `Lens` instance if you plan to access nested attributes many times:

```python
from lentezinha import Lens
age = Lens("profile.age")

print(age.get(user))  # == 20

age.set(user, 27)  # == 27

age.set(user, lambda a: a + 1)  # == 28
```

It also works with Pydantic:

```python
from pydantic import BaseModel

class Profile(BaseModel):
    age: int

class User(BaseModel):
    profile: Profile

user = User(profile=Profile(age=20))

age.get(user)  # == 20
age.set(user, 27)  # == 27
```

## Installation

```shell
pip install lentezinha
```

## TODO

- Compose lenses
pylipextractor 2.2.4
A Python package for robust lip frame extraction from videos using MediaPipe, featuring enhanced stability, configurable options, and customizable GPU-accelerated lossless video format conversion for VSR tasks.
Requires Python: >=3.8
Keywords: lip-extraction, visual-speech-recognition, mediapipe, video-processing, lip-reading, ffmpeg, video-conversion, documentation, examples

# PyLipExtractor

PyLipExtractor is a powerful and easy-to-use Python package for extracting lip regions from videos. It leverages the high-precision MediaPipe Face Mesh to accurately detect and crop the lip area, providing a stable and reliable tool for researchers and developers working on lip-reading, facial analysis, and other related fields.

For detailed information about the package, its features, and how to use them, please refer to the [**Full Documentation**](DOCUMENTATION.md).

## Key Features

- **Accurate & Stable Lip Detection:** Utilizes MediaPipe Face Mesh for precise landmark detection.
- **Temporal Smoothing:** Applies an Exponential Moving Average (EMA) filter for smooth and consistent lip crops.
- **Illumination Normalization:** Includes an optional histogram matching filter to normalize video brightness.
- **Flexible Configuration:** Offers a wide range of customizable settings.
- **Customizable Hardware Acceleration:** Choose your preferred processing device (`auto`, `cuda`, or `cpu`) for video conversion. The package leverages NVIDIA GPU acceleration (if available) for faster processing and uses lossless compression to ensure no quality is lost.

## Demo

https://github.com/user-attachments/assets/a6841309-3e4d-4b7e-bd0f-b56a5cab28e4

*Original video by Tima Miroshnichenko*

## Installation

```bash
pip install pylipextractor
```

## Quick Start

Here is a basic example of how to use PyLipExtractor. For a more detailed and comprehensive example, please see `examples/example_usage.py`.

```python
from pylipextractor.lip_extractor import LipExtractor

# Create a LipExtractor instance
extractor = LipExtractor()

# Specify the path to your video
video_path = "path/to/your/video.mp4"
output_path = "output/lip_frames.npy"

# Extract the lip frames
extracted_frames, rtf_value = extractor.extract_lip_frames(video_path, output_path)

if extracted_frames is not None:
    print(f"Successfully extracted {len(extracted_frames)} frames.")
    if rtf_value is not None:
        print(f"Real-Time Factor (RTF): {rtf_value:.4f}")
```

## Documentation

For a deep dive into all the features, configurations, and technical details, please read our [**Comprehensive Documentation**](DOCUMENTATION.md).

## Contributing

Contributions are welcome! Please see our [Contributing Guidelines](https://github.com/MehradYaghoubi/pylipextractor/blob/main/CONTRIBUTING.md) for more details.

## License

This project is licensed under the MIT License. See the [LICENSE](https://github.com/MehradYaghoubi/pylipextractor/blob/main/LICENSE) file for details.