semvec/pypi-packages huggingface dataset:
async-plus 0.3.0
Async-related stuff you miss in standard library
License: MIT
Requires Python: >3.7

async_plus
==========

Async-related stuff you miss in standard library

..  Original (unscaled) picture:
    https://upload.wikimedia.org/wikipedia/commons/f/fe/The_Hanging_by_Jacques_Callot.jpg
    :align:, :figwidth: directives appear not working for figure, so just scale
    it with Wikimedia capabilities and put under description.

.. figure:: https://upload.wikimedia.org/wikipedia/commons/thumb/f/fe/The_Hanging_by_Jacques_Callot.jpg/500px-The_Hanging_by_Jacques_Callot.jpg

    *“The horrors of hanging tasks when using asyncio” by Jacques Callot*


Safely run coroutines concurrently
----------------------------------

The ``asyncio.gather()`` function has an
`issue <https://bugs.python.org/issue31452>`_: in case of error in one of
coroutines the rest coroutines are left running detached.  This might cause
hard to detect problems.  On the contrary, the ``async_plus.try_gather()``
insures all tasks are cancelled on error:

.. code-block:: python

    result1, result2 = await async_plus.try_gather(
        coroutine_func1(...),
        coroutine_func2(...),
    )


Fire-and-forget task
--------------------

With ``create_task()`` it's your responsibility to retrieve exception.
Usually this causes that exception is not seen until process finishes or
even is not seen at all if process is killed.  With ``launch_watched()``
exception is logged immediately when it's raised.

.. code-block:: python

    async_plus.launch_watched(your_coroutine_func(...))


Structuring groups of tasks
---------------------------

.. code-block:: python

    async with async_plus.task_scope() as scope:
        scope.launch(coroutine_func1(...))
        scope.launch(coroutine_func2(...))
        await scope.wait()

By default, ``wait()`` call returns when all tasks finish or first exception
occurs.  In all cases all unfinished tasks are cancelled at the end of
``async with`` block.


Increase delay between attempts in supervisor
---------------------------------------------

.. code-block:: python

    retry_delayer = async_plus.RetryDelayer([0, 10, 60], random_shift=1)
    while True:
        try:
            await run_service_x()
        # In Python <3.8 it inherits from Exception
        except asyncio.CancelledError:
            raise
        except Exception:
            logger.exception('Error in service X:')
            await retry_delayer.sleep()


Log long waits
--------------

Does your program hang and you don't know what it's waiting for?  Wrap
suspicious coroutines with ``impatient()`` to see bottlenecks:

.. code-block:: python

    await async_plus.impatient(asyncio.sleep(10), log_after=5)

Or just log the time it took:

.. code-block:: python

    await async_plus.impatient(asyncio.sleep(10), log_completion='always')


Change log
----------

..  Absolute link is needed for correct description on PyPI.
    See https://github.com/pypa/readme_renderer/issues/163

See `CHANGELOG <https://github.com/ods/async-plus/blob/master/CHANGELOG.rst>`_.
chickadee-opt 0.1.1
A tool for advanced dispatch optimization of hybrid energy systems
License: MIT
Requires Python: >=3.5

# Chickadee
> A developmental hybrid energy system dispatch optimization package aimed at providing flexibility and development speed while supporting integration with other tools.

The goal of this project is to be a testing-grounds for design and dispatch optimization. This project is meant to stay light, fast and flexible rather than full-featured or rigorous. A key requirement of this project is to maintain compatibility with [HERON](https://github.com/idaholab/HERON) so as to be useable as an internal dispatch optimizer. As a result, the structure necessarily mimics that of HERON to some extent.

## Development Installation
Install chickadee for development using pip. Run the following command from within the root of the repository: `pip install -e .`

## Requirements
- Needs to be able to be imported into HERON for internal dispatch optimization
- Needs to be a flexible place for quickly and simply messing around with dispatch/design opt
- Be importable and useable as a python library
- Has to be useable with various optimizers and with various optimization schemes
- Has to be able to support the same type of components as HERON


## Ideas to experiment with
- Adding DAEs
- Integrating GEKKO as an optimizer
- Support for timing, allowing optimization of algorithm