semvec/pypi-packages huggingface dataset:
buildmgr 0.1.1
A simple Python-based build system
Requires Python: >=3.9

# buildmgr - A simple Python-based build system

This module lets you define targets, dependencies, and commands in pure Python
to manage your project's build workflow, similar to Make.

## Usage

1. Define your own targets:
   - Use `BuildTarget` for normal build steps:
       • `name`: unique identifier
       • `help_msg`: short description shown in CLI help
       • `log_msg`: message printed when the target runs
       • `commands`: list of shell commands (each is a `Sequence[str|Path]`)
       • `dependencies`: other `BuildTarget` instances this target relies on
       • `inputs` / `outputs`: files to determine staleness
   - Use `CleanupTarget` to remove files or directories:
       • `patterns`: glob patterns to delete
       • `directories`: `Path` objects to remove entirely

2. Customize global behavior:
   - Call `get_logger()` at import to configure ANSI-colored logging.
   - Use `global_config.dry_run = True` to simulate without executing.

3. Wire up your build graph:

   ```python
   setup = BuildTarget(
       name="setup",
       help_msg="Create virtualenv & install dependencies",
       log_msg="Setting up virtual environment",
       commands=[
           ["python3", "-m", "venv", ".venv"],
           [Path(".venv/bin/python"), "-m", "pip", "install", "-r", "requirements.txt"],
       ],
       outputs=[Path(".venv")],
   )

   build_docs = BuildTarget(
       name="docs",
       help_msg="Build Sphinx documentation",
       log_msg="Generating docs",
       commands=[["make", "html", "-C", "docs"]],
       dependencies=[setup],
       inputs=list(Path("docs").rglob("*.rst")),
       outputs=[Path("docs/_build/html/index.html")],
   )
   ```

Instantiate and run the build system:

```python
from build import BuildSystem
import sys

all_target = BuildTarget(
    name="all",
    help_msg="Build everything",
    log_msg="Building all targets",
    commands=[],
    dependencies=[build_docs, /* your other targets here */],
)

system = BuildSystem(
    targets=[setup, build_docs, all_target, /* others */],
    default=all_target
)

if __name__ == "__main__":
    sys.exit(system())  # Parses CLI args, determines outdated targets, and runs them in order

```

## Command-line interface

```sh
$ buildmgr [target]

  target     Name of the target to run (default: 'all')
Options:
  -d, --dry-run    Show commands but do not execute
  -v, --verbose    Enable DEBUG-level logging
  -q, --quiet      Show only WARNING and above
```

## Key features

Incremental builds: only targets whose outputs are missing or older than any inputs will be run.

Automatic dependency topological sort with cycle detection.

ANSI-colored logging with optional verbosity levels.

Easy cleanup via CleanupTarget.
NewsFeed-CNN-Indonesia 0.0.2
6 Popular news from CNN Indonesia
Requires Python: >=3.9

# News-Feed CNN Indonesia
This package will get 6 Popular news from CNN Indonesia

## HOW IT WORK?
This package will scrape from [CNN Indonesia](https://www.cnnindonesia.com/) to get 6 most popular news from it website.
This package will use Requests and BeautifulSoup4, to produce output in the form of JSON that is ready use in web or mobile applications

## HOW TO USE?
''
{
import berita_terbaru_cnn

if __name__ == "__main__":
    print("Berita CNN Indonesia")
    result = berita_terbaru_cnn.ekstraksi_data()
    berita_terbaru_cnn.tampilkan_data(result)
}
'''
flexhub 0.1.0
Handler for batching messages to azure eventhubs
Requires Python: >=3.9

# Introduction 
TODO: Give a short introduction of your project. Let this section explain the objectives or the motivation behind this project. 

# Getting Started
TODO: Guide users through getting your code up and running on their own system. In this section you can talk about:
1.	Installation process
2.	Software dependencies
3.	Latest releases
4.	API references

# Build and Test
TODO: Describe and show how to build your code and run the tests. 

# Contribute
TODO: Explain how other users and developers can contribute to make your code better. 

If you want to learn more about creating good readme files then refer the following [guidelines](https://docs.microsoft.com/en-us/azure/devops/repos/git/create-a-readme?view=azure-devops). You can also seek inspiration from the below readme files:
- [ASP.NET Core](https://github.com/aspnet/Home)
- [Visual Studio Code](https://github.com/Microsoft/vscode)
- [Chakra Core](https://github.com/Microsoft/ChakraCore)
pyMOSF 0.1.1.10
Python package for Multi-OS, Multi-Framework UI apps.
Requires Python: >=3.6

# pyMOSF

[![rpazuki github](https://img.shields.io/badge/GitHub-rpazuki-181717.svg?style=flat&logo=github)](https://github.com/rpazuki)
[![python](https://img.shields.io/badge/Python-3.10-3776AB.svg?style=flat&logo=python&logoColor=white)](https://www.python.org)
[![License: GPLv3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)

### platforms
![iOS](https://img.shields.io/badge/macOS-999999.svg?style=flat&logo=apple)
![Ubuntu](https://img.shields.io/badge/Ubuntu-E95420?style=flat&logo=ubuntu&logoColor=white)
![iOS](https://img.shields.io/badge/iOS-999999.svg?style=flat&logo=apple)

## pyMOSF (python Multi-OF Multi-Framework)
> A lightweight python package for Multi-OS, Multi-Framework UI apps. It support [BeeWare](https://beeware.org/) and [Kivy](https://kivy.org/) frameworks.

## macOS

```
brew install cairo
brew install pyobject3

```
toxy-bot 0.9.0
A trained Discord Bot to detect and handle toxic messages in text channels.
Requires Python: >=3.11

# 1. Project Structure

```bash

Toxy-Bot/
│── data/                    # Store datasets (raw, processed)
│── models/                  # Trained models, checkpoints
│── src/
│   │── bot/                 # Discord bot logic
│   │── ml/                  # Machine learning pipeline
│   │── api/                 # FastAPI deployment
│   │── utils/               # Helper functions
│── notebooks/               # Jupyter notebooks for EDA, model training
│── requirements.txt         # Dependencies
│── config.yaml              # Configuration file
│── main.py                  # Entry point
│── README.md                # Project documentation
│── .env

```


# 2. Development Plan

**Phase 1**: Data Handling & Preprocessing ✅

    Download Kaggle dataset and store in data/
    Clean, preprocess (tokenization, padding, text augmentation)
    Train-test split

**Phase 2**: Model Building & Training

    Load pretrained BERT model
    Fine-tune it on the Kaggle dataset
    Evaluate performance (accuracy, F1-score)
    Save trained model in models/

**Phase 3**: API Deployment

    Use FastAPI to expose the trained model as an API
    Endpoint: /predict → Takes a message and returns toxicity score

**Phase 4**: Discord Bot Integration

    Use discord.py to set up the bot
    Connect bot to the FastAPI backend for toxicity detection
    Implement auto-moderation (warn, mute, ban users)

**Phase 5**: Testing & Deployment

    Deploy FastAPI using Docker + cloud hosting (AWS, GCP, etc.)
    Host the bot on a cloud VM (DigitalOcean, Heroku, etc.)
    Monitor bot performance, handle errors