django-viewflow 2.1.2__tar.gz → 2.2.3__tar.gz

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-viewflow
-Version: 2.1.2
+Version: 2.2.3
 Summary: Reusable library to build business applications fast
 Author: Mikhail Podgurskiy
 Author-email: kmmbvnr@gmail.com

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/README.md

@@ -185,24 +185,41 @@ modifications of Viewflow. You can find the commercial license terms in
 
 ## Changelog
 
-### 2.1.2 2024-06-24
+### 2.2.3 2024-07-09
 
-- Allow cancelling Celery tasks from the ERROR state.
-- Hotfix: Fix broken Join when no other nodes are created by Split.
-- Allow using this references to flow static methods as Celery tasks.
-- Allow cancelling Celery jobs from the ERROR status.
-- Add missing permission check before adding a new item to the list.
-- Allow Admin() viewset to be used as a sub-item in an Application viewset.
+- Fixed issue with Split/Join operations when an immediate split to join
+  connection occurs.
+- Improved redirect functionality for "Execute and Continue." Now redirects to
+  the process details if the process has finished.
+- Enabled the Undo action for End() nodes.
 
-### 2.1.1 2024-06-06
 
-- Hotfix broken task creation
+### 2.2.2 2024-07-05
 
+- Introduced new parameters for .If().Then(.., task_data=, task_seed) and
+  .Else(...)
+- Include {{ form.media }} into default workflow/task.html template
 
-### 2.1.0 2024-06-16
 
-- Allow to assign additional custom data to viewflow.fsm transitions
-- Added `data_source` parameter to `Split.Next()` method, allowing dynamic creation of multiple node instances based on a list of data items.
+### 2.2.1 2024-07-03
+
+- Introduced a new parameter for .Next(..., task_seed=) that allows the
+  instantiation of new tasks with additional initialized .seed generic foreign key
+- Introduced a new parameter for .Split(..., task_seed_source=) same as task_data_source,
+  prodices outgoing tasks with initializaed .seed value
+- Introduced a new parameter for flow.Subprocess(process_data=, process_seed=,
+  task_data=, task_seed=) allows to provide data nad seed for newly created
+  process and/or start task
+
+### 2.2.0 2024-06-28
+
+- Introduced a new parameter for .Next(..., task_data=) that allows the
+  instantiation of new tasks with additional initialized .data, enabling data to
+  be passed from task to task.
+- Added process.seed and task.seed generic foreign keys to the default workflow
+  models. Along with process.artifact and task.artifact, these additions enable
+  tracking of business process results from start to finish.
+- Renamed Split.Next(data_source=) to task_data_source=.
 
 
 [build]: https://img.shields.io/github/actions/workflow/status/viewflow/viewflow/django.yml?branch=main

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/django_viewflow.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: django-viewflow
-Version: 2.1.2
+Version: 2.2.3
 Summary: Reusable library to build business applications fast
 Author: Mikhail Podgurskiy
 Author-email: kmmbvnr@gmail.com

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/django_viewflow.egg-info/SOURCES.txt

@@ -1,5 +1,4 @@
 LICENSE
-LICENSE.django
 LICENSE_EXCEPTION
 MANIFEST.in
 README.md
@@ -306,6 +305,7 @@ viewflow/workflow/migrations/0009_merge.py
 viewflow/workflow/migrations/0010_viewflow20.py
 viewflow/workflow/migrations/0011_alter_task_created_and_more.py
 viewflow/workflow/migrations/0012_alter_process_data_alter_task_data.py
+viewflow/workflow/migrations/0013_process_seed_content_type_process_seed_object_id_and_more.py
 viewflow/workflow/migrations/__init__.py
 viewflow/workflow/nodes/__init__.py
 viewflow/workflow/nodes/end.py
@@ -318,6 +318,5 @@ viewflow/workflow/nodes/mixins.py
 viewflow/workflow/nodes/obsolete.py
 viewflow/workflow/nodes/split.py
 viewflow/workflow/nodes/start.py
-viewflow/workflow/nodes/subprocess.py
 viewflow/workflow/nodes/switch.py
 viewflow/workflow/nodes/view.py

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/setup.py

@@ -4,7 +4,7 @@ README = open("README.md", "r", encoding="utf-8").read()
 
 setuptools.setup(
     name="django-viewflow",
-    version="2.1.2",
+    version="2.2.3",
     author_email="kmmbvnr@gmail.com",
     author="Mikhail Podgurskiy",
     description="Reusable library to build business applications fast",

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/viewflow/templates/viewflow/workflow/task.html

@@ -1,6 +1,10 @@
 {% extends request.resolver_match.app.base_template_name|default:'viewflow/workflow/base_page.html' %}
 {% load i18n viewflow workflow %}
 
+{% block extrahead %}
+  {{ block.super }}
+  {{ form.media }}
+{% endblock %}
 
 {% block content %}{% with process=request.activation.process task=request.activation.task %}
   <div class="mdc-layout-grid vf-page__grid">

django-viewflow-2.2.3/viewflow/this_object.py

@@ -0,0 +1,119 @@
+"""Forward-reference for class-body declarations"""
+
+# Copyright (c) 2017-2020, Mikhail Podgurskiy
+# All Rights Reserved.
+
+# This work is dual-licensed under AGPL defined in file 'LICENSE' with
+# LICENSE_EXCEPTION and the Commercial license defined in file 'COMM_LICENSE',
+# which is part of this source code package.
+from typing import Any, Optional, Union
+
+
+class ThisMethod:
+    """
+    Reference to a method for forward references in class bodies.
+
+    This class is used to defer the resolution of a method reference until the
+    class is fully constructed. This is particularly useful in workflow or state
+    machine implementations where the flow references are declared before the
+    methods are defined.
+    """
+
+    def __init__(self, propname: str, methodname: str):
+        self._propname = propname
+        self._methodname = methodname
+
+    def resolve(self, instance) -> Any:
+        """
+        Resolve the method reference on the given instance.
+
+        Args:
+            instance (object): The instance on which to resolve the method.
+
+        Returns:
+            Any: The result of the resolved method call.
+
+        Raises:
+            AttributeError: If the property or method does not exist on the instance.
+        """
+        prop = getattr(instance, self._propname)
+        method = getattr(instance, f"_this_{self._methodname}")
+        return method(prop)
+
+
+class ThisObject(object):
+    """
+    Helper for forward references to class attributes.
+
+    This class is used to defer the resolution of an attribute reference until
+    the class is fully constructed. This allows for the use of class attributes
+    before they are defined.
+
+    Attributes:
+        name (str): The name of the attribute to resolve.
+    """
+
+    def __init__(self, name: str) -> None:  # noqa D102
+        self.name = name
+
+    def resolve(self, instance: object) -> Any:
+        """
+        Resolve the attribute reference on the given instance.
+
+        Args:
+            instance (object): The instance on which to resolve the attribute.
+
+        Returns:
+            Any: The resolved attribute.
+
+        Raises:
+            AttributeError: If the attribute does not exist on the instance.
+        """
+        return getattr(instance, self.name)
+
+    # def __copy__(self):
+    #     return super().__copy__()
+
+    # def __deepcopy__(self, memo):
+    #     return super().__deepcopy__(memo)
+
+    def __getattr__(self, name):
+        if name.startswith("__"):
+            super().__getattr__(name)
+        return ThisMethod(self.name, name)
+
+
+class This:
+    """
+    Helper for building forward references to class attributes and methods.
+
+    The rationale is the ability to specify references to the class attributes and
+    methods before they are declared. `this` acts similarly to `self`, but for
+    class-level forward references.
+    """
+
+    def resolve(self, instance: object, this_ref: Union[ThisObject, ThisMethod, Any]):
+        """
+        Resolve a forward reference on the given instance.
+
+        Args:
+            instance (object): The instance on which to resolve the reference.
+            this_ref (Union[ThisObject, ThisMethod, Any]): The reference to resolve.
+
+        Returns:
+            Any: The resolved reference.
+
+        Raises:
+            AttributeError: If the reference cannot be resolved.
+        """
+        if isinstance(this_ref, (ThisObject, ThisMethod)):
+            return this_ref.resolve(instance)
+        else:
+            return this_ref
+
+    def __getattr__(self, name):
+        return ThisObject(name)
+
+
+# Instantiate a global `this` object for use in class definitions.
+this = This()

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/viewflow/urls/base.py

@@ -8,6 +8,7 @@ import copy
 import types
 import warnings
 from collections import namedtuple, OrderedDict
+from typing import Optional, Dict, Any, List, Union
 
 from django.views.generic import RedirectView
 from django.urls import URLPattern, URLResolver, include, path, reverse
@@ -29,17 +30,17 @@ class _UrlName(str):
     hierarchy.
     """
 
-    def __init__(self, value):
+    def __init__(self, value) -> None:
         str.__init__(value)
         self.extra = {}
 
 
 class _URLResolver(URLResolver):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, *args, **kwargs) -> None:
         self.extra = kwargs.pop("extra", {})
         super(_URLResolver, self).__init__(*args, **kwargs)
 
-    def resolve(self, *args, **kwargs):
+    def resolve(self, *args, **kwargs) -> str:
         result = super(_URLResolver, self).resolve(*args, **kwargs)
         if not isinstance(result.url_name, _UrlName):
             result.url_name = _UrlName(result.url_name)
@@ -54,7 +55,7 @@ class _URLResolver(URLResolver):
 Route = namedtuple("Route", ["prefix", "viewset"])
 
 
-def route(prefix, viewset):
+def route(prefix, viewset: "BaseViewset") -> Route:
     """A viewset url"""
     if not isinstance(viewset, BaseViewset):
         raise ValueError(
@@ -65,26 +66,48 @@ def route(prefix, viewset):
     return Route(prefix, viewset)
 
 
-class BaseViewset(object):
+class BaseViewset:
     """
-    Class-based django routing configuration
+    Base class for defining a class-based Django routing configuration.
+
+    Attributes:
+        app_name (Optional[str]): The name of the application associated with this viewset.
+        namespace (Optional[str]): The namespace for the URLs of this viewset.
+        parent_namespace (Optional[str]): The namespace of the parent viewset.
+        extra_kwargs (Optional[Dict[str, Any]]): Additional keyword arguments for URL configuration.
     """
 
-    app_name = None
-    namespace = None
-    parent_namespace = None
-    extra_kwargs = None
+    app_name: Optional[str] = None
+    namespace: Optional[str] = None
+    parent_namespace: Optional[str] = None
+    extra_kwargs: Optional[Dict[str, Any]] = None
 
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
-        self._parent = None
+        self._parent: Optional[BaseViewset] = None
 
     @property
-    def parent(self):
+    def parent(self) -> Optional["BaseViewset"]:
+        """
+        Get the parent viewset.
+
+        Returns:
+            Optional[BaseViewset]: The parent viewset, if any.
+        """
         return self._parent
 
     @parent.setter
-    def parent(self, value):
+    def parent(self, value: "BaseViewset") -> None:
+        """
+        Set the parent viewset. This can only be set once.
+
+        Args:
+            value (BaseViewset): The viewset to set as the parent.
+
+        Raises:
+            Warning: If the parent is being set more than once or if the viewset
+                     already has an explicit parent namespace.
+        """
         if self._parent is not None:
             warnings.warn(
                 f"Viewset {self.__class__.__name__} parent could be set only once",
@@ -98,11 +121,28 @@ class BaseViewset(object):
         self._parent = value
 
     @property
-    def urls(self):
+    def urls(self) -> List[Any]:
         raise NotImplementedError("Subclass should override this")
 
-    def reverse(self, viewname, args=None, kwargs=None, current_app=None):
-        """Get view url."""
+    def reverse(
+        self,
+        viewname: str,
+        args: Optional[list[Any]] = None,
+        kwargs: Optional[dict[str, Any]] = None,
+        current_app: Optional[str] = None,
+    ) -> str:
+        """
+        Get the URL for a given viewname, including the namespace.
+
+        Args:
+            viewname (str): The name of the view.
+            args (Optional[list[Any]], optional): Positional arguments for the view.
+            kwargs (Optional[dict[str, Any]], optional): Keyword arguments for the view.
+            current_app (Optional[str], optional): The current application namespace.
+
+        Returns:
+            str: The URL for the view with the appropriate namespace
+        """
         view_namespace = ""
 
         current_viewset = self
@@ -121,7 +161,17 @@ class BaseViewset(object):
 
         return reverse(viewname, args=args, kwargs=kwargs, current_app=current_app)
 
-    def has_view_permission(self, user, obj=None):
+    def has_view_permission(self, user: Any, obj: Optional[Any] = None):
+        """
+        Determine if the user has permission to view the viewset.
+
+        Args:
+            user (User): The user to check permissions for.
+            obj (Optional[Any], optional): The object being viewed.
+
+        Returns:
+            bool: True if the user has view permission, False otherwise.
+        """
         return True
 
 

{django-viewflow-2.1.2 → django-viewflow-2.2.3}/viewflow/workflow/activation.py

@@ -1,5 +1,5 @@
 from contextlib import contextmanager
-from typing import List
+from typing import Any, List, Optional, Set
 
 from django.db import connection, transaction
 from django.utils.timezone import now
@@ -10,70 +10,116 @@ from .signals import task_finished, task_failed
 from .status import STATUS, PROCESS
 
 
-def parent_tasks_completed(activation):
-    """Canceled task could be recreated iff all parent task was not cancelled."""
+def parent_tasks_completed(activation: "Activation") -> bool:
+    """
+    Check if all parent tasks are completed.
+
+    Canceled task could be recreated iff all parent task was not cancelled.
+
+    Args:
+        activation (Activation): The current activation instance.
+
+    Returns:
+        bool: True if all parent tasks are completed, False otherwise.
+    """
     previous = activation.task.previous.values("status")
     completed = (STATUS.DONE, STATUS.REVIVED)
     return all(lambda task: task.status in completed, previous)
 
 
-def leading_tasks_canceled(activation):
-    """Task could be undone iff no outgoing uncancelled tasks are exists."""
+def leading_tasks_canceled(activation: "Activation") -> bool:
+    """
+    Check if all leading tasks are canceled.
+
+    Task could be undone iff no outgoing uncancelled tasks are exists.
+
+    Args:
+        activation (Activation): The current activation instance.
+
+    Returns:
+        bool: True if all leading tasks are canceled, False otherwise.
+    """
     non_canceled_count = activation.task.leading.exclude(status=STATUS.CANCELED).count()
     return non_canceled_count == 0
 
 
-def process_not_cancelled(activation):
+def process_not_cancelled(activation: "Activation") -> bool:
+    """
+    Check if the process is not canceled.
+
+    Args:
+        activation (Activation): The current activation instance.
+
+    Returns:
+        bool: True if the process is not canceled, False otherwise.
+    """
     return activation.process.status != PROCESS.CANCELED
 
 
-def has_manage_permission(activation, user):
+def has_manage_permission(activation: "Activation", user: Any) -> bool:
+    """
+    Check if the user has manage permission.
+
+    Args:
+        activation (Activation): The current activation instance.
+        user (Any): The user instance.
+
+    Returns:
+        bool: True if the user has manage permission, False otherwise.
+    """
     return activation.flow_class.instance.has_manage_permission(user)
 
 
-class Activation(object):
+class Activation:
     """
     Base class for flow task activations.
 
-    Activation is responsible for flow task state management and persistance.
-    Each activation status changes are restricted by a simple finite state
-    automata.
+    Activation is responsible for flow task state management and persistence.
+    Each activation status change is restricted by a simple finite state automaton.
     """
 
     status: fsm.State = fsm.State(STATUS, default=STATUS.NEW)
+    type: str = "node"
+
+    def __init__(self, task: Any) -> None:
+        """
+        Instantiate an activation.
 
-    def __init__(self, task):
-        """Instantiate an activation."""
+        Args:
+            task (Any): The task instance associated with the activation.
+        """
         self.task = task
         self.process = task.process.coerced
 
-    def __eq__(self, other):
+    def __eq__(self, other: Any) -> bool:
         if not isinstance(other, Activation):
             return False
         return self.task == other.task
 
-    def __hash__(self):
+    def __hash__(self) -> int:
         return hash(self.task)
 
     @status.setter()
-    def _set_status(self, value):
+    def _set_status(self, value: Any) -> None:
         """Set the status to the underline task."""
         self.task.status = value
 
     @status.getter()
-    def _get_status(self):
+    def _get_status(self) -> Any:
         """Get the status of the activated task."""
         return self.task.status
 
     @property
-    def flow_task(self):
+    def flow_task(self) -> Any:
+        """Get the flow task associated with the activation."""
         return self.task.flow_task
 
     @property
-    def flow_class(self):
+    def flow_class(self) -> Any:
+        """Get the flow class associated with the activation."""
         return self.flow_task.flow_class
 
-    def exception_guard(self):
+    def exception_guard(self) -> contextmanager:
         """
         Perform activation action inside a transaction.
 
@@ -100,56 +146,101 @@ class Activation(object):
         return guard()
 
     @classmethod
-    def create(cls, flow_task, prev_activation, token, data=None):
-        """Instantiate and persist new flow task."""
+    def create(
+        cls,
+        flow_task: Any,
+        prev_activation: "Activation",
+        token: Any,
+        data: Optional[Any] = None,
+        seed: Optional[Any] = None,
+    ) -> "Activation":
+        """
+        Instantiate and persist a new flow task.
+
+        Args:
+            flow_task (Any): The flow task instance.
+            prev_activation (Activation): The previous activation instance.
+            token (Any): The token for the new task.
+            data (Optional[Any]): Additional data for the new task.
+
+        Returns:
+            Activation: The newly created activation instance.
+        """
         flow_class = flow_task.flow_class
         task = flow_class.task_class(
             process=prev_activation.process,
             flow_task=flow_task,
             token=token,
             data=data if data is not None else {},
+            seed=seed,
         )
         task.save()
         task.previous.add(prev_activation.task)
         return cls(task)
 
     @status.transition(source=STATUS.NEW)
-    def activate(self):
+    def activate(self) -> None:
+        """Activate the task."""
         raise NotImplementedError(
             f"{self.__class__.__name__} class should override act() method"
         )
 
     @status.transition(source=STATUS.DONE)
-    def create_next(self):
+    def create_next(self) -> None:
+        """Create the next task in the flow."""
         raise NotImplementedError(
             f"{self.__class__.__name__} class should override create_next() method"
         )
 
     @status.transition(source=STATUS.NEW, target=STATUS.DONE)
-    def complete(self):
+    def complete(self) -> None:
+        """Complete the current task."""
         assert connection.in_atomic_block
         self.task.finished = now()
         self.task.save()
         task_finished.send(sender=self.flow_class, process=self.process, task=self.task)
 
-    def _activate_next(self, activations: set):
+    def _activate_next(self, activations: Set["Activation"]) -> None:
+        """Activate the next set of tasks."""
         while activations:
-            for current_activation in activations:
+            join_activations = {act for act in activations if act.type == "join"}
+            task_activations = activations - join_activations
+
+            if task_activations:
+                for current_activation in task_activations:
+                    if current_activation.activate.can_proceed():
+                        current_activation.activate()
+
+                    if current_activation.complete.can_proceed():
+                        current_activation.complete()
+
+                activations = {
+                    next_activation
+                    for current_activation in activations
+                    if current_activation.create_next.can_proceed()
+                    for next_activation in current_activation.create_next()
+                }
+                activations.update(join_activations)
+            elif join_activations:
+                # process first join activation
+                current_activation = join_activations.pop()
                 if current_activation.activate.can_proceed():
                     current_activation.activate()
 
                 if current_activation.complete.can_proceed():
                     current_activation.complete()
 
-            activations = {
-                next_activation
-                for current_activation in activations
-                if current_activation.create_next.can_proceed()
-                for next_activation in current_activation.create_next()
-            }
+                activations = set()
+                if current_activation.create_next.can_proceed():
+                    activations = {
+                        next_activation
+                        for next_activation in current_activation.create_next()
+                    }
+                activations.update(join_activations)
 
     @status.transition(source=STATUS.DONE)
-    def activate_next(self):
+    def activate_next(self) -> None:
+        """Activate the next task in the flow."""
         assert connection.in_atomic_block
         activations = set(self.create_next())
         self._activate_next(activations)
@@ -160,7 +251,8 @@ class Activation(object):
         conditions=[leading_tasks_canceled],
         permission=has_manage_permission,
     )
-    def undo(self):
+    def undo(self) -> None:
+        """Undo the current task."""
         self.task.finished = now()
         self.task.save()
 
@@ -169,7 +261,7 @@ class Activation(object):
         target=STATUS.REVIVED,
         permission=has_manage_permission,
     )
-    def revive(self):
+    def revive(self) -> Any:
         """
         Recreate and activate cancelled task
         """
@@ -188,7 +280,9 @@ class Activation(object):
         return task
 
     def get_outgoing_transitions(self) -> List[fsm.Transition]:
+        """Get the outgoing transitions for the current status."""
         return self.__class__.status.get_outgoing_transitions(self.status)
 
     def get_available_transitions(self, user) -> List[fsm.Transition]:
+        """Get the available transitions for the current status and user."""
         return self.__class__.status.get_available_transitions(self, self.status, user)