semvec/pypi-packages huggingface dataset:
worker-bunch 1.0.5
Task/job/rule engine, primarily intended for use in a smarthome environment.
Keywords: smarthome,mqtt,rule-engine,task-engine


# Worker-Bunch

... is a tasks/jobs/rules engine, primarily intended for use in a smarthome environment.

*Worker-Bunch* provides a programming infrastructure for creating tasks/jobs/rules with proprietary functionality.
These tasks/jobs/rules are called "workers" here. Each worker runs as a separate thread.

The worker base class is supposed to get overwritten. The most functionality goes into 2 functions with limited scope:
`subscribe_notifications` and `_work`. See
[dummy_worker.py](https://github.com/rosenloecher-it/worker-bunch/blob/master/app/dummy_worker.py) and
[main.py](https://github.com/rosenloecher-it/worker-bunch/blob/master/app/main.py).

The following infrastructure parts are already implemented:
- Starting and stopping the workers
- Logging
- Configuration and validation of configuration file (extendable for your job configuration; JSON schema based)
- Subscriptions to timer and cron events.
- Subscriptions to MQTT topics and publish MQTT messages. MQTT messages get debounced (configurable time span).
- Command line arguments

Other characteristics:
- Runs as Linux service.
- Additional prepacked is a Postgres and MQTT client.
  This is a quite opinionated decision due to the special lifecycle of the MQTT client (among others).
- Ready to use is a database worker, which is fully configurable (cron, sql statements, sql scripts, text replacements).
  See [database_worker](https://github.com/rosenloecher-it/worker-bunch/blob/master/worker_bunch/database/database_worker.py).


## Usage

Have a look at  [Worker-Bunch-Sample](https://github.com/rosenloecher-it/worker-bunch-sample)


## Maintainer & License

MIT © [Raul Rosenlöcher](https://github.com/rosenloecher-it)

The code is available at [GitHub][home].

[home]: https://github.com/rosenloecher-it/worker-bunch
FlaskApx 1.0.1
The helper for Flask
Requires Python: >=3.7, <4
Keywords: flask helper,flask,API heler,API Toolkit,API warper

Flask-Apx
=========

.. image:: https://github.com/Nux-xader/Flask-Apx/blob/master/images/sample.png
    :target: https://github.com/Nux-xader/Flask-Apx/blob/master/example/app.py
    :alt: Apx example

**apx** is the helper for flask


Notes
=====
This project is still in **BETA**. Please be careful if you want to use it in production environment! Thank You.

Why use apx?
============
* readable your code
* simplyify your code
* speed up the development process

Installation and usage
======================
**installation**

``$ pip install FlaskApx``

or


``$ pip install git+https://github.com/Nux-xader/Flask-Apx``

**Example**

For the example usage of code you can see `here <https://github.com/Nux-xader/Flask-Apx/blob/master/example/app.py>`_
riskhub 0.2
fetching URLs to any domains

### Features
    
    - it's a fetching and Gathering a URLs to any domains ;
    - reduce a timing for Gathering a URLs ;
    - it's takeing milliseconds for fetching and Gathering a URLs ; 
    - Support Module Loader, and Custom/define editor plugins;
    - Support identification, interpretation for fetching URLs


# requirement to install ..
    `$ pip3 install riskhub`

> Follow your heart.

# I recommends do both install pip and pip3 ..
    `$ pip install riskhub`

# COMMAND (help)..
    ' riskhub -h '

# OUTPUT COMMAND >> ' use >> this one '

# COMMAND (OUTPUT)..
    ' riskhub -d https://example.com/ >> output.txt ' 

## COMMAND (domain)..
    ' riskhub -d https://example.com/ '

# COMMAND (list of urls) ..
    ' riskhub -f urls.txt '

# COMMAND (domain with threads)..
    ' riskhub -d https://example.com/ -t 100'

## COMMAND (domain with multiplex)..
    'riskhub -d https://example.com/ -t 100 -m {proxy}'

> instagram >> "@sabarishh4ck3r",

> "END",
json-schema-enforcer 0.1.4
A progressive JSON schema validator
Requires Python: >=3.10,<4.0

# JSON schema enforcer

## Table of Contents

- [Introduction](#introduction)
- [Key Features](#key-features)
- [Installation](#installation)
- [Usage](#usage)
- [Example JSON Schema](#example-json-schema)
- [Potential Use Cases](#potential-use-cases)

## Introduction

json-schema-enforcer is a Python package that allows you to progressively validate a JSON string against a JSON schema. With this package, you can check if a JSON string adheres to the schema and if it is complete, even if the string is not fully formed. This is particularly useful when working with large language models to constraint text generation.

This project was created out of spite for the lack of a similar feature in [OpenAI ChatGPT's function calling](https://openai.com/blog/function-calling-and-other-api-updates), to prove that creating something like this is very easy. It uses the simplified JSON schema specification, similar to what OpenAI does. Please note that the code implementation probably does not adhere to best practices, as it is primarily an experimental showcase by someone who isn't skilled in creating programming language parsers.

## Key Features

- Parses a JSON schema and validates a string against it
- Determines if the returned JSON is valid (matches the schema and optional formatting)
- Determines if the JSON string is complete and provides the index of the last character

## Installation

You can install json-schema-enforcer using pip:

```shell
pip install json-schema-enforcer
```

## Usage

To use json-schema-enforcer in your Python project, follow these steps:

```python
import json_schema_enforcer

# Parse the schema
parser = json_schema_enforcer.parser_for_schema(schema)

# Check if the parser is valid
if parser is None:
    raise ValueError("Invalid JSON schema")

# Validate the JSON string
validated = parser.validate(maybe_json_string)

# Print the validation result
print(validated.valid)  # Whether it adheres to the schema
print("complete" if validated.end_index else "incomplete")
```

## Example JSON Schema

You can use the following example JSON schema as a reference when working with json-schema-enforcer:

```json
{
  "type": "object",
  "properties": {
    "name": { "type": "string", "maxLength": 20 },
    "age": { "type": "integer" },
    "preferred_animal": { "type": "string", "enum": ["cat", "dog"] }
  },
  "required": ["name", "age"]
}
```

## Potential Use Cases

- Constraining text generation with large language models; example: [local-llm-function-calling](https://github.com/rizerphe/local-llm-function-calling), a project that allows you to constrain generation with any huggingface model