semvec/pypi-packages huggingface dataset:
safenc 1.0.0
A tool to encrypt file or folder by using file as key.

# Safenc

## Introduction
**Safenc** is a simple command-line tool to encrypt your data. Whether it's a file, folder or just text it can be encrypted using key that can be **Any File** (photo, video, pdf, etc) or password and unless someone has that password or specific file that was used as key to encrypt, they can't  decrypt the original data.
## Installation

Install directly via pip (virtual enviroment reccomended):

```bash
pip install safenc
```
then run it using 
```bash
safenc [options]
```
for manual clone this repo `https://github.com/8oruz/safenc` and add addition package `cryptography` using pip and run `safenc.py`

## Options
- `--input file-path` or `-i file-path` to specify file path to encrypt and if input is text use `-i "@text"`
- `--key key-path` or `-k key-path` to specify path of file to be used as key. It could be any file png, pdf, doc etc, if to use password can use `-k "#password"`
- `--output output-path` or `-o output-path` to give output path that will be used to store encrypted data if  encryption and decrypted data if decrypted **if not given output will print in terminal**.
- `--decrypt` or `-d` To specify the task as decryption **without it there will be only encryption.**
- `--base64` or `-b` if wanted encryption output in base64 format and **in decryption requried if encrypted in base64**.

## Usage Examples

**Encrypting a file using image as key**
```bash
safenc -i input-file -k /path/of/image.png -o encrypted-file
```
**Decrypting same file**
```bash
safenc --decrypt -i encrypted-file -k /path/to/image.png -o original-file
```
**Encrypting a Folder**
```bash
safenc -i /path/to/folder -k key-file.pdf -o encrypted-file
```
**Decrypting same folder**
```bash
safenc -d -i encrypted-file -k key-file.pdf -o /path/to/result
```
**Encrypting a file with password**
```bash
safenc -i input-file -k "#password" -o output-path
```
**Encrypting text with password and print result as base64**
```bash
safenc -i "@any text" -k "#password" --base64
```
**Encrypting a file with password and save as base64**
```bash
safenc -i file-path -k "#password" --base64 -o output
```
**Decryption of same file**
```bash
safenc --decrypt -i encrypted-file -k "#password" --base64 -o original-file
```
elephate 0.1.8
Elephate.ai CLI - Calculatie Copilot voor installatiebedrijven
Requires Python: >=3.10
Keywords: bouw, calculatie, cli, installatie, pdf

# Elephate CLI

Calculatie Copilot voor installatiebedrijven - Command Line Interface

> **Let op:** Dit is een **mockup versie**. De resultaten zijn gesimuleerd en niet gebaseerd op echte LLM analyse.

## Installatie

```bash
pip install elephate
```

## Quick Start

```bash
# Login (kies toegangscode of Auth0)
elephate login

# Of direct met toegangscode
elephate login --code JOUW-CODE

# Of via Auth0 (opent browser)
elephate login --sso

# Start calculatie
elephate calc ./bestek

# Check status
elephate status

# Logout
elephate logout
```

## Authenticatie

Je hebt een account nodig om de CLI te gebruiken. Twee opties:

### Optie 1: Toegangscode
Vraag een toegangscode aan via [calc.elephate.ai](https://calc.elephate.ai) of bij een admin.

```bash
elephate login --code ABC123XYZ
```

### Optie 2: Auth0 (SSO)
Login via je browser met Google of email.

```bash
elephate login --sso
```

## Calculatie Commands

```bash
# Huidige directory scannen
elephate calc

# Specifieke directory
elephate calc ./bestek

# Meerdere directories
elephate calc ./bestek ./tekeningen

# Specifiek bestand
elephate calc bestek.pdf

# Snelle modus (skip animaties)
elephate calc --fast

# Andere output directory
elephate calc --output ./mijn-output

# Alleen resultaten tonen (geen export)
elephate calc --no-export
```

## Interactieve Modus

Start zonder arguments voor een interactieve sessie:

```bash
elephate
```

Beschikbare commands in de sessie:
- `/login` - Inloggen
- `/logout` - Uitloggen
- `/status` - Login status
- `/calc` - Start calculatie
- `/help` - Alle commands
- `/exit` - Afsluiten

## Output

De CLI genereert de volgende output:

```
elephate-output/
├── resultaat.json          # Alle resultaten in JSON formaat
└── csv/
    ├── 50_hwa.csv
    ├── 51_binnenriolering.csv
    ├── 52_waterinstallaties.csv
    ├── 53_sanitair.csv
    ├── 54_brandbestrijding.csv
    ├── 60_verwarmingsinstallatie.csv
    ├── 61_ventilatie.csv
    └── totalen.csv
```

## STABU Categorieën

| Code | Categorie                     |
|------|-------------------------------|
| 50   | HWA (Hemelwaterafvoer)        |
| 51   | Binnenriolering               |
| 52   | Waterinstallaties             |
| 53   | Sanitaire toestellen          |
| 54   | Brandbestrijdingsinstallaties |
| 60   | Verwarmingsinstallatie        |
| 61   | Ventilatieinstallatie         |

## Overige Commands

```bash
elephate version      # Versie info
elephate info         # Systeem info
elephate categories   # STABU categorieën
elephate --help       # Help
```

## Links

- Website: https://elephate.ai
- Webapp: https://calc.elephate.ai
- Documentatie: https://calc.elephate.ai/help
nixwrap 0.11.0
Run Nix packages from Python without Nix installed
Requires Python: >=3.14

# nixwrap

Wrap Nix binaries into Python packages for installation via `uv tool install`.

## Overview

nixwrap provides a way to distribute Nix-built binaries as Python packages. When a user installs a nixwrap package (e.g., `ripgrep`), the PEP 517 build backend:

1. Fetches the narinfo and nar from the Nix binary cache
2. Verifies the hash
3. Extracts the binary
4. Builds a wheel containing the binary as package data

## Usage

```bash
# Install a tool from the nixwrap index
uv tool install --index-url https://elohmeier.github.io/nixwrap/ ripgrep

# Use the tool
rg --version
```

## Repository Structure

```
nixwrap/
  pyproject.toml              # nixwrap-core (shared build backend)
  src/nixwrap_core/
    __init__.py
    backend.py                # PEP 517 build backend
    runtime.py                # Runtime binary executor
  tools/
    manifests/                # Tool manifest files
      ripgrep.json
      fd.json
    build_index.py            # Generates sdists + PEP 503 index
  .github/workflows/
    publish-pages.yml         # CI for publishing to GitHub Pages
```

## Adding a New Tool

1. Create a manifest file in `tools/manifests/<tool>.json`:

```json
{
  "name": "ripgrep",
  "version": "15.1.0",
  "dist": "ripgrep",
  "command": "rg",
  "description": "A line-oriented search tool",
  "store_path": "/nix/store/...-ripgrep-15.1.0",
  "bin_relpath": "bin/rg",
  "cache_url": "https://cache.nixos.org",
  "nar_hash": "sha256:...",
  "ld_linux": "lib/ld-linux-x86-64.so.2",
  "closure": [
    {"store_path": "/nix/store/...-glibc-2.40-66", "nar_hash": "sha256:..."},
    {"store_path": "/nix/store/...-pcre2-10.46", "nar_hash": "sha256:..."}
  ]
}
```

2. Push to main - CI will regenerate the index and publish.

## Development

```bash
# Install dependencies
uv sync

# Build the index locally
uv run python tools/build_index.py --manifests tools/manifests --out gh-pages

# Test a local install
uv tool install --index-url file://$(pwd)/gh-pages/ ripgrep
```

## How It Works

### Build Time (CI)

The `build_index.py` script:
1. Reads each manifest from `tools/manifests/*.json`
2. Creates ephemeral wrapper projects in a temp directory
3. Builds sdists using `python -m build --sdist`
4. Generates PEP 503 simple index HTML pages
5. Publishes to GitHub Pages

### Install Time (User)

When a user runs `uv tool install ripgrep`:
1. uv downloads the sdist from the PEP 503 index
2. The PEP 517 build backend (`nixwrap_core.backend`) is invoked
3. The backend fetches the nar files from the Nix cache (main package + closure)
4. The binary, dynamic linker, and libraries are extracted and embedded in the wheel
5. The wheel is installed with the command available on PATH
6. At runtime, the binary is invoked via the bundled dynamic linker

## License

MIT
django-bootstrap3 26.1
Bootstrap 3 for Django
Requires Python: >=3.10
Keywords: django, bootstrap, bootstrap3

# django-bootstrap3

[![CI](https://github.com/zostera/django-bootstrap3/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/zostera/django-bootstrap3/actions/workflows/ci.yml)
[![Coverage Status](https://coveralls.io/repos/github/zostera/django-bootstrap3/badge.svg?branch=main)](https://coveralls.io/github/zostera/django-bootstrap3?branch=main)
[![Latest PyPI version](https://img.shields.io/pypi/v/django-bootstrap3.svg)](https://pypi.python.org/pypi/django-bootstrap3)

Bootstrap 3 for Django.

## Goal

The goal of this project is to seamlessly blend Django and Bootstrap 3.

## Maintenance Mode

Bootstrap 3 has been superseded by Bootstrap 4, which has since been superseded by Bootstrap 5. As a result, this package is now in **maintenance mode** and will only receive bug fixes and security updates. No new features or enhancements will be added. We recommend that new projects use Bootstrap 5 and encourage existing projects to consider migrating when feasible.

For Bootstrap 4, please refer to our dedicated package: [django-bootstrap4](https://github.com/zostera/django-bootstrap4).

For Bootstrap 5, please refer to our dedicated package: [django-bootstrap5](https://github.com/zostera/django-bootstrap5).

For icons, we recommend our dedicated package: [django-icons](https://github.com/zostera/django-icons).

## Requirements

This package requires a combination of Python and Django that is currently supported.

See "Supported Versions" on https://www.djangoproject.com/download/.

## Documentation

The full documentation is at https://django-bootstrap3.readthedocs.io/

## Installation

1. Install using pip:

    ```shell script
    pip install django-bootstrap3
    ```

   Alternatively, you can install download or clone this repo and call ``pip install -e .``.

2. Add to `INSTALLED_APPS` in your `settings.py`:

   ```python
   INSTALLED_APPS = (
       # ...
       "bootstrap3",
       # ...
   )
   ````

3. In your templates, load the `bootstrap3` library and use the `bootstrap_*` tags:

## Example template

```djangotemplate
{% load bootstrap3 %}

{# Display a form #}

<form action="/url/to/submit/" method="post" class="form">
    {% csrf_token %}
    {% bootstrap_form form %}
    {% buttons %}
        <button type="submit" class="btn btn-primary">Submit</button>
    {% endbuttons %}
</form>
```

Example app
-----------

An example app is provided in `example`. You can run it with `make example`.


Bugs and suggestions
--------------------

If you have found a bug or if you have a request for additional functionality, please use the issue tracker on GitHub.

https://github.com/zostera/django-bootstrap3/issues


License
-------

You can use this under BSD-3-Clause. See [LICENSE](LICENSE) file for details.


Author
------

Developed and maintained by [Zostera](https://zostera.nl).

Original author: [Dylan Verheul](https://github.com/dyve).

Thanks to everybody that has contributed pull requests, ideas, issues, comments and kind words.

Please see [AUTHORS](AUTHORS) for a list of contributors.