semvec/pypi-packages huggingface dataset:
banglish-stopwords 0.1.0
A high-performance library to filter Banglish stopwords from text.
Requires Python: >=3.6

# Banglish Stopwords

A high-performance, lightweight Python library to filter Banglish (Bengali written in Latin/English script) stopwords. It helps in cleaning text data for NLP, sentiment analysis, and machine learning projects.

## Features
- **Comprehensive Dataset:** Includes 350+ Bengali words and their popular Banglish variations.
- **Lazy Typing Support:** Handles repeated characters automatically (e.g., `naaaa` -> `na`, `hbeee` -> `hbe`).
- **High Performance:** Uses optimized sets for O(1) lookup speed.
- **Punctuation Aware:** Cleans text while respecting common punctuation.

## Installation

You can install the library using pip (after you publish it):
```bash
pip install banglish-stopwords
matpak 2.1.0
Matrix Utilization Python Package
Requires Python: >=3.12

# MatPak
Matrix Utilization Python Package.

![MatPak](https://github.com/user-attachments/assets/3fb0d588-3070-4aec-a418-73d369474562)


## Files structure
`src/`: source codes of library lives in here.

`src/matpak/`: **MatPak** package files stored in this directory.

`tests/`: **MatPak** package unit tests are located here.

## Usage
First of all, **MatPak** should be installed via your python package manager (e.g, pip):
```bash
pip install matpak
```

Then by importing `matpak` package in your application files, you can use **MatPak**'s public API functions:

```python
import matpak

def main():
    # import custom matrix from file
    foo_mat = matpak.imp_mat_file("./foo_mat.txt")
    
if __name__ == "__main__":
    main()
```

## Test
To execute unit tests, from root dir:
```bash
python -m unittest discover -s tests -p "*_test.py"
```

on successful test:
```bash
..................
----------------------------------------------------------------------
Ran 18 tests in 0.048s

OK
```

## Examples
`tests/` directory contains tests that are also best examples to inspire from.
all public APIs tested and all names (function names, variable name, etc...) are clear
to find out what is going on.

## Contribution
Feel free to fork, modify and open a pull request in this repository.
Thanks for your contribution.
buildcpp 0.2.5
A build system for C++.
Requires Python: >=3.7

# Buildcpp: A Python Build System for C++ Projects  

![MIT-LICENSE](https://img.shields.io/github/license/Anglebase/buildcpp)  
![PyPI](https://img.shields.io/pypi/v/buildcpp)

Buildcpp is a build tool that uses Python as the scripting language for C++ projects. Its minimalist design makes building C++ projects straightforward and efficient.

## Installation  

Buildcpp requires **Python 3.7 or higher**. You can download Python from [python.org](https://www.python.org/downloads/).  
Once Python is installed, install Buildcpp via pip:

```shell
pip install buildcpp
```

Buildcpp also depends on **CMake 3.15 or later**, which you can download from [cmake.org](https://cmake.org/download/).  
Under the hood, Buildcpp uses Python for front-end scripting and CMake as the back-end build engine.

## Usage  

Buildcpp is a Python package that provides a set of APIs for defining and building C++ projects.  
To use it, simply create a Python script in your project directory and define your build using Buildcpp’s API. Running this script will execute the build.

While Buildcpp uses a script-based approach, the script itself resembles a configuration file. This design choice stems from the fact that C++ builds often involve numerous configuration options, which can become cumbersome in static configuration files.

Here’s a minimal example:

```python title="myproject.py"
from buildcpp import Target, Builder, Scope
from pathlib import Path

# Get current directory
ROOT = Path(__file__).parent

# Define a build target
target = Target('main')\
    .add_sources(Scope.PRIVATE, ROOT / 'main.cpp')

if __name__ == '__main__':
    # Create a builder and compile the target
    builder = Builder()
    builder.attach(target)
    builder.build()
```

Even without prior Python experience, you can likely understand what’s happening if you’re familiar with C++.  
The `Target` object is central to Buildcpp—it holds all the metadata needed for the build, much like a configuration file.

If you want to learn more, check out the [documentation](https://anglebase.github.io/buildcpp/site/quick/).

## LICENSE

This project is licensed under the MIT license.
xcdn 0.1.5
A complete Python library to parse, serialize and deserialize xCDN — eXtensible Cognitive Data Notation
Requires Python: >=3.8
Keywords: xcdn, parser, serializer, data-notation, configuration, json-alternative

# > xCDN_ (Python)

A complete Python library to parse, serialize and deserialize **> xCDN_ — eXtensible Cognitive Data Notation**. 

> **What is > xCDN_?**  
> xCDN_ is a human-first, machine-optimized data notation with native types, tags and annotations.
> It supports comments, trailing commas, unquoted keys and multi‑line strings.
> You can read more about this notation in the [> xCDN_ repository](https://github.com/gslf/xCDN).

## Features

- Full streaming document model (one or more top-level values)
- Optional **prolog** (`$schema: "..."`, …)
- Objects, arrays and scalars
- Native types: `Decimal` (`d"..."`), `UUID` (`u"..."`), `DateTime` (`t"..."` RFC3339),
  `Duration` (`r"..."` ISO8601), `Bytes` (`b"..."` Base64)
- `#tags` and `@annotations(args?)` that decorate any value
- Comments: `//` and `/* ... */`
- Trailing commas and unquoted keys
- Pretty or compact serialization

## Example

```xcdn
$schema: "https://gslf.github.io/xCDN/schemas/v1/meta.xcdn",

server_config: {
  host: "localhost",
  // Unquoted keys & trailing commas? Yes.
  ports: [8080, 9090,],

  // Native Decimals & ISO8601 Duration
  timeout: r"PT30S",
  max_cost: d"19.99",

  // Semantic Tagging
  admin: #user {
    id: u"550e8400-e29b-41d4-a716-446655440000",
    role: "superuser"
  },

  // Binary data handling
  icon: @mime("image/png") b"iVBORw0KGgoAAAANSUhEUgAAAAUA...",
}
```

## Usage

```python
from xcdn import parse_str, ser

doc = parse_str(open("sample.xcdn").read())
text = ser.to_string_pretty(doc)
print(text)
```

## Installation

```bash
pip install .
```

Or for development:

```bash
pip install -e .
```

## Testing

```bash
pytest
```

## License

MIT, see [LICENSE](LICENSE).

---

#### This is a :/# GSLF project.
ultradl-pro 0.1.2
UltraDL Pro - cross-platform CLI downloader powered by yt-dlp
Requires Python: >=3.9
Keywords: download, downloader, yt-dlp, youtube, cli

# UltraDL Pro 🚀

UltraDL Pro includes:

- **Linux TUI** (`ultradl`): the original Gum-based interactive UI
- **Cross-platform CLI** (`ultradl-pro`): works on Linux/macOS/Windows via Python

## Features

- 🎥 **Multi-Platform**: Support for YouTube, TikTok, Twitter, Twitch, and more.
- 🎵 **Spotify Support**: Download tracks, albums, and playlists directly.
- 🔍 **Built-in Search**: Search YouTube directly from your terminal.
- 📂 **Auto-Organizer**: Automatically sorts downloads into Video, Music, Images, etc.
- 🍪 **Cookie Integration**: Bypass bot detection by using your browser's cookies.
- ⚡ **Fast**: Uses `aria2c` for multi-threaded acceleration.
- 🎨 **Beautiful UI**: Interactive menus powered by `gum`.

## Installation

### Cross-platform (recommended)

Single-line install from PyPI:

```bash
python -m pip install -U ultradl-pro
```

Then run:

```bash
ultradl-pro
ultradl-pro "https://www.youtube.com/watch?v=D4A4APuwVgg&t=298s"
```

Notes:

- For best isolation (especially on Linux), prefer `pipx install ultradl-pro`.
- Some features (audio conversion) require `ffmpeg` installed on your system.

Install the Python CLI (`ultradl-pro`) using `pipx` (Linux/macOS/Windows):

```bash
python -m pip install --user -U pipx
python -m pipx ensurepath
pipx install .
```

Run:

```bash
ultradl-pro --help
ultradl-pro download "https://www.youtube.com/watch?v=..."
```

Windows PowerShell convenience installer:

```powershell
./install.ps1
```

### Linux TUI (legacy)

1. **Install Dependencies**:

   ```bash
   # Arch Linux
   sudo pacman -S gum aria2 yt-dlp ffmpeg nodejs
   pip install spotdl

   # Ubuntu/Debian
   sudo apt install gum aria2 yt-dlp ffmpeg nodejs
   pip install spotdl
   ```

2. **Setup**:
   ```bash
   chmod +x ultradl
   sudo ln -s $(pwd)/ultradl /usr/local/bin/ultradl
   ```

## Usage

Linux TUI:

- Run `ultradl` and follow the interactive prompts.

Cross-platform CLI:

- `ultradl-pro download <url>`
- `ultradl-pro config --download-dir <path>`
- `ultradl-pro config --cookies-browser firefox`
blocket-api 0.4.32
A python API wrapper for blocket.se
Requires Python: >=3.10

<p align="center">
  <img src="https://blocket-api.se/blocket-api.png" />
</p>

# BlocketAPI

[![PyPI version](https://img.shields.io/pypi/v/blocket_api?style=for-the-badge)](https://pypi.org/project/blocket_api/) [![License](https://img.shields.io/badge/license-WTFPL-green?style=for-the-badge)](https://github.com/dunderrrrrr/blocket_api/blob/main/LICENSE) ![Python](https://img.shields.io/badge/Python-3.10-blue?style=for-the-badge) ![PyPI - Downloads](https://img.shields.io/pypi/dw/blocket_api?style=for-the-badge&color=%23dbce58) 

BlocketAPI allows users to search [blocket.se](https://blocket.se/) for ads.

> Blocket is one of Sweden's largest online marketplaces. It was founded in 1996 and allows users to buy and sell a wide range of items, including cars, real estate, jobs, services, and second-hand goods. The platform is known for its extensive reach and user-friendly interface, making it a popular choice for Swedes looking to purchase or sell items quickly and efficiently.

## 🧑‍💻️ Install

Install BlocketAPI via PyPI...

```sh
pip install blocket-api
```

or use [blocket-api.se](https://blocket-api.se) without installing anything!

## 💁‍♀️ Usage

```py
from blocket_api import (
    BlocketAPI,
    Category,
    CarColor,
    CarModel,
    CarSortOrder,
    CarTransmission,
    Location,
)

api = BlocketAPI()

# search all of blocket
api.search(
    "Tamagotchi",
    sort_order=SortOrder.PRICE_ASC,
    locations=[Location.STOCKHOLM, Location.UPPSALA],
    category=Category.FRITID_HOBBY_OCH_UNDERHALLNING,
)

# search for cars
api.search_car(
    "Audi", # query is optional
    sort_order=CarSortOrder.MILEAGE_ASC,
    models=[CarModel.AUDI],
    colors=[CarColor.GULD],
    price_from=10000,
    price_to=50000,
    transmissions=[CarTransmission.MANUAL],
    locations=[Location.STOCKHOLM],
    org_id=1337, # dealer or store id
)

# search for boats
from blocket_api import BoatType

api.search_boat(
    "Mercury", # query is optional
    types=[BoatType.DAYCRUISER],
    locations=[Location.STOCKHOLM],
    length_from=10,
    length_to=15,    
    price_from=20000,
    price_to=90000,
    org_id=1337, # dealer or store id
)

# search for motorcycles
from blocket_api import McType, McModel

api.search_mc(
    "TC 150", # query is optional
    types=[McType.SPORT],
    locations=[Location.STOCKHOLM],
    models=[McModel.DUCATI],
    price_from=20000,
    price_to=90000,
    engine_volume_from=100,
    engine_volume_to=200,
    org_id=1337, # dealer or store id
)


# get ad details
from blocket_api import CarAd, RecommerceAd, BoatAd, McAd

api.get_ad(RecommerceAd(12345678))
api.get_ad(CarAd(12345678))
api.get_ad(BoatAd(12345678))
api.get_ad(McAd(12345678))
```

## 📝 Notes

- REST API: https://blocket-api.se
- Source repo: https://github.com/dunderrrrrr/blocket_api
- PyPI: https://pypi.org/project/blocket-api/
cloe-util-git-client 2.0.3
This package contains a git client which can be used to retrieve files from git history and interact with it.
Requires Python: <3.14,>=3.11

# CLOE Util Git Client

[![Copier](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/copier-org/copier/master/img/badge/badge-grayscale-inverted-border-orange.json)](https://github.com/copier-org/copier)
[![python](https://img.shields.io/badge/Python-3.11-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/charliermarsh/ruff/main/assets/badge/v0.json)](https://github.com/charliermarsh/ruff)
[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)

Owner: initions

This package contains a git client which can be used to retrieve files from git history and interact with it.
k8s-helpers 1.0.14
Collection of Kubernetes command-line utilities
Requires Python: >=3.13

# k8s-utils

A collection of Kubernetes command-line utilities built with Python and Typer.

## Installation

This project uses [uv](https://github.com/astral-sh/uv) for package management. Make sure you have uv and uvx installed.

Just testing it out:
```shell
# Install dependencies
uvx k8s-helpers --help

```

Installation
```shell
uv tool install k8s-helpers
```
This installs the `k8s-helpers` command and the shorthand `k8sh`

## Commands

### podcount

Count non-daemonset pods per node in the current Kubernetes context.

```shell
# Use current context
k8sh podcount --help

# Specify a different context
k8sh podcount --context my-context

# Show nodegroup and zone labels, and sort by nodegroup
k8sh podcount \
--node-labels "eks.amazonaws.com/nodegroup" \
--node-labels "topology.kubernetes.io/zone" \
--sort "eks.amazonaws.com/nodegroup" \
--show-taints
```

This command:
- Retrieves all pods and nodes in the cluster
- Excludes pods managed by DaemonSets
- Displays a table showing pod count per node
- Shows total non-DaemonSet pod count

### delpods

Delete pods matching certain statuses across namespaces.

```shell
# Delete pods with specific statuses across all namespaces
k8sh delpods --all-namespaces --status ImagePullBackOff --status CrashLoopBackOff

# Preview what would be deleted (dry run)
k8sh delpods -A --status CrashLoopBackOff --dry-run

# Delete in specific namespace without confirmation
k8sh delpods -n default --status Error --yes

# Use specific context
k8sh delpods -c my-cluster -A --status ImagePullBackOff
```

Available arguments:
- `--all-namespaces`, `-A`: Search pods in all namespaces
- `--namespace`, `-n`: Specify a namespace (default: current context namespace)
- `--status`: Pod status to match (can be specified multiple times)
- `--dry-run`: Show what would be deleted without deleting
- `--yes`, `-y`: Skip confirmation prompt
- `--context`, `-c`: Kubernetes context to use

### resources

Analyze CPU and memory consumption per node (excluding DaemonSet pods).

```shell
# Show all nodes
k8sh resources

# Analyze single node (faster for large clusters)
k8sh resources --node my-node-name

# Include pod breakdown
k8sh resources -p

# Sort by memory requests
k8sh resources --sort mem-req
```

Shows requests, limits, allocatable capacity, and actual usage (if metrics-server is available).

### node

Analyze resource waste for pods on a specific node.

```shell
# Analyze waste on a node
k8sh node my-node-name

# Sort by CPU waste
k8sh node my-node-name --sort cpu-waste
```

Shows actual usage vs requests, with color-coded waste percentages (green=efficient, red=wasteful).
free-ai-for-all 1.7.5
Free AI for everyone, providing text and image generation capabilities. No API keys required.

# Free-AI-For-All
**free-ai-for-all** is, a python library powered by **[pollinations.ai](https://pollinations.ai/)**
tis python library is super powerfull, if you know about **AI** and know what you are doing this can be alot, fun and powerfull, and also use this wisely.

### get started!

**type this in your terminal to, get started with coding with this library**
```bash
pip install free-ai-for-all
``` 
or if you want to, upgrade **type this**

```bash
pip install --upgrade free-ai-for-all
```

and then yyou just add this, at top of your python code

```python
import free_ai_for_all as fafa #this imports, the library as fafa short for, free ai for all
```

***
for more information check out Free-AI-For-All team's github repo

**[github page](https://seigh-sword.github.io/Free-AI-For-All-github_page/)**

***

# versions

### 1.7.0

**added**
- **Readme.md** for, projects's info
**updated**
- setup.py
- pyproject.py
            [other config files]
***

## about pollination.ai
**Pollination.ai** is super cool I will recommend checking it out, and also, thanks for the free **AI tools** 
- Its an free AI tool
- used in projects like this, python library and others

check it out **[here!](https://pollinations.ai/)** 

***

**Made with Time and Effort by [@Seigh-sword](https://github.com/Seigh-sword/)**

***