semvec/pypi-packages huggingface dataset:
ricochet 0.2.1
Simple Spring-inspired IoC framework for Python.
Requires Python: >=3.7.0
Keywords: python ioc spring inversion of control

# Ricochet - IoC simplified

[
    ![status](https://gitlab.com/flitt3r/ricochet/badges/master/pipeline.svg)
    ![coverage](https://gitlab.com/flitt3r/ricochet/badges/master/coverage.svg)
](https://gitlab.com/flitt3r/ricochet/pipelines)

**This is still in concept stage. No implementation exists yet**

Ricochet is designed to be an architectural design framework for Python applications which utilises inversion of 
control. Built with the aim of making complex designs simpler to implement, this framework will allow you to specify 
dependencies between components in a simple way and allow the framework to handle wiring the references together.  

It is designed to be simple, easy to learn, fast to use, but powerful when you need it, and aims to provide utilities
for wiring up a Python application using tagged components (similar to Java annotations) and configuration classes.
The recoil runner context will then manage dependency injection for you on startup, creating singletons of each
class you tag.
pytest-yield 1.0.0
PyTest plugin to run tests concurrently, each `yield` switch context to other one
Keywords: testing,pytest

========
Overview
========

.. start-badges

.. list-table::
    :stub-columns: 1

    * - tests
      - | |drone|
    * - package
      - | |version| |supported-versions| |supported-implementations|

.. |drone| image:: https://cloud.drone.io/api/badges/devova/pytest-yield/status.svg
    :alt: Drone-CI Build Status
    :target: https://cloud.drone.io/devova/pytest-yield


.. |version| image:: https://img.shields.io/pypi/v/pytest-yield.svg
    :alt: PyPI Package latest release
    :target: https://pypi.python.org/pypi/pytest-yield

.. |supported-versions| image:: https://img.shields.io/pypi/pyversions/pytest-yield.svg
    :alt: Supported versions
    :target: https://pypi.python.org/pypi/pytest-yield

.. |supported-implementations| image:: https://img.shields.io/pypi/implementation/pytest-yield.svg
    :alt: Supported implementations
    :target: https://pypi.python.org/pypi/pytest-cov

.. end-badges

What?
~~~~~

**pytest\_yield** is a plugin that allows run tests as coroutines. This
means that a few tests can being executing at same time.

Why?
~~~~

This is first question that engineers asking. General theory said us
that each test have to be run separetelly and independently, meaning
without any influence on other tests. This plugin breaks this rules at
all.

So why do we need it?

Imagine we have integration tests where each test execution takes very
long time. For examle test should wait for some reactions depend on
initial actions. This waiting could take up to e.g. 1 hour. And even
after it we need perform next action from scenario and wait more.
Syncronous execution of all tests, one by one, will take huge amout of
time. But what if all test cases are independent, so actions of *test1*
does not influence results of *test2*. Than make sense some how skip
waiting prosess of *test1* and switch execution context to *test2*. This
actually what **pytest\_yield** doing.

How?
~~~~

Each concurrent test is suppose to be a generator. Switching of
execution context is performed after each ``yield``. Test add itself to
the end of a deueue if generator is not exausted yet. After new one is
pulled from left side of dequeue. Assume test have ``N`` yields, tahn it
will be ``N`` times rescheduled.

|image2|

Do not use with
~~~~~~~~~~~~~~~

Tests that are cross dependent. Most
particular example is unittests with mocks, if *test1* mock some method,
this will be implicitly mocked in *test2* also.

.. |image2| image:: https://raw.githubusercontent.com/devova/pytest-yield/b0c7aa058df5f50cb9a05272fce01fc62a78bbee/how-it-works-pytest-yield.svg?sanitize=true