semvec/pypi-packages huggingface dataset:
cirrondly-cli 0.1.112
Cirrondly agent installer and guard CLI
Requires Python: >=3.8

## Usage Instructions

Users can easily install and use the Cirrondly CLI with these simple steps:
Install the package:

```bash
pip install cirrondly-cli
```

1. Initialize in their application (main.py, app.py, or Django's manage.py):

```python
from cirrondly import Cirrondly
cirrondly(api_key="your-api-key-here")
```

2. For web frameworks, add the appropriate middleware:
For Flask:

```python
from cirrondly import Cirrondly
from cirrondly_cli import cirrondly, flask_middleware

app = Flask(__name__)
cirrondly(api_key="your-api-key-here")
flask_middleware(app)
```

for FastAPI:

```python
from cirrondly import Cirrondly
from cirrondly_cli import cirrondly, CirrondlyFastAPIMiddleware

app = FastAPI()
cirrondly(api_key="your-api-key-here")
app.add_middleware(CirrondlyFastAPIMiddleware)
```
for Django:
Django: Add to your settings.py:

```python
MIDDLEWARE = [
    # ... other middleware
    'cirrondly_cli.CirrondlyDjangoMiddleware',
    # ... other middleware
]
```
voluptuous-serialize 2.7.0
Convert voluptuous schemas to dictionaries
Requires Python: >=3.9

# Voluptuous Serialize

Convert Voluptuous schemas to json serializable objects.

```python
import voluptuous as vol
from voluptuous_serialize import convert

schema = vol.Schema(
    {
        vol.Required("name"): vol.All(str, vol.Length(min=5)),
        vol.Required("age"): vol.All(vol.Coerce(int), vol.Range(min=18)),
        vol.Optional("hobby", default="not specified"): str,
    }
)
result = convert(schema)
```

becomes

_(dictionaries become lists to guarantee order of properties)_

```json
[
  {
    "name": "name",
    "type": "string",
    "lengthMin": 5,
    "required": true,
  },
  {
    "name": "age",
    "type": "integer",
    "valueMin": 18,
    "required": true,
  },
  {
    "name": "hobby",
    "type": "string",
    "default": "not specified",
    "required": false,
    "optional": true,  // This is deprecated. Please use "required" key instead.
  }
]
```

See the tests for more examples.

## Custom serializer

You can pass a custom serializer to be able to process custom validators. If the serializer returns `UNSUPPORTED`, it will return to normal processing.

```python
from typing import Any
from voluptuous_serialize import UNSUPPORTED, UnsupportedType, convert

def custom_convert(value: Any) -> dict[str, str] | UnsupportedType:
    if value is my_custom_validator:
        return {'type': 'custom_validator'}
        
    return UNSUPPORTED

convert(value, custom_serializer=custom_convert)
```
envdetect 0.1.0
A lightweight Python package to detect environment details like OS, CPU, memory, GPU, and Python runtime.
Requires Python: >=3.7
Keywords: environment, system, os, cpu, memory, gpu, python, detection

# EnvDetect

EnvDetect is a lightweight Python library for detecting detailed system environment information, including OS, CPU, memory, GPU, Python runtime, and installed packages.  

It can be used for debugging, reproducibility, environment validation, or as part of ML/AI pipelines where knowing the exact system setup is crucial.

---

## Features

- **OS Information**: Name, version, release, architecture, and more.  
- **CPU Information**: Count, frequency, brand, cores, cache sizes, etc.  
- **Memory Information**: Total, available, used, swap, and percentages.  
- **GPU Information**: Vendor, name, driver version, VRAM, and more (if available).  
- **Python Runtime**: Version, implementation, executable path, installed packages.  
- **Environment Summary**: Aggregates all details into one dictionary for easy export/logging.

---

## Installation

```bash
pip install envdetect
```

## Usage

```python
from envdetect import os_info, cpu_info, memory_info, gpu_info, python_info, environment_summary

print("=== OS Info ===")
print(os_info())

print("=== CPU Info ===")
print(cpu_info())

print("=== Memory Info ===")
print(memory_info())

print("=== GPU Info ===")
print(gpu_info())

print("=== Python Info ===")
print(python_info())

print("=== Full Environment Summary ===")
print(environment_summary())
```

## CLI

```bash
python -m envdetect
```

This will print a full environment summary in JSON format.

### Example Output

```json
{
  "os": {
    "system": "Linux",
    "release": "5.15.0-78-generic",
    "version": "#85-Ubuntu SMP Tue Jun 6 23:34:54 UTC 2023",
    "architecture": ["64bit", "ELF"],
    "machine": "x86_64",
    "processor": "Intel(R) Xeon(R) CPU"
  },
  "cpu": {
    "physical_cores": 4,
    "total_cores": 8,
    "cpu_freq_mhz_max": 4200.0,
    "cpu_freq_mhz_min": 800.0,
    "cpu_freq_mhz_current": 2300.0,
    "l1_cache_kb": 256,
    "l2_cache_kb": 1024,
    "l3_cache_kb": 8192,
    "brand": "Intel(R) Core(TM) i7-8750H CPU @ 2.20GHz"
  },
  "memory": {
    "total": 16,
    "available": 10.5,
    "used": 5.3,
    "percent": 34.5,
    "swap_total": 2,
    "swap_used": 0.1,
    "swap_free": 1.9
  },
  "gpu": [
    {
      "id": "GPU-0",
      "name": "NVIDIA GeForce RTX 3070",
      "driver_version": "535.54",
      "memory_total_MB": 8000,
      "memory_free_MB": 6500,
      "memory_used_MB": 1500
    }
  ],
  "python": {
    "version": "3.10.12",
    "implementation": "CPython",
    "executable": "/usr/bin/python3",
    "packages_count": 240
  }
}
```

## Running Tests

```bash
python -m unittest discover -s tests
```
tigram-nt-bot 0.1.0
A simple pyton telegram libary
Requires Python: >=3.9

# nt-telegram-bot

Oddiy va minimal telegram bot uchun Python + requests asosidagi kutubxona.

```python
from telegram.updater import Updater
from telegram.handlers import MessageHandler
from telegram.types import Update
from config import TOKEN
```

`nt-telegram-bot` sizga hech qanday qo‘shimcha murakkabliksiz, tozalangan interfeys orqali Telegram bot yaratish imkonini beradi.

## ⚙️ O‘rnatish

```bash
pip install tigram_nt_bot
```

## 🚀 Boshlang‘ich foydalanish

Quyidagi kod namunasi orqali botni ishga tushiring:

```python
from telegram.updater import Updater
from telegram.handlers import MessageHandler
from telegram.types import Update
from config import TOKEN


def handle_message(update: Update):
    message = update.message

    if message.text:
        if message.text == '/start':
            message.reply_text(
                TOKEN,
                "assalomu alaykum. ECHO BOT"
            )
        else:
            message.reply_text(TOKEN, message.text)
    elif message.contact:
        pass
    elif message.photo:
        pass
    elif message.sickter:
        pass


updater = Updater(TOKEN)
dispatcher = updater.dispatcher

dispatcher.add_handler(MessageHandler(handle_message))
updater.start_polling()
```

## 📌 Xususiyatlar

* `Updater` yordamida soddalashtirilgan polling
* `MessageHandler` orqali barcha turdagi xabarlarni tutib olish
* `Update` obyektiga qulay kirish

## 📣 Hissa qo‘shish

Pull request’lar mamnuniyat bilan qabul qilinadi.
Agar xatolik topsangiz — Issue qoldiring.

## 📄 Litsenziya

MIT
flomo-cli 0.1.2
Create flomo memo from your terminal
Requires Python: >=3.12

# Flomo-cli: save your memos in terminal

## Usage

```shell
pip install flomo-cli
# first use
flomo-cli --url <your-flomo-api>
# next
flomo-cli
```

## ScreenShot



![Next use](images/next-use.png)