semvec/pypi-packages huggingface dataset:
junkpurge 0.1.0
A tool to clean up build directories in various programming languages.
Requires Python: >=3.6

# JunkPurge

A simple Python script to recursively delete common build and install directories for various programming languages, helping you clean up unnecessary files and free up space.

## Supported Languages

- JavaScript (js)
- Rust (rust)
- Python (python)
- C++ (cpp)
- Java (java)
- C# (csharp)
- Go (go)
- Ruby (ruby)
- PHP (php)
- Dart (dart)
- Flutter (flutter)

## Installation

You can install JunkPurge directly from PyPI:

```bash
pip install junkpurge
```

Once installed, you can use it as a command-line tool:

```bash
junkpurge <directory> <language>
```

For example, to clean the build directories for a JavaScript project:

```bash
junkpurge my_project js
```

This will remove directories like node_modules, dist, and build from the specified my_project directory.

## License

This project is licensed under the MIT License - see the LICENSE file for details.
fzstats 0.1.2
Display statistics for file and folder sizes
Requires Python: >=3.8,<4.0

# fzstats - File and Folder Size Statistics

fzstats is a Python command line tool that allows you to display statistics for file and folder sizes. Gain insights into the distribution of sizes within a directory, and easily sort and analyze the data.

## Installation

Install fzstats using pip:

```bash
pip install fzstats
```

## Usage

Show help message:

```bash
fzstats --help
```

Display size statistics for a folder, by default the results is sorted by size in descending order:

```bash
fzstats /path/to/your/folder
```

Sort the results by size in ascending order:

```bash
fzstats -s  /path/to/your/folder
```

Sort the results by name in descending order:

```bash
fzstats -s name /path/to/your/folder
```

Limit the results to 10 rows:

```bash
fzstats -l 10 /path/to/your/folder
```

## Options

* `--help`: Display help message.
* `-s`, `--sort`: Sort the results by a specific attribute. [default: size]
* `-d`, `--dir`: Sort direction. [default: desc]
* `-l`, `--limit`: Limit the results to a given number of rows. [default: no limit]
webmin-xmlrpc 0.0.2
Provides a python interface to interact with the Webmin XML-RPC API.
Keywords: webmin,xmlrpc

# Webmin XML-RPC python package

This package provides a python interface to interact with the Webmin XML-RPC API.

## Usage

```python
from aiohttp.client import ClientSession
from webmin_xmlrpc.client import WebminInstance
from yarl import URL

base_url = URL.build(host="example.com", scheme="https")
session = Clientsession(base_url)
instance = WebminInstance(session)

async def get_data():
    data = await instance.update()
```

## Exposed data

- Load (1m, 5m, 15m)
- Network interfaces
- Memory information
- Uptime
- Local disk space information
VeilMail 1.0.8
A simple command-line email client using the 1secmail API.
Requires Python: >=3.6

# VeilMail: Your Go-To CLI Temporary Email Client

🚀 VeilMail is a sleek, command-line email client tailored for handling temporary emails with ease, utilizing the 1secmail API.

![Build Status](https://img.shields.io/badge/build-passing-brightgreen.svg)
![Version](https://img.shields.io/badge/version-1.0.0-blue.svg)
![License](https://img.shields.io/badge/license-MIT-green.svg)

## Welcome to VeilMail 🌟

The ultimate command-line solution for managing temporary emails with speed and simplicity. VeilMail harnesses the power of the 1secmail API, delivering an intuitive and efficient email experience right in your terminal.

## Key Features

- 📩 Instant Temporary Email Generation
- 📥 Easy Inbox Management
- 🖥️ Pure CLI Interface
- 📑 Support for Custom Usernames
- ✂️ Clipboard Integration for Quick Access
- 📖 HTML to Text Email Conversion
- 🌐 Fetch and View Email Contents
- 🎨 Rich Text Formatting with 'rich' Library

## Installation

You can install VeilMail either by cloning the repository or using pip:

### Option 1: Cloning the Repository

1. Clone the repository: `git clone https://github.com/zadeson/veilmail.git`
2. Navigate to the project directory: `cd veilmail`
3. Install dependencies: `pip install -r requirements.txt`
4. Cd into the directory: `cd veilmail`
5. Run the application: `python main.py`

### Option 2: Installing via Pip

1. Run `pip install git+https://github.com/zadeson/veilmail.git`
2. Start VeilMail with `veilmail` command in your terminal

## Usage

Run `python veilmail.py` (or just `veilmail` if installed via pip) and follow the interactive prompts.

## How it Works

VeilMail operates through a series of straightforward CLI commands, providing a user-friendly interface to interact with your temporary email inbox. From fetching active domains, creating random or custom email addresses, to reading emails in a neatly formatted console - VeilMail does it all with ease.

## Contributing

Contributions are what make the open-source community such an amazing place to learn, inspire, and create. Any contributions you make are **greatly appreciated**.

1. Fork the Project
2. Create your Feature Branch (`git checkout -b feature/AmazingFeature`)
3. Commit your Changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the Branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License

Distributed under the MIT License. See `LICENSE` for more information.

## Contact
Ethen Dixon - ethendixon@outlook.com

Project Link: [https://github.com/Zadeson/veilmail](https://github.com/Zadeson/veilmail)
dajngo-models-typescript-types 0.2
A package to create your Typescript Types/Models from your Django Models.

THIS MODULE BEINH IN DEVELOPMENT, IT IS NOT READY FOR USE YET.
THE DOCUMENTATION MAY NOT BE ACCURATE.


# Django Model to TypeScript Converter

This repository contains a utility for converting Django models into TypeScript interfaces, facilitating the development of TypeScript applications that interact with Django backends.


## Key Components

### `modeltotypescriptconverter.py`

This file contains the `ModelToTypeScriptConverter` class responsible for the conversion process. It includes methods for processing Django model fields, generating TypeScript interface files, and managing command-line arguments for customization.

### `apps.py`

Defines the `DjangoModelToTypescriptTypesConfig` class, which configures the application and initiates the conversion process during Django's startup if certain conditions are met (based on environment variables).

### Command `django2ts.py`

Located under `management/commands`, this Django management command allows for manual invocation of the conversion process from the command line or within scripts.

## Usage

To use this utility in your project, you can run the Django management command `django2ts` to generate TypeScript interfaces. Additionally, you can customize the behavior through environment variables such as `TS_APP_TO_INCLUDE`, `TS_PATH`, `TS_SEPERATED_FILES`, and `DJANGO2TS_VERBOSE`. You can also directly use it as CLI command next to your `manage.py` file by using `django2ts` command, with the folowing options:

```
usage: manage.py django2ts [--app APP] [--path PATH] [--separated-files] [--verbose]
```

And if you want you can also directly use the `ModelToTypeScriptConverter` class in your own code to generate TypeScript interfaces programmatically.

## Installation

`pip install dajngo-models-typescript-types`