semvec/pypi-packages huggingface dataset:
hfjobs 0.6.2
Tools for Hugging Face Jobs
Requires Python: >=3.9

# hfjobs

Hugging Face Jobs

## Installation

```
pip install hfjobs
```

## Available commands

```
usage: hfjobs <command> [<args>]

positional arguments:
  {inspect,logs,ps,run,cancel}
                        hfjobs command helpers
    inspect             Display detailed information on one or more Jobs
    logs                Fetch the logs of a Job
    ps                  List Jobs
    run                 Run a Job
    cancel              Cancel a Job

options:
  -h, --help            show this help message and exit
```

## Run jobs

### Usage

```
usage: hfjobs <command> [<args>] run [-h] [-e ENV] [-s SECRET] [--env-file ENV_FILE] [--secret-env-file SECRET_ENV_FILE] [--flavor FLAVOR] [--timeout TIMEOUT] [-d] [--token TOKEN] dockerImage ...

positional arguments:
  dockerImage           The Docker image to use.
  command               The command to run.

options:
  -h, --help            show this help message and exit
  -e ENV, --env ENV     Set environment variables.
  -s SECRET, --secret SECRET
                        Set secret environment variables.
  --env-file ENV_FILE   Read in a file of environment variables.
  --secret-env-file SECRET_ENV_FILE
                        Read in a file of secret environment variables.
  --flavor FLAVOR       Flavor for the hardware, as in HF Spaces.
  --timeout TIMEOUT     Max duration: int/float with s (seconds, default), m (minutes), h (hours) or d (days).
  -d, --detach          Run the Job in the background and print the Job ID.
  --token TOKEN         A User Access Token generated from https://huggingface.co/settings/tokens
```

### Examples

```
$ hfjobs run ubuntu echo hello world
hello world
```

```
$ hfjobs run python:3.12 python -c "print(2+2)"
4
```

```
$ hfjobs run python:3.12 /bin/bash -c "cd /tmp && wget https://gist.githubusercontent.com/sergeyprokudin/e8e1eeb9263766cc43a05ab9190442e4/raw/3c34504fd646517aeb15903700f8e9c1f4d6d2e5/fibonacci.py && python fibonacci.py"
0
1
...
218922995834555169026
```

```
$ hfjobs run hf.co/spaces/lhoestq/duckdb duckdb -c "select 'hello world'"
┌───────────────┐
│ 'hello world' │
│    varchar    │
├───────────────┤
│ hello world   │
└───────────────┘
```

```
$ hfjobs run --flavor t4-small pytorch/pytorch:2.6.0-cuda12.4-cudnn9-devel python -c "import torch; print(torch.tensor([42]).to('cuda'))"
tensor([42], device='cuda:0')
```

## Hardware

Available `--flavor` options:

- CPU: `cpu-basic`, `cpu-upgrade`
- GPU: `t4-small`, `t4-medium`, `l4x1`, `l4x4`, `a10g-small`, `a10g-large`, `a10g-largex2`, `a10g-largex4`,`a100-large`
- TPU: `v5e-1x1`, `v5e-2x2`, `v5e-2x4`

(updated in 03/25 from Hugging Face [suggested_hardware docs](https://huggingface.co/docs/hub/en/spaces-config-reference))
pdfriend 0.9.0
A command line utility for easily modifying PDF files
Requires Python: >=3.11

# Simple command line PDF editor

`pdfriend` is a simple command line program for editing PDF files at the page level. It can, among other things:

- merge many PDFs, PNGs and JPGs into a single PDF
- split a PDF into different parts
- exctract images from PDFs
- select pages from a PDF
- rotate PDF pages
- delete PDF pages
- change the order of pages in a PDF
- encrypt and decrypt PDFs
- see and edit PDF metadata

## Installation
The recommended way to install `pdfriend` is through [pipx](https://github.com/pypa/pipx). Simply run:
```sh
pipx install pdfriend
```
You need a working python 3.11 or newer installation.

Alternatively, you can install it as you would any other PyPI package, for example using pip:
```sh
pip install pdfriend
```

## Usage
To access instructions for the usage of `pdfriend`:
```sh
pdfriend help
```
As a quick overview:
### Merging PDFs and images
PDFs:
```sh
pdfriend merge doc0.pdf doc1.pdf -o output.pdf
```
Images:
```sh
pdfriend merge img0.png img1.jpg img2.png img3.png -o output.pdf
```
PDFs and images:
```sh
pdfriend merge doc0.pdf img0.png doc32.pdf -o comb.pdf
```
Glob patterns are also supported:
```sh
pdfriend merge input_dir/*.png -o output.pdf
```

### Editing PDFs
To edit a PDF file in place, enter the edit shell:
```sh
pdfriend edit doc.pdf
```
You can then use the edit subcommands, for example
```
rotate 12 90
```
To rotate page 12 by 90 degrees, or
```
delete 6
```
To delete page 6, or
```
swap 3 7
```
To swap pages 3 and 7, or
```
undo
```
To undo the previous command, etc. Use
```sh
pdfriend encrypt sus.pdf -o sus-encrypted.pdf
```
to encrypt the PDF with a password. Use
```sh
pdfriend invert wrong.pdf -o right.pdf
```
to invert the order of the pages in a PDF. Use
```
help
```
To see all the available subcommands
pyEncripto 1.0.0
pyEncripto — a tool for encrypting Python projects and securely running them with encrypted modules and assets
Requires Python: >=3.10.0

# 🔐 PyEncripto

**PyEncripto** is a tool for encrypting Python source code and resources (assets) with secure runtime decryption. It is designed to protect intellectual property and create encrypted Python packages.

## 🚀 Features

- 🔒 Encrypt `.py` files into `.crpt` using AES (CFB mode)
- 📦 Package and encrypt resources (from `assets/` folder) into `assets.pak`
- 🧹 Runtime loading of encrypted modules
- 🖼 Runtime loading and decryption of encrypted assets (images, sounds, etc.)
- 🔑 Support for encryption keys
- 🧪 Run encrypted projects with preserved `main.main()` interface

---

## 📦 Installation

```bash
pip install pyencripto
```

---

## 💠 Usage

### 1. Encrypt a project

```bash
pyencripto encrypt <source_folder> <output_folder> --key <key>
```

Example:

```bash
pyencripto encrypt ./my_project ./my_project_crpt --key secret123
```

What happens:

- All `.py` files are encrypted and saved with `.crpt` extension
- The `assets/` folder is encrypted and packed into `assets.pak`

> ⚠️ The `.crpt` extension is mandatory! It is used by the module loader.

---

### 2. Run an encrypted project

```bash
pyencripto run <encrypted_project_folder> <key>
```

Example:

```bash
pyencripto run ./my_project_crpt secret123
```

> The project must contain an encrypted `main.crpt` file with a `main()` function.

---

## 📁 Project structure

Original project:

```
my_project/
├── main.py          # contains main()
├── utils/
│   └── helper.py
└── assets/
    └── image.png
```

After encryption:

```
my_project_crpt/
├── main.crpt
├── utils/
│   └── helper.crpt
└── assets.pak
```

---

## 🔧 Internal modules

- `encryptor.py` — handles project encryption
- `secure_runtime.py` — loads `.crpt` modules and decrypts assets at runtime
- `cli.py` — CLI interface (`pyencripto encrypt|run`)

---

## 🧪 Requirements

- Python 3.10+
- `pycryptodome` (automatically installed)

---

## ⚠️ Security notes

- Encryption makes reverse engineering harder but not impossible. Do not treat this as absolute protection.
- The key is stored only in memory but can be extracted during runtime.

---
saiyam-calculator 1.1.0
A simple calculator package
Requires Python: >=3.6

# Saiyam basic Calucator 

A Simple calclator package of python

## Installation

'''bash
pip install saiyamcal

#python -m venv mypyenv

#Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned
#.\mypyenv\Scripts\activate
mypackage-calutor 0.1.0
A simple calculator package
Requires Python: >=3.6

# Saiyam basic Calucator 

A Simple calclator package of python

## Installation

'''bash
pip install saiyamcal

#python -m venv mypyenv

#Set-ExecutionPolicy -Scope CurrentUser -ExecutionPolicy RemoteSigned
#.\mypyenv\Scripts\activate
tilt-sectioner 0.1.2
Source data sectioner for Tilt Networks
Requires Python: >=3.8

# tilt_sectioner

A fast, cross-platform Python module for **splitting and reconstructing media files** (like `.mp4`) for **Tilt Networks** pipelines.

Built in Rust with [PyO3](https://pyo3.rs/), distributed as a single Python wheel per platform.

---

##  Features

* Split media files (e.g., `.mp4`) into time-based chunks
* Reconstruct files from chunks
* Optional support for text-based segmentation in the future
* **No build-time FFmpeg dependency** – only runtime CLI calls
* Python bindings for easy use

---

##  Installation

```bash
pip install tilt_sectioner
```

*(Wheels are available for Linux, Windows, and macOS — Python 3.8 and above)*

---

##  Quick Example

```python
from tilt_sectioner import split_video, reconstruct_video

# Split into 10-second chunks
split_video("input.mp4", "output_chunks", time_limit_sec=10)

# Reconstruct later
reconstruct_video("output_chunks", "output_merged.mp4")
```

---

##  System Requirements

###  Python Versions Supported:

* Python **3.8+**

###  Operating Systems Supported:

* Linux
* macOS (Intel & Apple Silicon)
* Windows (x64)

---

###  FFmpeg Runtime Requirement:

This package **requires FFmpeg to be installed at runtime**.

* **You MUST have the `ffmpeg` binary available in your system PATH**.
* The Rust backend will call ffmpeg as an external process.

---

####  How to Install FFmpeg:

| OS            | Command                                                                                                                              |
| ------------- | ------------------------------------------------------------------------------------------------------------------------------------ |
| macOS         | `brew install ffmpeg`                                                                                                                |
| Ubuntu/Debian | `sudo apt-get install ffmpeg`                                                                                                        |
| Windows       | Download from [https://ffmpeg.org/download.html](https://ffmpeg.org/download.html) or install via Chocolatey: `choco install ffmpeg` |

---

###  How to Test FFmpeg Availability:

```bash
ffmpeg -version
```

---

##  Metadata and JSON Outputs

Each split operation generates a JSON metadata file describing the chunk files.

This is used by `reconstruct_video()` for accurate reassembly.

---

##  Development Notes

* Built with Rust using PyO3 and Maturin
* Wheels built via GitHub Actions
* **No compile-time linking to FFmpeg libraries** – runtime only via subprocess calls.

---

##  License

MIT License © Tilt Networks