semvec/pypi-packages huggingface dataset:
SkylarklabsVideoProcessor 0.11
A video processing package

# Skylark Video Processor

Skylark Video Processor is a Python package that provides a convenient way to process videos using YOLO-based object detection and classification models.

## Installation

You can install Skylark Video Processor using `pip`:

pip install skylark_video_processor
```bash

from skylark_video_processor import VideoProcessor

# Set paths and configurations
detection_model_path = "yolov8m.pt"
classification_model_path = False
video_path = "rtsp://..."

# Create a VideoProcessor instance
processor = VideoProcessor(
    detection_model_path,
    classification_model_path,
    video_path,
    save_video=True,
    detection_save_crops=False,
    classification_save_crops=False,
    detection_conf=0.75,
    detection_image_size=640,
    detection_classes=0
)

# Process the video
processor.process_video()

```

Features

    Object detection using YOLO model
    Optional object classification
    Save processed video
    Save detected object crops

Dependencies

    opencv-python
    ultralytics
    torch (if using classification)
pmxlock 1.1.0
Cluster-wide Proxmox pmxcfs locks
Requires Python: >=3.9

# pmxlock
Python classes and CLI tools for cluster-wide Proxmox pmxcfs locks.

## Installation
Use `pip` for install:

```bash
pip install pmxlock
```

## CLI usage
Start simple command:

```bash
pmxlock mylockname echo hello
```

or

```bash
python3 -m pmxlock mylockname echo hello
```

Only one command with `mylockname` lock can run in current time in cluster.
Other commands will be blocked until current command completes.

You can exit with failure code instead of blocking.
Use `-n` flag for nonblocking mode.
Failure exit code is `1` by default. Use `-E` flag for other failure code:

```bash
pmxlock -n -E2 mylockname echo hello
```

Command above exits with code `2` if `mylockname` already acquired.

You can use timeout mode also:

```bash
pmxlock -w10 mylockname echo hello
```

Command above waits no more than 10 seconds and exits with code `1` if
`mylockname` cannot be acquired.

If command has options use `--` before command in order stop options parsing by
`pmxlock`:

```bash
pmxlock mylockname -- echo -n hello
```

For `mylockname`-lock `pmxlock` uses node-wide `/run/lock/pmxlock/mylockname`
flock and cluster-wide `/etc/pve/priv/lock/mylockname` pmxcfs-lock. If `pmxlock`
terminated abnormaly (e.g. SIGKILL) `/etc/pve/priv/lock/mylockname` pmxcfs-lock
will remain locked for pmxcfs timeout period (currently 120 seconds hardcoded
in Proxmox). Other process on the same node can acquire orphaned lock
without waiting. You can use `pmxlock-gc` cli command for clean all orphaned
locks on current node.

```bash
pmxlock-gc
```

or

```bash
python3 -m pmxlock.gc
```

## Class usage
Cluster-wide lock implemented by `ClusterLock` class:

```python
from pmxlock import ClusterLock

lock = ClusterLock("mylockname")
```

Short operation in blocking mode:

```python
lock.acquire()
try:
    # Your operation should be short or timeouted.
    # Hardcoded proxmox timeout == 120 seconds.
    # Take overheads into account and use shorter timeout 
    do_work(timeout=0.8 * 120) 
finally:
    lock.release()
```

`ClusterLock` lock implements context manager protocol for blocking mode:

```python
with ClusterLock("mylockname"):
    do_work(timeout=0.8 * 120)
```

For long operations you need to use `lock.update()` regularly.
You can use subprocess for it:

```python
import subprocess

with ClusterLock("mylockname") as lock:
    proc = subprocess.Popen(command)
    while True:
        try:
            proc.wait(0.8 * 120)
            break
        except subprocess.TimeoutExpired:
            lock.update()
```

You can start operation in nonblocking mode:

```python
if lock.acquire(blocking=False):
    try:
        do_work()
    finally:
        lock.release()
else:
    cannot_acquire_lock()
```

And timeout mode:

```python
if lock.acquire(timeout=10):
    try:
        do_work()
    finally:
        lock.release()
else:
    cannot_acquire_lock()
```
StarZai-Memu 0.1.0
StarZai-Memu
Requires Python: <4.0,>=3.8

# StarZai-Memu

## How to start

1. generate project using `nb create` .
2. create your plugin using `nb plugin create` .
3. writing your plugins under `src/plugins` folder.
4. run your bot using `nb run --reload` .

## Documentation

See [Docs](https://nonebot.dev/)
Skylark-Video-Processor 0.6
A video processing package

# Skylark Video Processor

Skylark Video Processor is a Python package that provides a convenient way to process videos using YOLO-based object detection and classification models.

## Installation

You can install Skylark Video Processor using `pip`:

pip install skylark_video_processor
```bash

from skylark_video_processor import VideoProcessor

# Set paths and configurations
detection_model_path = "yolov8m.pt"
classification_model_path = False
video_path = "rtsp://..."

# Create a VideoProcessor instance
processor = VideoProcessor(
    detection_model_path,
    classification_model_path,
    video_path,
    save_video=True,
    detection_save_crops=False,
    classification_save_crops=False,
    detection_conf=0.75,
    detection_image_size=640,
    detection_classes=0
)

# Process the video
processor.process_video()

```

Features

    Object detection using YOLO model
    Optional object classification
    Save processed video
    Save detected object crops

Dependencies

    opencv-python
    ultralytics
    torch (if using classification)
skylark-video-processor 0.5
A video processing package

# Skylark Video Processor

Skylark Video Processor is a Python package that provides a convenient way to process videos using YOLO-based object detection and classification models.

## Installation

You can install Skylark Video Processor using `pip`:

pip install skylark_video_processor
```bash

from skylark_video_processor import VideoProcessor

# Set paths and configurations
detection_model_path = "yolov8m.pt"
classification_model_path = False
video_path = "rtsp://..."

# Create a VideoProcessor instance
processor = VideoProcessor(
    detection_model_path,
    classification_model_path,
    video_path,
    save_video=True,
    detection_save_crops=False,
    classification_save_crops=False,
    detection_conf=0.75,
    detection_image_size=640,
    detection_classes=0
)

# Process the video
processor.process_video()

```

Features

    Object detection using YOLO model
    Optional object classification
    Save processed video
    Save detected object crops

Dependencies

    opencv-python
    ultralytics
    torch (if using classification)
testeCryptoguardian 0.0.1
Uma ferramenta de criptografia e descriptografia de arquivos.

# CryptoGuardian

CryptoGuardian é um pacote Python que fornece uma ferramenta simples e poderosa de criptografia e descriptografia de arquivos. Ele permite que você proteja seus arquivos confidenciais com criptografia forte usando a biblioteca de criptografia Fernet, ao mesmo tempo em que fornece uma interface gráfica construída com PyQt5.

## Características

- **Criptografia de arquivo**: criptografe facilmente seus arquivos para proteger dados confidenciais.
- **Descriptografia de arquivo**: Descriptografe arquivos criptografados anteriormente quando precisar acessar seu conteúdo.
- **Gerenciamento de senhas**: gere automaticamente chaves de criptografia fortes e copie-as para a área de transferência para proteção.
- **Interface Gráfica Intuitiva**: A interface gráfica do usuário torna mais fácil para usuários de todos os níveis de habilidade criptografar e descriptografar arquivos.

### Instalação

Você pode instalar o CryptoGuardian via `pip`:

```bash
pip install cryptoguardian
```

### Uso
import cryptoguardian
# Crie uma instância do CryptoGuardian
guardian = cryptoguardian.CryptoGuardian()
# Criptografar um arquivo
guardian.encrypt_file()
# Descriptografar um arquivo
guardian.decrypt_file()

### Licença
O CryptoGuardian é distribuído sob a [Licença MIT](https://opensource.org/licenses/MIT). Você é livre para usar, modificar e distribuir este pacote de acordo com os termos da **[licença](https://opensource.org/licenses/MIT).**