kestrapy 2.1.0.dev514__tar.gz → 2.1.0.dev541__tar.gz

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kestrapy
-Version: 2.1.0.dev514
+Version: 2.1.0.dev541
 Summary: Kestra EE
 Home-page: https://github.com/kestra-io/client-sdk
 Author: Kestra

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/kestrapy/__init__.py

@@ -9,7 +9,7 @@
 """  # noqa: E501
 
 
-__version__ = "2.1.0.dev514"
+__version__ = "2.1.0.dev541"
 
 # Define package exports
 __all__ = [

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/kestrapy/api/flows_api.py

@@ -342,9 +342,30 @@ class FlowsApi(BaseApi):
     # Concurrency
     # ========================================================================
 
-    def search_concurrency_limits(self, tenant: str) -> PagedResultsConcurrencyLimit:
+    def search_concurrency_limits(
+        self,
+        tenant: str,
+        page: Optional[int] = None,
+        size: Optional[int] = None,
+    ) -> PagedResultsConcurrencyLimit:
+        """Search for the flow, namespace and tenant concurrency limits of a tenant.
+
+        Each result carries the number of ``running`` and ``queued`` executions. A
+        namespace limit has an empty ``flow_id``, the tenant limit an empty
+        ``namespace`` and ``flow_id``.
+        """
         path = self._tenant_path(tenant, "concurrency-limit", "search")
-        return self._json_request("GET", path, PagedResultsConcurrencyLimit)
+        params = self._build_query_params(page=page, size=size)
+        return self._json_request("GET", path, PagedResultsConcurrencyLimit, params=params)
+
+    def concurrency_limit(self, namespace: str, flow_id: str, tenant: str) -> ConcurrencyLimit:
+        """Get the concurrency limit of a flow.
+
+        The server answers 404 until the counter exists, which happens once the
+        flow (declaring a concurrency limit) has run.
+        """
+        path = self._tenant_path(tenant, "concurrency-limit", namespace, flow_id)
+        return self._json_request("GET", path, ConcurrencyLimit)
 
     def update_concurrency_limit(
         self,
@@ -353,8 +374,17 @@ class FlowsApi(BaseApi):
         tenant: str,
         concurrency_limit: ConcurrencyLimit,
     ) -> ConcurrencyLimit:
-        path = self._tenant_path(tenant, "concurrency-limit", namespace, flow_id)
-        return self._json_request("PUT", path, ConcurrencyLimit, body=concurrency_limit)
+        """Set the running-execution counter of a concurrency limit to ``concurrency_limit.running``.
+
+        Pass an empty ``flow_id`` to target a namespace limit, and an empty
+        ``namespace`` and ``flow_id`` for the tenant limit. Only ``running`` is read
+        from ``concurrency_limit``. The limit must already exist, otherwise the
+        server answers 404.
+        """
+        # Since Kestra 2.1 the namespace and flow are sent in the body, not the path.
+        path = self._tenant_path(tenant, "concurrency-limit")
+        body = {"namespace": namespace, "flowId": flow_id, "running": concurrency_limit.running}
+        return self._json_request("PUT", path, ConcurrencyLimit, body=body)
 
     # ========================================================================
     # Validation

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/kestrapy/api/reusable_inputs_api.py

@@ -15,9 +15,12 @@ class ReusableInputsApi(BaseApi):
         tenant: str,
         page: Optional[int] = None,
         size: Optional[int] = None,
+        allow_draft: Optional[bool] = None,
     ) -> PagedResultsReusableInputsWithSource:
+        """Lists the blocks visible from a namespace, including those inherited from parent namespaces. Without
+        ``allow_draft``, only the blocks an execution can use are listed, each as the revision it would run."""
         path = self._tenant_path(tenant, "namespaces", namespace, "reusable-inputs")
-        params = self._build_query_params(page=page, size=size)
+        params = self._build_query_params(page=page, size=size, allowDraft=allow_draft)
         return self._json_request("GET", path, PagedResultsReusableInputsWithSource, params=params)
 
     def reusable_inputs(
@@ -26,9 +29,13 @@ class ReusableInputsApi(BaseApi):
         id: str,
         tenant: str,
         revision: Optional[int] = None,
+        allow_draft: Optional[bool] = None,
     ) -> ReusableInputsWithSource:
+        """Retrieves a block, resolving namespace inheritance. Without ``allow_draft``, the revision an execution
+        would use is returned: the latest that isn't a draft, unless ``revision`` is set; a block with only
+        drafts fails with a 422."""
         path = self._tenant_path(tenant, "namespaces", namespace, "reusable-inputs", id)
-        params = self._build_query_params(revision=revision)
+        params = self._build_query_params(revision=revision, allowDraft=allow_draft)
         return self._json_request("GET", path, ReusableInputsWithSource, params=params)
 
     def list_reusable_inputs_revisions(self, namespace: str, id: str, tenant: str) -> List[ReusableInputsWithSource]:
@@ -42,9 +49,12 @@ class ReusableInputsApi(BaseApi):
         tenant: str,
         body: str,
         fail_if_exists: Optional[bool] = None,
+        draft: Optional[bool] = None,
     ) -> ReusableInputsWithSource:
+        """Creates or updates a block from its YAML source. With ``draft``, the revision is saved as a draft,
+        which executions skip and which may be invalid."""
         path = self._tenant_path(tenant, "namespaces", namespace, "reusable-inputs", id)
-        params = self._build_query_params(failIfExists=fail_if_exists)
+        params = self._build_query_params(failIfExists=fail_if_exists, draft=draft)
         return self._json_request("PUT", path, ReusableInputsWithSource, params=params, body=body, content_type=self.YAML)
 
     def delete_reusable_inputs(self, namespace: str, id: str, tenant: str) -> None:

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/kestrapy/configuration.py

@@ -530,7 +530,7 @@ conf = kestrapy.Configuration(
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 2.0.0-SNAPSHOT\n"\
-               "SDK Package Version: 2.1.0.dev514".\
+               "SDK Package Version: 2.1.0.dev541".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]:

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/kestrapy/models/concurrency_limit.py

@@ -25,8 +25,9 @@ class ConcurrencyLimit(BaseModel):
     namespace: StrictStr
     flow_id: StrictStr = Field(alias="flowId")
     running: Optional[StrictInt] = None
+    queued: Optional[StrictInt] = Field(default=None, description="Number of queued executions; only set on the results of search_concurrency_limits.")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["tenantId", "namespace", "flowId", "running"]
+    __properties: ClassVar[List[str]] = ["tenantId", "namespace", "flowId", "running", "queued"]
 
     model_config = ConfigDict(
         populate_by_name=True,
@@ -89,7 +90,8 @@ class ConcurrencyLimit(BaseModel):
             "tenantId": obj.get("tenantId"),
             "namespace": obj.get("namespace"),
             "flowId": obj.get("flowId"),
-            "running": obj.get("running")
+            "running": obj.get("running"),
+            "queued": obj.get("queued")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/kestrapy/models/reusable_inputs_with_source.py

@@ -34,8 +34,10 @@ class ReusableInputsWithSource(BaseModel):
     updated: Optional[datetime] = None
     deleted: Optional[StrictBool] = None
     source: Optional[StrictStr] = None
+    draft: Optional[StrictBool] = Field(default=None, description="Executions skip draft revisions and use the latest revision that isn't a draft, unless a revision is set explicitly.")
+    updated_by: Optional[StrictStr] = Field(default=None, alias="updatedBy")
     additional_properties: Dict[str, Any] = {}
-    __properties: ClassVar[List[str]] = ["namespace", "id", "description", "inputs", "revision", "last", "created", "updated", "deleted", "source"]
+    __properties: ClassVar[List[str]] = ["namespace", "id", "description", "inputs", "revision", "last", "created", "updated", "deleted", "source", "draft", "updatedBy"]
 
     @field_validator('id')
     def id_validate_regular_expression(cls, value):
@@ -107,6 +109,11 @@ class ReusableInputsWithSource(BaseModel):
         if self.updated is None and "updated" in self.model_fields_set:
             _dict['updated'] = None
 
+        # set to None if updated_by (nullable) is None
+        # and model_fields_set contains the field
+        if self.updated_by is None and "updated_by" in self.model_fields_set:
+            _dict['updatedBy'] = None
+
         return _dict
 
     @classmethod
@@ -128,7 +135,9 @@ class ReusableInputsWithSource(BaseModel):
             "created": obj.get("created"),
             "updated": obj.get("updated"),
             "deleted": obj.get("deleted"),
-            "source": obj.get("source")
+            "source": obj.get("source"),
+            "draft": obj.get("draft"),
+            "updatedBy": obj.get("updatedBy")
         })
         # store additional fields in additional_properties
         for _key in obj.keys():

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/kestrapy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: kestrapy
-Version: 2.1.0.dev514
+Version: 2.1.0.dev541
 Summary: Kestra EE
 Home-page: https://github.com/kestra-io/client-sdk
 Author: Kestra

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/pyproject.toml

@@ -1,6 +1,6 @@
     [project]
 name = "kestrapy"
-version = "2.1.0.dev514"
+version = "2.1.0.dev541"
 description = "Kestra EE"
     authors = [
     {name = "Kestra",email = "hello@kestra.io"},

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/setup.py

@@ -19,7 +19,7 @@ from setuptools import setup, find_packages  # noqa: H301
 # prerequisite: setuptools
 # http://pypi.python.org/pypi/setuptools
 NAME = "kestrapy"
-VERSION = "2.1.0.dev514"
+VERSION = "2.1.0.dev541"
 PYTHON_REQUIRES = ">= 3.9"
 REQUIRES = [
 "requests (>= 2.32.5)",

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/testApis/test_flows_api.py

@@ -12,6 +12,7 @@ from kestrapy import (
     QueryFilter,
     QueryFilterField,
     QueryFilterOp,
+    StateType,
 )
 from test_helpers import (
     TENANT,
@@ -21,9 +22,9 @@ from test_helpers import (
     log_flow_yaml_with_description,
     log_flow_yaml_with_labels,
     two_task_flow_yaml,
-    concurrency_flow_yaml,
     invalid_task_flow_yaml,
     create_flow,
+    create_execution,
     create_log_flow,
     simple_flow_fixture,
     complete_flow_body,
@@ -1040,38 +1041,77 @@ class TestTaskFromFlow:
 # ========================================================================
 
 
-class TestConcurrency:
-    def test_search_concurrency_limits(self, client):
-        result = client.flows.search_concurrency_limits(TENANT)
+def _sleep_concurrency_flow_yaml(flow_id, namespace):
+    return f"""\
+id: {flow_id}
+namespace: {namespace}
+concurrency:
+  behavior: QUEUE
+  limit: 1
+tasks:
+  - id: wait
+    type: io.kestra.plugin.core.flow.Sleep
+    duration: PT10S
+"""
+
+
+def _start_execution_in_state(client, namespace, flow_id, expected, timeout=30):
+    execution_id = create_execution(client, namespace, flow_id).id
+    deadline = time.time() + timeout
+    while time.time() < deadline:
+        execution = client.executions.execution(execution_id, TENANT)
+        if execution.state is not None and execution.state.current == expected:
+            return execution_id
+        time.sleep(0.2)
+    raise TimeoutError(f"Execution {execution_id} did not reach {expected} within {timeout}s")
 
-        assert result is not None
-        assert result.results is not None
 
-    @pytest.mark.skip(reason="Concurrency limit PUT returns 404 on this kestra-ee image")
-    def test_update_concurrency_limit_set(self, client):
+# A concurrency-limit counter only exists once a flow declaring `concurrency` has run,
+# so these tests start one execution (running) and, for search, a second one queued
+# behind limit 1.
+class TestConcurrency:
+    def test_search_concurrency_limits_running_and_queued(self, client):
+        fid = random_id()
+        ns = random_namespace()
+        create_flow(client, _sleep_concurrency_flow_yaml(fid, ns))
+        _start_execution_in_state(client, ns, fid, StateType.RUNNING)
+        _start_execution_in_state(client, ns, fid, StateType.QUEUED)
+
+        found = None
+        deadline = time.time() + 10
+        while found is None and time.time() < deadline:
+            result = client.flows.search_concurrency_limits(TENANT, page=1, size=1000)
+            found = next((l for l in result.results if l.namespace == ns and l.flow_id == fid), None)
+            if found is None:
+                time.sleep(0.2)
+
+        assert found is not None
+        assert found.running == 1
+        assert found.queued == 1
+
+    def test_update_concurrency_limit_resets_running(self, client):
         fid = random_id()
         ns = random_namespace()
-        create_flow(client, concurrency_flow_yaml(fid, ns, 1))
+        create_flow(client, _sleep_concurrency_flow_yaml(fid, ns))
+        _start_execution_in_state(client, ns, fid, StateType.RUNNING)
 
-        limit = ConcurrencyLimit(tenant_id=TENANT, namespace=ns, flow_id=fid, running=5)
+        assert client.flows.concurrency_limit(ns, fid, TENANT).running == 1
 
+        limit = ConcurrencyLimit(tenant_id=TENANT, namespace=ns, flow_id=fid, running=0)
         result = client.flows.update_concurrency_limit(ns, fid, TENANT, limit)
 
-        assert result is not None
         assert result.namespace == ns
         assert result.flow_id == fid
+        assert result.running == 0
 
-    @pytest.mark.skip(reason="Concurrency limit PUT returns 404 on this kestra-ee image")
-    def test_update_concurrency_limit_update(self, client):
+    def test_update_concurrency_limit_unknown_is_404(self, client):
         fid = random_id()
         ns = random_namespace()
-        create_flow(client, concurrency_flow_yaml(fid, ns, 3))
-
-        limit = ConcurrencyLimit(tenant_id=TENANT, namespace=ns, flow_id=fid, running=10)
-        result = client.flows.update_concurrency_limit(ns, fid, TENANT, limit)
+        limit = ConcurrencyLimit(tenant_id=TENANT, namespace=ns, flow_id=fid, running=0)
 
-        assert result is not None
-        assert result.flow_id == fid
+        with pytest.raises(ApiException) as exc:
+            client.flows.update_concurrency_limit(ns, fid, TENANT, limit)
+        assert exc.value.status == 404
 
 
 # ========================================================================

{kestrapy-2.1.0.dev514 → kestrapy-2.1.0.dev541}/testApis/test_reusable_inputs_api.py

@@ -1,7 +1,7 @@
 import pytest
 
 from test_helpers import TENANT, random_id, random_namespace, register_namespace
-from kestrapy.exceptions import ConflictException, NotFoundException
+from kestrapy.exceptions import ConflictException, NotFoundException, UnprocessableEntityException
 
 
 def reusable_inputs_source(namespace, block_id, description="shared inputs"):
@@ -18,9 +18,9 @@ def reusable_inputs_source(namespace, block_id, description="shared inputs"):
     )
 
 
-def create_block(client, namespace, block_id, **kwargs):
+def create_block(client, namespace, block_id, draft=None, **kwargs):
     return client.reusable_inputs.create_or_update_reusable_inputs(
-        namespace, block_id, TENANT, reusable_inputs_source(namespace, block_id, **kwargs)
+        namespace, block_id, TENANT, reusable_inputs_source(namespace, block_id, **kwargs), draft=draft
     )
 
 
@@ -61,6 +61,56 @@ def test_reusable_inputs(client):
     assert len(found.inputs) == 2
 
 
+def test_create_or_update_reusable_inputs_draft(client):
+    namespace, block_id = random_namespace(), random_id()
+    published = create_block(client, namespace, block_id)
+
+    draft = create_block(client, namespace, block_id, draft=True, description="in progress")
+
+    assert published.draft is False
+    assert published.updated_by
+    assert draft.draft is True
+    assert draft.revision == 2
+    assert draft.updated_by == published.updated_by
+
+
+def test_reusable_inputs_skips_drafts_unless_allowed(client):
+    namespace, block_id = random_namespace(), random_id()
+    create_block(client, namespace, block_id)
+    create_block(client, namespace, block_id, draft=True, description="in progress")
+
+    for_execution = client.reusable_inputs.reusable_inputs(namespace, block_id, TENANT)
+    assert for_execution.revision == 1
+    assert for_execution.draft is False
+
+    latest = client.reusable_inputs.reusable_inputs(namespace, block_id, TENANT, allow_draft=True)
+    assert latest.revision == 2
+    assert latest.draft is True
+    assert latest.description == "in progress"
+
+
+def test_reusable_inputs_drafts_only(client):
+    namespace, block_id = random_namespace(), random_id()
+    create_block(client, namespace, block_id, draft=True)
+
+    with pytest.raises(UnprocessableEntityException):
+        client.reusable_inputs.reusable_inputs(namespace, block_id, TENANT)
+    assert client.reusable_inputs.reusable_inputs(namespace, block_id, TENANT, allow_draft=True).draft is True
+
+
+def test_list_reusable_inputs_excludes_drafts_only_unless_allowed(client):
+    namespace, published, drafts_only = random_namespace(), random_id(), random_id()
+    create_block(client, namespace, published)
+    create_block(client, namespace, published, draft=True, description="in progress")
+    create_block(client, namespace, drafts_only, draft=True)
+
+    for_execution = client.reusable_inputs.list_reusable_inputs(namespace, TENANT)
+    assert [(b.id, b.revision) for b in for_execution.results] == [(published, 1)]
+
+    with_drafts = client.reusable_inputs.list_reusable_inputs(namespace, TENANT, allow_draft=True)
+    assert sorted((b.id, b.draft) for b in with_drafts.results) == sorted([(published, True), (drafts_only, True)])
+
+
 def test_reusable_inputs_resolves_namespace_inheritance(client):
     parent = random_namespace()
     child = register_namespace(f"{parent}.child")