semvec/pypi-packages huggingface dataset:
agespec 1.0.0
Spectroscopy with the Atomic Genesis Explorer
Requires Python: >=3.8
Keywords: spectroscopy, as5, atomic genesis explorer, radial velocity, abundances


AGESpec
==================

Spectroscopy with the AS5 Atomic Genesis Explorer (AGE)

Authors
-------

- **David Nidever** (Montana State University)
  
Installation
------------

To install the latest version::

    pip install git+https://github.com/dnidever/agespec


License
-------

.. image:: http://img.shields.io/badge/license-MIT-blue.svg?style=flat
        :target: https://github.com/dnidever/agespec/blob/main/LICENSE
video-intensity-plot 0.0.7
A Cli Tool to plot video intensity graph over timeline.
Requires Python: >=3.13

# Video Intensity Plot (viplot)
This tools plot the intensity of the pxiels over the timeline of a video.

## How does it work?
1) Takes a video and extact frames from it.
2) Transform each frame to grey scale.
3) sum up all the pixels and divide by the number of pixels.
4) plot the resulting value againt the coresponding frame timestamp.


## Installation and running
### Method 1(using uv)
The easy and recommended way of installing and running.
If you don't have uv already install it from [here](https://docs.astral.sh/uv/getting-started/installation/):
```
uvx video-intensity-plot video.mkv
```
### Method 2(using uv install from source)
If you don't have uv already install it from [here](https://docs.astral.sh/uv/getting-started/installation/):
```
git clone https://github.com/neerajnangireddy/video-intensity-graph
cd video-intensity-graph
uv run viplot video.mkv
```

### Method 3(using venv and pip install from source)
```
git clone https://github.com/neerajnangireddy/video-intensity-graph
cd video-intensity-graph
python3 -m venv .venv
source .venv/bin/activate
pip3 install opencv-python plotly tqdm
python3 viplot.py video.mkv
```

## Demo
[watch here](https://github.com/user-attachments/assets/dd22375f-882f-4326-8ab2-e07f7633990b)
python-django-injector 1.0.1
Django app for exposing methods to rest interface.
Requires Python: >=3.7

# To install this package
    pip install python-django-injector


### 🎯 Define Exposed Endpoints

####  Manager-based Endpoint

```python
# myapp/api.py
from Injection.utils import exposeable, expose
from myapp.models import Item
from myapp.serializers import ItemSerializer

@exposeable
class ItemManager:
    def __init__(self):
        pass

    @expose(
        method='POST',
        url='api/items/filter/',
        response_serializer=ItemSerializer
    )
    def filter_items(self, name: str):
        return Item.objects.filter(name__icontains=name)
```
### Utility Function Endpoint
```python
from Injection.utils import expose

@expose(method='GET', url='api/ping/')
def ping():
    return {'pong': True}
```


### Wire Up URL Patterns

```python 

from django.contrib import admin
from django.urls import path
from Injection.utils import root_instance

urlpatterns = [
    path('admin/', admin.site.urls),
    # Auto-add all @expose endpoints:
] + root_instance.export_urls()

```
k3s63 0.2.0
Toolkit by @k3s63 with date and reset functions
Requires Python: >=3.6

# k3s63

**A custom toolkit by @k3s63** with useful utilities like `date()` and `reset()`.

This is just the beginning â€“ more powerful functions like `info`, `check`, and `verify` will be added in future updates

---

## Installation

```bash
pip install k3s63
pyarccore 0.0.1211149
Paquetage Python pour gérer les configurations, l'internationalisation et les routes dans les applications FastAPI
Requires Python: >=3.7

# README

**pyarccore** est un paquetage Python pour gÃ©rer les configurations, l'internationalisation et les routes dans les applications FastAPI.

## Builder le projet

### Installations prÃ©alables

* **windows** : python -m pip install sdist bdist_wheel
* **linux** : sudo -H pip3 install sdist bdist_wheel

### Builder le projet

* **windows** : python setup.py sdist bdist_wheel
* **linux** : sudo py setup.py sdist bdist_wheel

### Deployer le projet sur pip

* **windows** : python -m twine upload dist/*
* **linux** : sudo twine upload dist/*

## Git

### Cloner le projet

git init && git remote add origin https://[username]@bitbucket.org/[username]/pypyarc.git && git config user.email [email] && git checkout -b [branche] && git pull origin [branche]

### Pousser le projet

git checkout [branche] && git add -A && git fetch && git merge [branche] && git commit -am "[le message commit]" && git push -u origin [branche]

## Tests

* **windows** : cls && python test.py
* **linux** : clear && python test.py

## Docstring

### Installations prÃ©alables

* **windows** : python -m pip install pdoc3
* **linux** : sudo -H pip3 install pdoc3

### Au prÃ©alable

Documenter aux prÃ©alables son code.

### Generer une documentation

* **windows** : python -m pdoc [projet]
* **linux** : sudo pdoc [projet]

### Exemple d'utilisation

```python 
from fastapi import FastAPI
from pyarccore import init_app, t, cfg, register_routes

app = FastAPI()
init_app()

# Use translations
print(t("hello.world"))  # Returns translation for "hello.world"

# Use configurations
print(cfg("database.url"))  # Returns configuration value for "database.url"

# Register routes
router = APIRouter()
register_routes(router, "path/to/routes")
app.include_router(router)
```

### Structure recommandÃ©e pour l'application utilisant ce package

```
arc_project/
â”œâ”€â”€ config.xml
â”œâ”€â”€ locales/
â”‚   â””â”€â”€ fr.json
â”œâ”€â”€ modules/
â”‚   â””â”€â”€ votre_module/
â”‚       â”œâ”€â”€ config.xml
â”‚       â””â”€â”€ locales/
â”‚           â””â”€â”€ fr.json
â””â”€â”€ routes/
    â””â”€â”€ vos_routes/
        â””â”€â”€ *.py
```
zhesp2 2.4.5
Z-HESP2 — Zero’s Hash Encryption Secure Protocol
Requires Python: >=3.7

# Z-HESP2 — Zero’s Hash Encryption Secure Protocol

Z-HESP2 is a terminal-based encryption tool designed for secure and efficient data protection. It features modern cryptographic techniques, including Argon2id key derivation and AES-GCM encryption, with support for metadata and multiple encryption versions.

## Features

- **Strong Encryption:** Uses AES-GCM with Argon2id key derivation for robust security.
- **Metadata Support:** Includes encrypted metadata such as timestamps and versioning.
- **File and Directory Encryption:** Encrypt and decrypt individual files or entire directories recursively.
- **Filename Encryption:** Encrypted files use encrypted filenames with a `.zh` extension for enhanced security.
- **Command Line Interface:** Easy-to-use CLI with commands for encryption, decryption, key generation, and version listing.
- **Help System:** Detailed help available for all commands and specific command summaries.
- **First-Time Integrity Check:** Ensures encryption system integrity on first use.


## Installation

```bash
pip install zhesp2
```

## Usage

Run the CLI tool:

```bash
python -m zhesp2
```

Available commands:

- `encrypt` — Encrypt a plaintext message.
- `decrypt` — Decrypt an encrypted token.
- `genkey` — Generate a new encryption key.
- `listversions` — List supported encryption versions.
- `encryptfile` — Encrypt a file or directory.
- `decryptfile` — Decrypt a file or directory.
- `help` — Show detailed help or help for a specific command.
- `exit` — Exit the program.

Example:

```bash
zhesp2 > encryptfile
Input file path: /path/to/input
Output file path: /path/to/output
Passphrase: 
[+] Encrypted file: /path/to/input/secret.txt -> /path/to/output/ENCRYPTEDFILENAME.zh
```

## Development
[+] Encrypted file: /path/to/input/secret.txt -> /path/to/output/ENCRYPTEDFILENAME.zh

The project is structured as a Python package with the following key modules:

- `crypto.py` — Core cryptographic functions, including filename encryption.
- `cli.py` — Command implementations and utilities, including file and directory encryption with filename encryption.
- `__main__.py` — CLI entry point and command dispatcher.

## License

GNU License Genral Public License v3.0
**note** This software is provided "as is", without warranty of any kind, express or implied, including but not limited to the warranties of merchantability, fitness for a particular purpose and noninfringement. In no event shall the authors or copyright holders be liable for any claim, damages or other liability, whether in an action of contract, tort or otherwise, arising from, out of or in connection with this software or the use or other dealings in this software

## Author

Zero

## Donation Address

Support development with Ethereum or Ethereum-based tokens:

[![Ethereum](https://img.shields.io/badge/ETH-0x2800aBdF...-627eea?style=flat-square&logo=ethereum&logoColor=white)](https://etherscan.io/address/0x2800aBdF356809F4EbE2c9158630CcF975E1Ee67)

Thank you for helping keep ZHESP secure and evolving!
forge-deploy 0.2.0
A CLI tool to automate QA deployments for forge environments
Requires Python: >=3.7

# Forge Deploy

A CLI tool to automate QA deployments for forge environments. 

## Installation
### From PyPI (Recommended)

```bash
pip install forge-deploy
```

### From Source

```bash
git clone https://github.com/mayank-hiver/forge-deploy.git
cd forge-deploy
pip install -e .
```

## Configuration

Create a `forge-deploy.yml` file in `~/.config/`:

```yaml
github:
  token: "your_github_token_here" 

local:
  qa_env_path: "/path/to/your/qa-env"
```

### GitHub Token Setup

1. Go to GitHub Settings → Developer settings → Personal access tokens
2. Create a new token with these permissions:
   - `repo` (Full control of private repositories)
   - `actions:read` (Read access to actions)
3. Copy the token to your config file

## Usage

### Basic Usage

```bash
forge-deploy --branch qa-feature-xyz --env hot-1
```

### Options

- `--branch`, `-b`: QA branch name (required)
- `--env`, `-e`: Environment to deploy to (e.g., hot-1, hot-2, hot-3) (required)  
- `--config`, `-c`: Path to config file (default: config.yml)

### Example Workflow

1. **Push your changes** to a QA branch (e.g., `qa-feature-xyz`)
2. **Run the tool**:
   ```bash
   forge-deploy -b qa-feature-xyz -e hot-1
   ```
3. The tool will:
   - Monitor the "qa build" GitHub Action
   - Extract the generated tag
   - Update the qa-env environment file with the new tag
   - Show you the diff and ask for confirmation (skips if tag already latest)
   - Push changes to main
   - Monitor the "spawn changed/new areas" action
   - Report when deployment is complete