Renamed Job to DataConnection

Author: Ken Lippold

setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = hydroserverpy
-version = 1.7.0b2
+version = 1.7.0b3
 description = A Python client for managing HydroServer data
 long_description_content_type = text/markdown
 long_description = file: README.md

src/hydroserverpy/api/client.py

@@ -12,7 +12,7 @@
     SensorService,
     DatastreamService,
     OrchestrationSystemService,
-    JobService,
+    DataConnectionService,
     TaskService,
 )
 
@@ -191,10 +191,10 @@ def orchestrationsystems(self):
         return OrchestrationSystemService(self)
 
     @property
-    def jobs(self):
-        """Utilities for managing HydroServer ETL jobs."""
+    def dataconnections(self):
+        """Utilities for managing HydroServer ETL data connections."""
 
-        return JobService(self)
+        return DataConnectionService(self)
 
     @property
     def tasks(self):

src/hydroserverpy/api/models/__init__.py

@@ -13,7 +13,7 @@
 from .sta.thing import Thing
 from .sta.unit import Unit
 from .etl.orchestration_system import OrchestrationSystem
-from .etl.job import Job
+from .etl.data_connection import DataConnection
 from .etl.run import TaskRun
 from .etl.task import Task
 from .etl.mapping import TaskMapping

src/hydroserverpy/api/models/etl/__init__.py

@@ -1,12 +1,12 @@
 from .orchestration_system import OrchestrationSystem
-from .job import Job
+from .data_connection import DataConnection
 from .task import Task
 from .schedule import TaskSchedule
 from .run import TaskRun
 
 __all__ = [
     "OrchestrationSystem",
-    "Job",
+    "DataConnection",
     "Task",
     "TaskSchedule",
     "TaskRun"

src/hydroserverpy/api/models/etl/job.py …rverpy/api/models/etl/data_connection.pysrc/hydroserverpy/api/models/etl/job.py renamed to src/hydroserverpy/api/models/etl/data_connection.py src/hydroserverpy/api/models/etl/job.py renamed to src/hydroserverpy/api/models/etl/data_connection.py

@@ -1,17 +1,19 @@
 import uuid
-from typing import ClassVar, List, TYPE_CHECKING
-from pydantic import Field, AliasPath
+from typing import ClassVar, List, Optional, TYPE_CHECKING
+from pydantic import Field, AliasPath, AliasChoices
 from ..base import HydroServerBaseModel
 
 if TYPE_CHECKING:
     from hydroserverpy import HydroServer
     from hydroserverpy.api.models import Workspace, Task
 
 
-class Job(HydroServerBaseModel):
+class DataConnection(HydroServerBaseModel):
     name: str = Field(..., max_length=255)
-    job_type: str = Field(..., max_length=255, alias="type")
-    workspace_id: uuid.UUID
+    data_connection_type: str = Field(..., max_length=255, alias="type")
+    workspace_id: Optional[uuid.UUID] = Field(
+        None, validation_alias=AliasChoices("workspaceId", AliasPath("workspace", "id"))
+    )
     extractor_type: str = Field(..., max_length=255, validation_alias=AliasPath("extractor", "type"))
     extractor_settings: dict = Field(default_factory=dict, validation_alias=AliasPath("extractor", "settings"))
     transformer_type: str = Field(..., max_length=255, validation_alias=AliasPath("transformer", "type"))
@@ -21,7 +23,7 @@ class Job(HydroServerBaseModel):
 
     _editable_fields: ClassVar[set[str]] = {
         "name",
-        "job_type",
+        "data_connection_type",
         "extractor_type",
         "extractor_settings",
         "transformer_type",
@@ -31,18 +33,18 @@ class Job(HydroServerBaseModel):
     }
 
     def __init__(self, client: "HydroServer", **data):
-        super().__init__(client=client, service=client.jobs, **data)
+        super().__init__(client=client, service=client.dataconnections, **data)
 
         self._workspace = None
         self._tasks = None
 
     @classmethod
     def get_route(cls):
-        return "etl-jobs"
+        return "etl-data-connections"
 
     @property
     def workspace(self) -> "Workspace":
-        """The workspace this ETL job belongs to."""
+        """The workspace this ETL data connection belongs to."""
 
         if self._workspace is None and self.workspace_id:
             self._workspace = self.client.workspaces.get(uid=self.workspace_id)
@@ -51,11 +53,11 @@ def workspace(self) -> "Workspace":
 
     @property
     def tasks(self) -> List["Task"]:
-        """The ETL tasks associated with this ETL job."""
+        """The ETL tasks associated with this ETL data connection."""
 
         if self._tasks is None:
             self._tasks = self.client.tasks.list(
-                job=self.uid, fetch_all=True
+                data_connection=self.uid, fetch_all=True
             ).items
 
         return self._tasks

src/hydroserverpy/api/models/etl/orchestration_system.py

@@ -1,5 +1,5 @@
 import uuid
-from typing import ClassVar, List, TYPE_CHECKING
+from typing import ClassVar, List, Optional, TYPE_CHECKING
 from pydantic import Field
 from ..base import HydroServerBaseModel
 
@@ -11,7 +11,7 @@
 class OrchestrationSystem(HydroServerBaseModel):
     name: str = Field(..., max_length=255)
     orchestration_system_type: str = Field(..., max_length=255, alias="type")
-    workspace_id: uuid.UUID
+    workspace_id: Optional[uuid.UUID] = None
 
     _editable_fields: ClassVar[set[str]] = {"name", "orchestration_system_type"}
 

src/hydroserverpy/api/models/etl/task.py

@@ -1,14 +1,13 @@
 from __future__ import annotations
 from functools import cached_property
 import uuid
-from typing import ClassVar, TYPE_CHECKING, List, Optional
-from pydantic import Field
+from typing import ClassVar, TYPE_CHECKING, List, Optional, Literal, Union
+from datetime import datetime
+from pydantic import Field, AliasPath, AliasChoices
 from ..base import HydroServerBaseModel
 from .orchestration_system import OrchestrationSystem
-from .job import Job
-from .schedule import TaskSchedule
+from .data_connection import DataConnection
 from .run import TaskRun
-from .mapping import TaskMapping
 
 
 if TYPE_CHECKING:
@@ -21,21 +20,39 @@ class Task(HydroServerBaseModel):
     extractor_settings: dict = Field(default_factory=dict, alias="extractorSettings")
     transformer_settings: dict = Field(default_factory=dict, alias="transformerSettings")
     loader_settings: dict = Field(default_factory=dict, alias="loaderSettings")
-    job_id: uuid.UUID
-    orchestration_system_id: Optional[uuid.UUID] = None
-    workspace_id: uuid.UUID
-    schedule: Optional[TaskSchedule] = None
-    latest_run: TaskRun
-    mappings: List[TaskMapping]
+    data_connection_id: uuid.UUID = Field(
+        None, validation_alias=AliasChoices("dataConnectionId", AliasPath("dataConnection", "id"))
+    )
+    orchestration_system_id: uuid.UUID = Field(
+        None, validation_alias=AliasChoices("orchestrationSystemId", AliasPath("orchestrationSystem", "id"))
+    )
+    workspace_id: uuid.UUID = Field(
+        None, validation_alias=AliasChoices("workspaceId", AliasPath("workspace", "id"))
+    )
+    start_time: Optional[datetime] = Field(None, validation_alias=AliasPath("schedule", "startTime"))
+    next_run_at: Optional[datetime] = Field(None, validation_alias=AliasPath("schedule", "nextRunAt"))
+    paused: bool = Field(False, validation_alias=AliasPath("schedule", "paused"))
+    interval: Optional[int] = Field(None, gt=0, validation_alias=AliasPath("schedule", "interval"))
+    interval_period: Optional[Literal["minutes", "hours", "days"]] = Field(
+        None, validation_alias=AliasPath("schedule", "intervalPeriod")
+    )
+    crontab: Optional[str] = Field(None, validation_alias=AliasPath("schedule", "crontab"))
+    latest_run: Optional[TaskRun] = None
+    mappings: List[dict]
 
     _editable_fields: ClassVar[set[str]] = {
         "name",
         "extractor_settings",
         "transformer_settings",
         "loader_settings",
-        "job_id",
+        "data_connection_id",
         "orchestration_system_id",
-        "schedule",
+        "start_time",
+        "next_run_at",
+        "paused",
+        "interval",
+        "interval_period",
+        "crontab",
         "mappings"
     }
 
@@ -51,12 +68,91 @@ def workspace(self) -> Workspace:
         return self.client.workspaces.get(uid=self.workspace_id)
 
     @cached_property
-    def orchestration_system(self) -> OrchestrationSystem:
+    def orchestration_system(self) -> Optional[OrchestrationSystem]:
         return self.client.orchestrationsystems.get(uid=self.orchestration_system_id)
 
     @cached_property
-    def job(self) -> Job:
-        return self.client.jobs.get(uid=self.job_id)
+    def data_connection(self) -> Optional[DataConnection]:
+        return self.client.dataconnections.get(uid=self.data_connection_id)
+
+    def get_task_runs(
+        self,
+        page: int = ...,
+        page_size: int = 100,
+        order_by: List[str] = ...,
+        status: str = ...,
+        started_at_max: datetime = ...,
+        started_at_min: datetime = ...,
+        finished_at_max: datetime = ...,
+        finished_at_min: datetime = ...,
+    ):
+        """Get a collection of task runs associated with this task."""
+
+        return self.client.tasks.get_task_runs(
+            uid=self.uid,
+            page=page,
+            page_size=page_size,
+            order_by=order_by,
+            status=status,
+            started_at_max=started_at_max,
+            started_at_min=started_at_min,
+            finished_at_max=finished_at_max,
+            finished_at_min=finished_at_min,
+        )
+
+    def create_task_run(
+        self,
+        status: Literal["RUNNING", "SUCCESS", "FAILURE"],
+        started_at: datetime,
+        finished_at: datetime = ...,
+        result: dict = ...,
+    ):
+        """Create a new task run for this task."""
+
+        return self.client.tasks.create_task_run(
+            uid=self.uid,
+            status=status,
+            started_at=started_at,
+            finished_at=finished_at,
+            result=result,
+        )
+
+    def get_task_run(
+        self,
+        uid: Union[uuid.UUID, str],
+    ):
+        """Get a task run record for this task."""
+
+        return self.client.tasks.get_task_run(uid=self.uid, task_run_id=uid)
+
+    def update_task_run(
+        self,
+        uid: Union[uuid.UUID, str],
+        status: Literal["RUNNING", "SUCCESS", "FAILURE"] = ...,
+        started_at: datetime = ...,
+        finished_at: datetime = ...,
+        result: dict = ...,
+    ):
+        """Update a task run record of this task."""
+
+        return self.client.tasks.update_task_run(
+            uid=self.uid,
+            task_run_id=uid,
+            status=status,
+            started_at=started_at,
+            finished_at=finished_at,
+            result=result,
+        )
+
+    def delete_task_run(
+        self,
+        uid: Union[uuid.UUID, str],
+    ):
+        """Delete a task run record of this task."""
+
+        return self.client.tasks.delete_task_run(uid=self.uid, task_run_id=uid)
 
     def run(self):
-        """"""
+        """Run this task."""
+
+        return self.client.tasks.run(uid=self.uid)

src/hydroserverpy/api/models/iam/workspace.py

@@ -20,7 +20,7 @@
         Datastream,
         OrchestrationSystem,
         Task,
-        Job,
+        DataConnection,
     )
 
 
@@ -50,7 +50,7 @@ def __init__(self, client: "HydroServer", **data):
         self._sensors = None
         self._datastreams = None
         self._orchestrationsystems = None
-        self._jobs = None
+        self._dataconnections = None
         self._tasks = None
 
     @classmethod
@@ -166,13 +166,13 @@ def orchestrationsystems(self) -> List["OrchestrationSystem"]:
         return self._orchestrationsystems
 
     @property
-    def jobs(self) -> List["Job"]:
-        """The ETL jobs associated with this workspace."""
+    def dataconnections(self) -> List["DataConnection"]:
+        """The ETL data connections associated with this workspace."""
 
-        if self._jobs is None:
-            self._jobs = self.client.jobs.list(workspace=self.uid, fetch_all=True).items
+        if self._dataconnections is None:
+            self._dataconnections = self.client.dataconnections.list(workspace=self.uid, fetch_all=True).items
 
-        return self._jobs
+        return self._dataconnections
 
     @property
     def tasks(self) -> List["Task"]:

src/hydroserverpy/api/services/__init__.py

@@ -8,5 +8,5 @@
 from .sta.sensor import SensorService
 from .sta.datastream import DatastreamService
 from .etl.orchestration_system import OrchestrationSystemService
-from .etl.job import JobService
+from .etl.data_connection import DataConnectionService
 from .etl.task import TaskService