Skip to content
Permalink
release-2.x
Switch branches/tags
Go to file
 
 
Cannot retrieve contributors at this time

Changes

v2.0.3 (2020-11-27)

  • Mark eventlet and gevent support as deprecated. The support will be removed in Pykka 3.0.

    These where somewhat interesting ways to implement concurrency in Python when Pykka was conceived in 2011. Today, it is unclear it these libraries still have any mindshare or if keeping the support for them just adds an unecessary burden to Pykka's maintenance.

  • Include Python 3.9 in the test matrix. (PR: :issue:`98`)

  • Add missing :class:`None` default value for the timeout keyword argument to :meth:`~pykka.eventlet.EventletEvent.wait`, so that it matches the :class:`~threading.Event` API. (PR: :issue:`91`)

v2.0.2 (2019-12-02)

Bugfix release.

  • Fix test suite run with pytest-mocker >= 1.11.2. (Fixes: :issue:`85`)

v2.0.1 (2019-10-10)

Bugfix release.

v2.0.0 (2019-05-07)

Major feature release.

Dependencies

  • Drop support for Python 2.6, 3.2, 3.3, and 3.4. All have reached their end of life and do no longer receive security updates.
  • Include CPython 3.5, 3.6, 3.7, and 3.8 pre-releases, and PyPy 3.5 in the test matrix.
  • Include gevent and Eventlet tests in all environments. Since Pykka was originally developed, both has grown support for Python 3 and PyPy.
  • On Python 3, import :class:`Callable` and :class:`Iterable` from :mod:`collections.abc` instead of :mod:`collections`. This fixes a deprecation warning on Python 3.7 and prepares for Python 3.8.

Actors

  • Actor messages are no longer required to be dict objects. Any object type can be used as an actor message. (Fixes: :issue:`39`, :issue:`45`, PR: :issue:`79`)

    For existing code, this means that :meth:`~pykka.Actor.on_receive` implementations should no longer assume the received message to be a dict, and guard with the appropriate amount of :func:`isinstance` checks. As an existing application will not observe any new message types before it starts using them itself, this is not marked as backwards incompatible.

Proxies

  • Backwards incompatible: Avoid accessing actor properties when creating a proxy for the actor. For properties with side effects, this is a major bug fix. For properties which does heavy work, this is a major startup performance improvement.

    This is backwards incompatible if you in a property getter returned an object instance with the pykka_traversable marker. Previously, this would work just like a traversable attribute. Now, the property always returns a future with the property getter's return value.

  • Fix infinite recursion when creating a proxy for an actor with an attribute or method replaced with a :class:`~unittest.mock.Mock` without a spec defined. (Fixes: :issue:`26`, :issue:`27`)

  • Fix infinite recursion when creating a proxy for an actor with an attribute that was itself a proxy to the same actor. The attribute will now be ignored and a warning log message will ask you to consider making the self-proxy private. (Fixes: :issue:`48`)

  • Add :meth:`~pykka.CallableProxy.defer` to support method calls through a proxy with :meth:`~pykka.ActorRef.tell` semantics. (Contributed by Andrey Gubarev. Fixes: :issue:`63`. PR: :issue:`72`)

  • Add :func:`~pykka.traversable` for marking an actor's attributes as traversable when used through actor proxies. The old way of manually adding a pykka_traversable attribute to the object to be traversed still works, but the new function is recommended as it provides protection against typos in the marker name, and keeps the traversable marking in the actor class itself. (PR: :issue:`81`)

Futures

  • Backwards incompatible: :meth:`pykka.Future.set_exception` no longer accepts an exception instance, which was deprecated in 0.15. The method can be called with either an exc_info tuple or :class:`None`, in which case it will use :func:`sys.exc_info` to get information on the current exception.

  • Backwards incompatible: :meth:`pykka.Future.map` on a future with an iterable result no longer applies the map function to each item in iterable. Instead, the entire future result is passed to the map function. (Fixes: :issue:`64`)

    To upgrade existing code, make sure to explicitly apply the core of your map function to each item in the iterable:

    >>> f = pykka.ThreadingFuture()
    >>> f.set([1, 2, 3])
    >>> f.map(lambda x: x + 1).get()  # Pykka < 2.0
    [2, 3, 4]
    >>> f.map(lambda x: [i + 1 for i in x]).get()  # Pykka >= 2.0
    [2, 3, 4]
    

    This change makes it easy to use :meth:`~pykka.Future.map` to extract a field from a future that returns a dict:

    >>> f = pykka.ThreadingFuture()
    >>> f.set({'foo': 'bar'})
    >>> f.map(lambda x: x['foo']).get()
    'bar'
    

    Because dict is an iterable, the now removed special handling of iterables made this pattern difficult to use.

  • Reuse result from :meth:`pykka.Future.filter`, :meth:`pykka.Future.map`, and :meth:`pykka.Future.reduce`. Recalculating the result on each call to :meth:`pykka.Future.get` is both inconsistent with regular futures and can cause problems if the function is expensive or has side effects. (Fixes: :issue:`32`)

  • If using Python 3.5+, one can now use the await keyword to get the result from a future. (Contributed by Joshua Doncaster-Marsiglio. PR: :issue:`78`)

Logging

  • Pykka's use of different log levels has been :ref:`documented <logging>`.
  • Exceptions raised by an actor that are captured into a reply future are now logged on the :attr:`~logging.INFO` level instead of the :attr:`~logging.DEBUG` level. This makes it possible to detect potentially unhandled exceptions during development without having to turn on debug logging, which can have a low signal to noise ratio. (Contributed by Stefan M枚hl. Fixes: :issue:`73`)

Gevent support

  • Ensure that the original traceback is preserved when an exception is returned through a future from a Gevent actor. (Contributed by Arne Brutschy. Fixes: :issue:`74`, PR: :issue:`75`)

Internals

  • Backwards incompatible: Prefix all internal modules with _. This is backwards incompatible if you have imported objects from other import paths than what is used in the documentation.
  • Port tests to pytest.
  • Format code with Black.
  • Change internal messaging format from dict to namedtuple. (PR: :issue:`80`)

v1.2.1 (2015-07-20)

v1.2.0 (2013-07-15)

v1.1.0 (2013-01-19)

v1.0.1 (2012-12-12)

v1.0.0 (2012-10-26)

v0.16 (2012-09-19)

  • Let actors access themselves through a proxy. See the :class:`pykka.ActorProxy` documentation for use cases and usage examples. (Fixes: :issue:`9`)
  • Give proxies direct access to the actor instances for inspecting available attributes. This access is only used for reading, and works since both threading and gevent based actors share memory with other actors. This reduces the creation cost for proxies, which is mostly visible in test suites that are starting and stopping lots of actors. For the Mopidy test suite the run time was reduced by about 33%. This change also makes self-proxying possible.
  • Fix bug where :meth:`pykka.Actor.stop` called by an actor on itself did not process the remaining messages in the inbox before the actor stopped. The behavior now matches the documentation.

v0.15 (2012-08-11)

  • Change the argument of :meth:`pykka.Future.set_exception` from an exception instance to a exc_info three-tuple. Passing just an exception instance to the method still works, but it is deprecated and may be unsupported in a future release.
  • Due to the above change, :meth:`pykka.Future.get` will now reraise exceptions with complete traceback from the point when the exception was first raised, and not just a traceback from when it was reraised by :meth:`get`. (Fixes: :issue:`10`)

v0.14 (2012-04-22)

v0.13 (2011-09-24)

  • 10x speedup of traversable attribute access by reusing proxies.
  • 1.1x speedup of callable attribute access by reusing proxies.

v0.12.4 (2011-07-30)

  • Change and document order in which :meth:`pykka.ActorRegistry.stop_all` stops actors. The new order is the reverse of the order the actors were started in. This should make stop_all work for programs with simple dependency graphs in between the actors. For applications with more complex dependency graphs, the developer still needs to pay attention to the shutdown sequence. (Fixes: :issue:`8`)

v0.12.3 (2011-06-25)

v0.12.2 (2011-05-05)

v0.12.1 (2011-04-25)

v0.12 (2011-03-30)

  • First stable release, as Pykka now is used by the Mopidy project. From now on, a changelog will be maintained and we will strive for backwards compatibility.