semvec/pypi-packages huggingface dataset:
reaktion-next 0.4.1
rpc and node backbone
Requires Python: <4.0,>=3.11

# reaktion-next

[![codecov](https://codecov.io/gh/arkitektio/omero-ark/branch/master/graph/badge.svg?token=UGXEA2THBV)](https://codecov.io/gh/arkitektio/arkitektio)
[![PyPI version](https://badge.fury.io/py/rekuest_next.svg)](https://pypi.org/project/rekuest/)
[![Maintenance](https://img.shields.io/badge/Maintained%3F-yes-green.svg)](https://pypi.org/project/rekuest/)
![Maintainer](https://img.shields.io/badge/maintainer-jhnnsrs-blue)
[![PyPI pyversions](https://img.shields.io/pypi/pyversions/rekuest_next.svg)](https://pypi.python.org/pypi/rekuest/)
[![PyPI status](https://img.shields.io/pypi/status/rekuest_next.svg)](https://pypi.python.org/pypi/rekuest/)

workflow scheduler  for arkitekt

## Idea

reaktion is a scheduler extension for rekuest, it hooks into the agent and provides the "Deploy Flow" Node, that allows users to
choose the app as a scheduler for their workflows. When deploying a flow, this plugin will create a new workflow node, which can
now be reserved by any external app.

When reserving a workflow node, the plugin will create a new "Flow" Actor, which will be responsible for the execution of the
workflow. This actor will keep track of the state of the workflow and acts as the scheduler.

## Prerequesits

Services: In order to use reaktion_next you need a working arkitekt server with both "rekuest" (remote app calling-service) and "fluss" -
(workflow design and run recording module)" installed.

Client: you need to install arkitekt-next with the "reaktion_next" extra enabled

### Use inside an Arktiekt "Plugin"App

Add the reaktion_next import to your imports

```python
from arkitekt_next import register
import reaktion_next # autoinstalls the scheduling extensions

@register
def do_something() -> None:
    """ Some other random installed functionaliry that is also provided """

```

Start your app via "arkitekt-next run dev". You should now see the
reaktion badge appear on the AgentPage and you will find the scheduler
in the Deploy Button subsection when deploying your app.

### Use inside an Arkitekt "Standalone App"

```python
from arkitekt import register, easy
import reaktion_next # autoinstalls the scheduling extensions

@register
def do_something() -> None:
    """ Some other random installed functionaliry that is also provided """



with easy("your_app_name", url="arkitekt-server-ulr") as e:
   e.run() # will start a normal arkitekt app with reaktion enabled

```

## Experimental: Local Scheduling

An Arkitekt app that imports reaktion_next can also run entire local workflows
the will call registered function in memory, and does not to copy data from and
to the arkitket server.
rpkg 1.69
A python library and runtime script for managing RPMpackage sources in a git repository

Introduction
============

This is the rpkg project, which mostly is a python library for dealing with
rpm packaging in a git source control.  pyrpkg is the base library that sites
can subclass to create useful tools.

rpkg works with Python 2.7, 3.6, 3.9, 3.12 and 3.13.

License
=======

Unless otherwise specified, all files are licensed under GPLv2+.

Installation
============

Install from distribution packages
----------------------------------

rpkg is available in Fedora and EPEL repositories. It can be installed with
package manager command. There is Python 3 package for Fedora and EPEL8;
and Python 2 package in EPEL7.

Install in a Fedora system::

    sudo dnf install python3-rpkg

Install in EPEL7::

    sudo yum install python2-rpkg

Install in EPEL8::

    sudo dnf install python3-rpkg

Install in a Python virtual environment
---------------------------------------

Both Python 2 and 3 packages are published in PyPI. Install rpkg in a Python 3
virtual environment in these steps::

    python3 -m venv .env
    source .env/bin/activate
    pip install rpkg rpm-py-installer

You are free to create a virtual environment with option ``--system-site-packages``.

Please note that, rpkg depends on some other utilities to build packages. These
packages are required to be installed as well.

* ``mock``: for local mockbuild.
* ``rpm-build``:  for local RPM build, which provides the command line ``rpm``.
* ``rpmlint``: check SPEC.
* ``copr-cli``: for building package in `Fedora Copr`_.
* ``module-build-service``: for building modules.

.. _`Fedora Copr`: https://copr.fedorainfracloud.org/

Contribution
============

You are welcome to write patches to fix or improve rpkg. All code should work
with Python 2.7, and 3. Before you create a PR to propose your changes,
make sure

Sign-off commit
---------------

Make sure to sign-off your commits by ``git commit -s``. This serves as a
confirmation that you have the right to submit your changes. See `Developer
Certificate of Origin`_ for details.

.. _Developer Certificate of Origin: https://developercertificate.org/

Run Tests
---------

Before make a pull request, ensure local changes pass all test cases.

Before run tests, install these packages::

    sudo dnf install python27 python36 python39 git make gcc rpm-build \
    rpm-devel libcurl-devel krb5-devel openssl-devel python3-devel

To run tests simply, ``make test``.

By default, target ``test`` runs tests with all supported Python versions.
However, if you look into ``Makefile``, there is still a target ``tox`` that
allows developer to run tests with test environments one by one.

Links
=====

* Documentation: https://docs.pagure.org/rpkg
* Upstream GIT: https://pagure.io/rpkg
* Issue tracker: https://pagure.io/rpkg/issues
runner-pjpawel 0.1.4
Universal runner with builder objects to run async, threaded or group commands
Requires Python: >=3.9

# runner (runner-pjpawel)
Universal runner with builder objects to run async, threaded or group commands

*Build for my research projects to run multiple scenarios with retry with one command*

#### *Remember! This project is on early stage of development* 

### Install
```shell
pip install runner-pjpawel
```

### Build runner
1. Create Runner class.
```python
from runner_pjpawel import Runner
runner = Runner()
```
2. Add commands. Use prepared `Command` classes in `runner.commands` module or classes that extends `runnner.command.BaseCommand`
```python
from runner_pjpawel.command.common import ShellCommand
shell = ShellCommand("uname -a")
runner.add_command(shell)
```
3. Invoke `run` or `run_sync` method.
```python
runner.run_sync()
```

### Existing commands
 - **ShellCommand** - executes shell command with subprocess.Popen
 - **GroupCommand** - treats all commands as one, allow to execute reset callback before retry
 - **ParallelCommand** - run commands in separate threads in parallel

### Commands to be implemented
 - **CyclicCommand** - Handles job than should be run more than once
 - **ThreadCommand** - Run callable in separate thread

### Build new commands
You can build you own command. To do so, create class that extend class `BaseCommand`.
You have to override `_do_work` method.
```python
class YourCommand(BaseCommand):
    def _do_work(self) -> CommandResult | None:
        ...
```



### Full examples

1. Simplest example
```python
from runner_pjpawel import Runner
from runner_pjpawel.command import ShellCommand

r = Runner(show_progress_bar=False)
r.add_command(ShellCommand("uname"))
r.run_sync()
    
```
mores 0.1.2
LLM-powered decorators for intelligent function behavior
Requires Python: >=3.12

# Mores

LLM-powered Python decorators for intelligent function behavior. Add validation, mocking, and output checking to your functions with a single line of code.

## Installation

```bash
{pip, uv} install mores
```

## Setup

Configure

```bash
export MORES_API_KEY=gsk_your_key_here
export MORES_SERVER_URL=https://mores.fulcrumresearch.ai
```

## Decorators

All decorators support two modes, depending on latency and intelligence requirements, passed in as keyword arguments - `mode=fast` and `mode=slow`.

### @guard - Pre-execution Validation

Validates function calls against custom rules before execution.

**Basic Usage:**

```python
@guard(rules=[
    "Never allow deletion",
    "Only allow amounts under 100"
])
def transfer(amount: float, delete: bool = False):
    """Transfer an amount."""
    if delete:
        return "deleted"
    return f"transferred {amount}"

result = transfer(50, delete=False)  # ✓ Returns Value
result = transfer(200, delete=False)  # ✗ Returns Rejected
result = transfer(50, delete=True)   # ✗ Returns Rejected
```


**Processing Guard Results:**

By default, `@guard` returns a `Maybe` type (either `Value` or `Rejected`). You can handle this in the following way.

1. **Pattern matching with match/case** (default):
```python
result = transfer(50, delete=False)
match result:
    case Value(data=data):
        # Function executed successfully
        print(f"Success: {data}")
    case Rejected(reason=reason):
        # Call was rejected
        print(f"Error: {reason}")
```

You can also `@guard(..., raise_reject=True)` to return the raw output, and raise if an error is caught.

### @mock - LLM-Generated Output

Replaces function execution with AI-generated mock output based on the function signature and documentation.

```python
from mores import mock

@mock()
def calculate_fibonacci(n: int):
    """Calculate the nth Fibonacci number."""
    pass  # Implementation doesn't matter

result = calculate_fibonacci(10)
print(result)  # LLM-generated Fibonacci number
```

### @doubt - Post-execution Validation

Validates that function output is correct given its inputs and implementation. Raises `DoubtError` if the output appears incorrect.

```python
from mores import doubt, DoubtError

@doubt()
def add(a: int, b: int):
    """Add two numbers."""
    return a + b

# Correct implementation passes
result = add(2, 3)  # Returns 5, no error

# Incorrect implementation raises error
@doubt()
def broken_add(a: int, b: int):
    """Add two numbers."""
    return a * b  # Wrong! Multiplying instead

try:
    broken_add(2, 3)
except DoubtError as e:
    print(e.reason)  # "The function should add but it's multiplying..."
```