semvec/pypi-packages huggingface dataset:
bytewax-valkey 0.3.0
Valkey connectors for Bytewax
Requires Python: >=3.12
Keywords: bytewax, valkey

[![PyPI](https://img.shields.io/pypi/v/bytewax-valkey.svg?style=flat-square)][pypi-package]

# Bytewax Valkey

[Valkey][valkey] connectors for [Bytewax][bytewax].

This connector offers 3 sources and 2 sinks:

* `StreamSink` - writes [Valkey streams][valkey-streams] using `xadd`
* `StreamSource` - reads [Valkey streams][valkey-streams] using `xread`
* `PubSubSink` - writes [Valkey pubsub][valkey-pubsub] using `publish`
* `PubSubSource` - reads [Valkey pubsub][valkey-pubsub] using `subscribe`
* `PubSubPatternSource` - reads [Valkey pubsub][valkey-pubsub] using `psubscribe`

## Installation

This package is available via [PyPi][pypi-package] as
`bytewax-valkey` and can be installed via your package manager of choice.

## Usage

### Pub/Sub Source

```python
import os

from bytewax_valkey import PubSubSource
from bytewax.connectors.stdio import StdOutSink

import bytewax.operators as op
from bytewax.dataflow import Dataflow

VALKEY_URL = os.environ["VALKEY_URL"]

flow = Dataflow("valkey_example")
flow_input = op.input("input", flow, PubSubSource.from_url(VALKEY_URL, "example"))
op.output("output", flow_input, StdOutSink())
```

### Pub/Sub Pattern Source

```python
import os

from bytewax_valkey import PubSubPatternSource
from bytewax.connectors.stdio import StdOutSink

import bytewax.operators as op
from bytewax.dataflow import Dataflow

VALKEY_URL = os.environ["VALKEY_URL"]

flow = Dataflow("valkey_example")
flow_input = op.input("input", flow, PubSubPatternSource.from_url(VALKEY_URL, "example*"))
op.output("output", flow_input, StdOutSink())
```

### Pub/Sub Sink

```python
import os

from bytewax_valkey import PubSubSink
from bytewax.testing import TestingSource

import bytewax.operators as op
from bytewax.dataflow import Dataflow

VALKEY_URL = os.environ["VALKEY_URL"]

flow = Dataflow("valkey_example")
flow_input = op.input("input", flow, TestingSource([b"example message"]))
op.output("output", flow_input, PubSubSink.from_url(VALKEY_URL, "example"))
```

### Stream Source

```python
import os

from bytewax_valkey import StreamSource
from bytewax.connectors.stdio import StdOutSink

import bytewax.operators as op
from bytewax.dataflow import Dataflow

VALKEY_URL = os.environ["VALKEY_URL"]

flow = Dataflow("valkey_example")
flow_input = op.input("input", flow, StreamSource.from_url(VALKEY_URL, "example"))
op.output("output", flow_input, StdOutSink())
```

### Stream Sink

```python
import os

from bytewax_valkey import StreamSink
from bytewax.testing import TestingSource

import bytewax.operators as op
from bytewax.dataflow import Dataflow

VALKEY_URL = os.environ["VALKEY_URL"]

flow = Dataflow("valkey_example")
flow_input = op.input("input", flow, TestingSource([{"key": "value"}]))
op.output("output", flow_input, StreamSink.from_url(VALKEY_URL, "example"))
```

## License

Licensed under the [MIT License](./LICENSE).

[valkey]: https://valkey.io
[bytewax]: https://bytewax.io
[valkey-streams]: https://valkey.io/topics/streams-intro/
[valkey-pubsub]: https://valkey.io/topics/pubsub/
[pypi-package]: https://pypi.org/project/bytewax-valkey
tenori 1.1.3
A Flask package for easily adding multi-tenancy with dedicated databases
Requires Python: >=3.10
Keywords: flask, multitenant, database, sqlalchemy, tenant, saas


<center>

![alt text](https://raw.githubusercontent.com/TaqsBlaze/tenori/refs/heads/main/logo/tenori.png)

# Tenori
### Flask Multi Tenant Package
</center>
A lightweight, secure Python package for easily adding multi tenancy to Flask applications using dedicated databases per tenant.

## Features

- 🔐 Secure database creation with SQL injection prevention
- 🎯 Simple integration with existing Flask-SQLAlchemy applications
- ⚡ Automated tenant database management
- 🛠️ Flexible configuration options
- 📝 Type hints for better IDE support

## Installation

```bash
pip install tenori
```

## Quick Start

```python
from flask import Flask
from flask_sqlalchemy import SQLAlchemy
from tenori import MultiTenantManager

app = Flask(__name__)
db = SQLAlchemy(app)

# Initialize the multi-tenant manager
tenant_manager = MultiTenantManager(db)

# Create a new tenant database
@app.route('/signup', methods=['POST'])
def create_tenant():
    try:
        success = tenant_manager.create_tenant(current_user)
        if success:
            return {"status": "success"}
    except Exception as e:
        return {"status": "error", "message": str(e)}
```

## Requirements

- Python 3.10+
- Flask
- Flask-SQLAlchemy
- SQLAlchemy

## Configuration

The package requires a properly configured Flask-SQLAlchemy instance. Your database user must have privileges to create new databases.


## API Reference

### MultiTenantManager

The main class for managing multi tenancy.

```python
manager = MultiTenantManager(db_instance)
```

#### Methods

- `create_tenant(user)`: Creates a new database for the specified user
  - Parameters:
    - `user`: User object (must have an 'id' attribute)
  - Returns:
    - `bool`: True if successful, False otherwise

- `get_tenant_connection(user)`: Gets the connection string for a tenant's database
  - Parameters:
    - `user`: User object (must have an 'id' attribute)
  - Returns:
    - `str`: Database connection string

## Error Handling

The package provides custom exceptions for different scenarios:

- `MultiTenantError`: Base exception class
- `DatabaseCreationError`: Raised when database creation fails
- `InvalidConfigurationError`: Raised when configuration is invalid

## Security Considerations

- Database names are automatically sanitized to prevent SQL injection
- Each tenant gets their own isolated database
- Database credentials are handled securely
- Connection strings are generated dynamically

## Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

1. Fork the repository
2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
4. Push to the branch (`git push origin feature/AmazingFeature`)
5. Open a Pull Request

## License

This project is licensed under the MIT License - see the LICENSE file for details.

## Support

If you encounter any issues or need support, please open an issue on GitHub.
cbe-verification-sdk 1.4.0
SDK for CBE Transaction Verification API
Requires Python: >=3.7

# CBE Verification SDK

A Python SDK for verifying Commercial Bank of Ethiopia (CBE) transactions.

## Installation

```bash
pip install cbe-verification-sdk
```

## Quick Start

```python
from cbe_verification_sdk import CBEVerificationClient

# Initialize client
client = CBEVerificationClient(
    api_key="your-api-key-here",
    api_base_url="http://your-api-url.com"
)

# Verify a transaction
result = client.verify_transaction(
    reference_number="FT253487211",
    account_number="1000012345678"
)

print(result)
```

## Features

- Easy verification of CBE transactions
- Automatic PDF text extraction
- Error handling and logging
- Rate limit handling

## Requirements

- Python 3.7+
- PyPDF2
- requests

## Documentation

For detailed documentation, visit [your-documentation-url].

## License

MIT License - see LICENSE file for details.
metaflow-diff 0.1.7
See and apply diffs between the current working directory and a Metaflow run
Requires Python: >=3.9

# `metaflow-diff` - run `git diff` between a repo and a Metaflow run

![Metaflow diff screenshot](metaflow-diff.png)

1. Create a Metaflow flow, say, `HelloFlow`, in a git repo as usual
2. Run it remotely: `python hello.py run --with kubernetes` or `python hello.py run --with batch`
3. Note the run ID in the console or in the UI, e.g. `HelloFlow/5`.
4. Continue editing code
5. Run `metaflow-diff diff HelloFlow/5` to see how the code has changed in the given execution 💡

> [!NOTE]
> `metaflow-diff` displays differences only for files associated with the specified run.
> Any new files added to the current working directory that are not part of the run will
> be excluded from the output.

## Commands

```
metaflow-diff diff HelloFlow/5
```

Show diff between the current working directory and the given run.

```
metaflow-diff pull --dir code HelloFlow/5
```

Pull the code of the given run to a directory.

```
metaflow-diff patch --file my.patch HelloFlow/5
```

Produce a patch file that, if applied, changes the code in the current
working directory to match that of the run.

```
metaflow-diff diff-runs HelloFlow/5 HelloFlow/6
```

Show diff between the two given runs.
hexdoc-hexical 1.5.0.1.0.0
Python web book docgen and hexdoc plugin for Hexical.
Requires Python: >=3.11
Keywords: hexdoc

# hexdoc-hexical

Python web book docgen and [hexdoc](https://pypi.org/project/hexdoc) plugin for Hexical.

## Version scheme

We use [hatch-gradle-version](https://pypi.org/project/hatch-gradle-version) to generate the version number based on whichever mod version the docgen was built with.

The version is in this format: `mod-version.python-version.mod-pre.python-dev.python-post`

For example:
* Mod version: `0.11.1-7`
* Python package version: `1.0.dev0`
* Full version: `0.11.1.1.0rc7.dev0`

## Setup

Install Python 3.11 and Node 18 (20+ is **not** currently supported).

```sh
python3.11 -m venv venv

.\venv\Scripts\activate   # Windows
. venv/bin/activate.fish  # fish
source venv/bin/activate  # everything else

# run from the repo root, not doc/
pip install -e .[dev]
```

## Usage

For local testing, create a file called `.env` in the repo root following this template:
```sh
GITHUB_REPOSITORY=miyucomics/hexical
GITHUB_SHA=main
GITHUB_PAGES_URL=https://miyucomics.github.io/hexical/
```

Useful commands:
```sh
# show help
hexdoc -h

# render and serve the web book in watch mode
nodemon --config doc/nodemon.json

# render and serve the web book
hexdoc serve

# export, render, and merge the web book
hexdoc export
hexdoc render
hexdoc merge

# start the Python interpreter with some extra local variables
hexdoc repl
```