semvec/pypi-packages huggingface dataset:
cbpi4-cooldown-braumeister 0.0.3
CraftBeerPi4 Plugin

# Craftbeerpi4 Plugin for Cooldown step with calculation of end time

The last step in cbpi that can be configured is a cooldown step. It'll be created if you have selected a cooldown step for the corresponding parameter. The step type must Start with Cooldown. One step comes with Craftbeerpi4. 

This step is applicable to kettles with cooling jacket (such as Speidel Braumeister Plus), but should work also with a cooling coil inside the wort.

The step caLculates the cooldown behavior based on newtons law of cooling and uses the data of the past 10 minutes in the step. In the beginning it waits for 2 Minutes and after the first 12 Minuted you will receive an estimation on when the process will be completed and the target temperature is reached 

The calculation is down with scipy and this formula is used for the curve fit: a * exp(-c * time) + d

The picture below shows as an example the principle. You can see the initial data in red from a cooldown step and the fitted curve in blue. The green datapoint is the estimated time, when the target Temperature is reached.

![Simulation data](https://github.com/PiBrewing/cbpi4-cooldown-braumeister/blob/main/Prediction_Curve.png?raw=true)

Below is an example of a real process done with the Braumeister 20 Plus. You can see, that the prediction has an accuracy  within 5 Minutes.

![Process Log](https://github.com/PiBrewing/cbpi4-cooldown-braumeister/blob/main/log.png?raw=true)

## Software installation:

Please have a look at the [Craftbeerpi4 Documentation](https://openbrewing.gitbook.io/craftbeerpi4_support/readme/plugin-installation)

- Package name: cbpi4-cooldown-braumeister
- Package link: https://github.com/PiBrewing/cbpi4-cooldown-braumeister/archive/main.zip

## Step Configuration

- Once successfully installed, select 'CooldownStepBM' for 'steps_cooldown' in the Craftbeerpi settings-

### Changelog:

- 24.11.25: (0.0.3) Add pyproject.toml file to support pip 25.3+
- 03.10.25: (0.0.2) Update scipy requirements
- 02.03.25: (0.0.1) Initial Release
abstractsignature 0.1.0
Create abstract function signatures that enforce consistent implementation signatures.
Requires Python: <4.0,>=3.11

# abstractsignature

This package provides a method for enforcing consistent
function signatures between abstractmethod implementations. This hopes to make large libraries where many classes inherit a common interface from a single abstract definition easier to maintain.

Classes which inherit an ``@abstractmethod`` with an ``@abstractsignature`` will fail to instantiate if their signature does not equal the abstraction.

Two signatures are considered equal if all their parameters are
equal (excluding the implicit ``self``/``cls`` parameter for instance and class methods), their positional and positional only parameters are in the same order, and they have equal return annotations. Parameters are considered equal if they have the same name, kind, default value, and annotation.


# Install

Install from git:

```sh
uv add git+https://github.com/d-c-gray/abstractsignature.git
```

# Usage

Create a class that inherits from ABCSignature, and
define abstract methods. Add the ``@abstractsignature`` decorator above the ``@abstractmethod`` decorator. 

<!--pytest.mark.xfail-->
```python
from abstractsignature import abstractsignature, ABCSignature
from abc import abstractmethod

class MyInterface(ABCSignature):
    @abstractsignature
    @abstractmethod
    def my_method(self, a: int) -> int:
        return a + 1

class MyImplementation(MyInterface):
    def __init__(self):
        super().__init__()
    def my_method(self, number: int) -> int:
        return number + 1

MyImplementation()
```

If the implemented signature doesn't match the defined signature, you will
get an error:


```
abstractsignature.abstractsignature.IncorrectSignatureError: implementation <bound method MyImplementation.my_method of <__main__.MyImplementation object at 0x00000135A7E1EE40>> does not match abstract definition of <class '__main__.MyInterface'>:
Implemented signature:
 (number: int) -> int
Abstract signature:
 (a: int) -> int
```

This pattern also works with ``@classmethod`` and ``@staticmethod``

```python
from abstractsignature import abstractsignature, ABCSignature
from abc import abstractmethod

class MyInterface(ABCSignature):
    @classmethod
    @abstractsignature
    @abstractmethod
    def my_class_method(cls, a: int) -> int:
        return a + 1

    @staticmethod
    @abstractsignature
    @abstractmethod
    def my_static_method(cls, a: int) -> int:
        return a + 1
```


*This project was built from
[simple-modern-uv](https://github.com/jlevy/simple-modern-uv).*