semvec/pypi-packages huggingface dataset:
exasol-error-reporting 1.1.0
Exasol Python Error Reporting
Requires Python: <4.0,>=3.10
Keywords: exasol, python, error-reporting

# Exasol Error Reporting

This project contains a Python library for describing Exasol error messages.
This library lets you define errors with a uniform set of attributes.
Furthermore, the error message is implemented to be parseable,
so that you can extract an error catalog from the code.

## In a Nutshell

### Install the library

```shell
pip install exasol-error-reporting
```

### Create a Simple Error

```python
from exasol import error

error1 = error.ExaError(
    "E-TEST-1", "A trivial error", "No mitigation available", {}
)
```

### Specify Multiple Mitigations
```python
from exasol import error

error2 = error.ExaError(
    "E-TEST-2",
    message="Fire in the server room",
    mitigations=[
        "Use the fire extinguisher",
        "Flood the room with halon gas (Attention: make sure no humans are in the room!)"
    ],
    parameters={}
)
```

### Error Parameter(s) without description

```python
from exasol import error

error3 = error.ExaError(
    "E-TEST-2",
    "Not enough space on device {{device}}.",
    "Delete something from {{device}}.",
    {"device": "/dev/sda1"},
)
```
### Error with detailed Parameter(s) 

```python
from exasol import error
from exasol.error import Parameter

error4 = error.ExaError(
    "E-TEST-2",
    "Not enough space on device {{device}}.",
    "Delete something from {{device}}.",
    {"device": Parameter("/dev/sda1", "name of the device")},
)
```

Check out the [user guide](doc/user_guide/user_guide.md) for more details.

## Tooling

The `exasol-error-reporting` library comes with a command line tool (`ec`) which also can be invoked
by using its package/module entry point (`python -m exasol.error`).
For detailed information about the usage consider consulting the help `ec --help` or `python -m exasol.error --help`.

### Parsing the error definitions in a python file(s)

```shell
ec parse some-python-file.py 
```

```shell
ec parse < some-python-file.py 
```

## Generating an error-code data file

In order to generate a [error-code-report](https://schemas.exasol.com/error_code_report-1.0.0.json) compliant data file,
you can use the generate subcommand.

```shell
ec generate NAME VERSION PACKAGE_ROOT > error-codes.json
```


## Links and References

For further details check out the [project documentation](https://exasol.github.io/error-reporting-python/).
custom-rnn 0.1.0
A NumPy-based neural network library featuring RNN, GRU cells, CTC loss/decoding, greedy and beam search decoders — built from scratch without PyTorch.
Requires Python: >=3.9

# custom-rnn

A lightweight, NumPy-only neural network library implementing recurrent architectures and CTC (Connectionist Temporal Classification) from scratch.

## Features

- **RNN Cell** — vanilla recurrent neural network cell with forward and backward (BPTT) support
- **GRU Cell** — gated recurrent unit with reset, update, and new gates
- **RNN Phoneme Classifier** — multi-layer RNN for sequence classification
- **Character Predictor** — GRU-based character-level prediction with inference utilities
- **CTC Loss** — full CTC forward-backward algorithm with posterior probability computation
- **CTC Decoding** — greedy search and beam search decoders
- **Neural Network Primitives** — Linear layer, Sigmoid, Tanh, Softmax Cross-Entropy loss

## Installation

```bash
pip install custom-rnn
```

## Quick Start

```python
import numpy as np
from mytorch import RNNCell, GRUCell
from CTC import CTC, CTCLoss, GreedySearchDecoder, BeamSearchDecoder

# Create an RNN cell
rnn = RNNCell(input_size=10, hidden_size=20)
x = np.random.randn(1, 10)
h = np.zeros((1, 20))
h_next = rnn(x, h)

# Create a GRU cell
gru = GRUCell(input_size=10, hidden_size=20)
x = np.random.randn(10)
h = np.zeros(20)
h_next = gru(x, h)

# CTC greedy decoding
symbols = ["a", "b", "c"]
decoder = GreedySearchDecoder(symbols)

# CTC beam search decoding
beam_decoder = BeamSearchDecoder(symbols, beam_width=3)
```

## Requirements

- Python >= 3.8
- NumPy
secret-portal 0.1.0
Spin up a temporary web UI for securely entering secret keys and env vars
Requires Python: >=3.10

# 🔐 secret-portal

spin up a temporary web UI for securely entering secret keys and environment variables.

## why?

entering API keys over messaging apps (telegram, slack, etc.) is sketchy — they get logged, cached, and stored in chat history. this tool spins up a one-time-use web form that saves secrets directly to an env file on your server.

## install

```bash
uv tool install .
```

## usage

```bash
# basic — saves to ~/.env, local only
secret-portal

# expose publicly via cloudflared tunnel (recommended)
secret-portal --tunnel cloudflared

# single key mode with guided instructions
secret-portal -k OPENAI_API_KEY \
  -i '<strong>Get your key:</strong><ol><li>Go to platform.openai.com</li><li>Click API Keys</li><li>Create new key</li></ol>' \
  -l "https://platform.openai.com/api-keys" \
  --link-text "Open OpenAI dashboard →" \
  --tunnel cloudflared

# custom env file and timeout
secret-portal -f ~/.secrets/api-keys --timeout 600
```

the CLI will print a one-time URL with an auth token. open it in your browser, enter your secrets, and hit save. the portal auto-destructs after the first submission.

## tunneling

use `--tunnel` to expose the portal publicly so it's accessible from any device (phone, laptop, etc.).

| provider | flag | cost | notes |
|----------|------|------|-------|
| **cloudflared** (recommended) | `--tunnel cloudflared` | free | no account needed, no interstitial pages, HTTPS, auto-downloads if missing |
| ngrok | `--tunnel ngrok` | free (limited) | requires account + auth, free tier shows an interstitial warning page that blocks mobile/automated use |
| none | (default) | — | binds to `0.0.0.0`, requires the port to be open in your firewall/security group |

**we recommend cloudflared** — it just works. no signup, no config, no interstitial. if the binary isn't installed, secret-portal will download it automatically on first use.

## features

- **one-time use**: portal expires after a single submission
- **token auth**: URL contains a random 32-byte token — no token, no access
- **auto-timeout**: shuts down after 5 minutes (configurable) if unused
- **merge mode**: new secrets are merged into existing env file (won't clobber)
- **file permissions**: env file is set to `600` (owner read/write only)
- **zero dependencies**: pure python stdlib
- **single key mode**: pre-populate a key name so the user just pastes the value (`-k KEY_NAME`)
- **guided instructions**: add step-by-step instructions and a link to the key's console (`-i`, `-l`)
- **reachability check**: warns if the port isn't externally accessible and suggests `--tunnel cloudflared`
- **no value leakage**: secret values are never printed to stdout/stderr (tested)

## security notes

- cloudflared tunnels use HTTPS automatically
- without a tunnel, the portal runs over HTTP — use behind a reverse proxy or SSH tunnel for production
- the one-time token prevents unauthorized access
- secrets never touch your chat history or terminal logs
- secret values never appear in stdout/stderr (enforced by tests)