prefect-client 3.1.9__py3-none-any.whl → 3.1.11__py3-none-any.whl

prefect/tasks.py

@@ -74,7 +74,7 @@ if TYPE_CHECKING:
     from prefect.context import TaskRunContext
     from prefect.transactions import Transaction
 
-T = TypeVar("T")  # Generic type var for capturing the inner return type of async funcs
+T = TypeVar("T")
 R = TypeVar("R")  # The return type of the user's function
 P = ParamSpec("P")  # The parameters of the task
 
@@ -82,6 +82,11 @@ NUM_CHARS_DYNAMIC_KEY = 8
 
 logger = get_logger("tasks")
 
+FutureOrResult: TypeAlias = Union[PrefectFuture[T], T]
+OneOrManyFutureOrResult: TypeAlias = Union[
+    FutureOrResult[T], Iterable[FutureOrResult[T]]
+]
+
 
 def task_input_hash(
     context: "TaskRunContext", arguments: dict[str, Any]
@@ -737,7 +742,7 @@ class Task(Generic[P, R]):
         parameters: Optional[dict[str, Any]] = None,
         flow_run_context: Optional[FlowRunContext] = None,
         parent_task_run_context: Optional[TaskRunContext] = None,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         extra_task_inputs: Optional[dict[str, set[TaskRunInput]]] = None,
         deferred: bool = False,
     ) -> TaskRun:
@@ -838,7 +843,7 @@ class Task(Generic[P, R]):
         parameters: Optional[dict[str, Any]] = None,
         flow_run_context: Optional[FlowRunContext] = None,
         parent_task_run_context: Optional[TaskRunContext] = None,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         extra_task_inputs: Optional[dict[str, set[TaskRunInput]]] = None,
         deferred: bool = False,
     ) -> TaskRun:
@@ -952,6 +957,8 @@ class Task(Generic[P, R]):
     def __call__(
         self: "Task[P, NoReturn]",
         *args: P.args,
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
     ) -> None:
         # `NoReturn` matches if a type can't be inferred for the function which stops a
@@ -960,28 +967,41 @@ class Task(Generic[P, R]):
 
     @overload
     def __call__(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
+        return_state: Literal[True],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> T:
+    ) -> State[R]:
         ...
 
     @overload
     def __call__(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
-        return_state: Literal[True],
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> State[T]:
+    ) -> R:
         ...
 
+    @overload
     def __call__(
-        self,
+        self: "Task[P, R]",
+        *args: P.args,
+        return_state: Literal[False] = False,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
+        **kwargs: P.kwargs,
+    ) -> R:
+        ...
+
+    def __call__(
+        self: "Union[Task[P, R], Task[P, NoReturn]]",
         *args: P.args,
         return_state: bool = False,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ):
+    ) -> Union[R, State[R], None]:
         """
         Run the task and return the result. If `return_state` is True returns
         the result is wrapped in a Prefect State which provides error handling.
@@ -1013,53 +1033,57 @@ class Task(Generic[P, R]):
 
     @overload
     def submit(
-        self: "Task[P, NoReturn]",
+        self: "Task[P, R]",
         *args: P.args,
         **kwargs: P.kwargs,
-    ) -> PrefectFuture[NoReturn]:
-        # `NoReturn` matches if a type can't be inferred for the function which stops a
-        # sync function from matching the `Coroutine` overload
+    ) -> PrefectFuture[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, Coroutine[Any, Any, T]]",
+        self: "Task[P, Coroutine[Any, Any, R]]",
         *args: P.args,
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> PrefectFuture[T]:
+    ) -> PrefectFuture[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
+        return_state: Literal[False],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> PrefectFuture[T]:
+    ) -> PrefectFuture[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, Coroutine[Any, Any, T]]",
+        self: "Task[P, Coroutine[Any, Any, R]]",
         *args: P.args,
         return_state: Literal[True],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> State[T]:
+    ) -> State[R]:
         ...
 
     @overload
     def submit(
-        self: "Task[P, T]",
+        self: "Task[P, R]",
         *args: P.args,
         return_state: Literal[True],
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: P.kwargs,
-    ) -> State[T]:
+    ) -> State[R]:
         ...
 
     def submit(
-        self,
+        self: "Union[Task[P, R], Task[P, Coroutine[Any, Any, R]]]",
         *args: Any,
         return_state: bool = False,
-        wait_for: Optional[Iterable[PrefectFuture[R]]] = None,
+        wait_for: Optional[OneOrManyFutureOrResult[Any]] = None,
         **kwargs: Any,
     ):
         """
@@ -1584,11 +1608,39 @@ def task(__fn: Callable[P, R]) -> Task[P, R]:
 @overload
 def task(
     __fn: Literal[None] = None,
+    *,
+    name: Optional[str] = None,
+    description: Optional[str] = None,
+    tags: Optional[Iterable[str]] = None,
+    version: Optional[str] = None,
+    cache_policy: Union[CachePolicy, type[NotSet]] = NotSet,
+    cache_key_fn: Optional[
+        Callable[["TaskRunContext", dict[str, Any]], Optional[str]]
+    ] = None,
+    cache_expiration: Optional[datetime.timedelta] = None,
+    task_run_name: Optional[TaskRunNameValueOrCallable] = None,
+    retries: int = 0,
+    retry_delay_seconds: Union[
+        float, int, list[float], Callable[[int], list[float]], None
+    ] = None,
+    retry_jitter_factor: Optional[float] = None,
+    persist_result: Optional[bool] = None,
+    result_storage: Optional[ResultStorage] = None,
+    result_storage_key: Optional[str] = None,
+    result_serializer: Optional[ResultSerializer] = None,
+    cache_result_in_memory: bool = True,
+    timeout_seconds: Union[int, float, None] = None,
+    log_prints: Optional[bool] = None,
+    refresh_cache: Optional[bool] = None,
+    on_completion: Optional[list[StateHookCallable]] = None,
+    on_failure: Optional[list[StateHookCallable]] = None,
+    retry_condition_fn: Optional[Callable[[Task[P, Any], TaskRun, State], bool]] = None,
+    viz_return_value: Any = None,
 ) -> Callable[[Callable[P, R]], Task[P, R]]:
     ...
 
 
-@overload
+@overload  # TODO: do we need this overload?
 def task(
     *,
     name: Optional[str] = None,
@@ -1619,7 +1671,7 @@ def task(
     refresh_cache: Optional[bool] = None,
     on_completion: Optional[list[StateHookCallable]] = None,
     on_failure: Optional[list[StateHookCallable]] = None,
-    retry_condition_fn: Optional[Callable[["Task[P, R]", TaskRun, State], bool]] = None,
+    retry_condition_fn: Optional[Callable[[Task[P, Any], TaskRun, State], bool]] = None,
     viz_return_value: Any = None,
 ) -> Callable[[Callable[P, R]], Task[P, R]]:
     ...
@@ -1653,7 +1705,7 @@ def task(
     refresh_cache: Optional[bool] = None,
     on_completion: Optional[list[StateHookCallable]] = None,
     on_failure: Optional[list[StateHookCallable]] = None,
-    retry_condition_fn: Optional[Callable[["Task[P, R]", TaskRun, State], bool]] = None,
+    retry_condition_fn: Optional[Callable[[Task[P, Any], TaskRun, State], bool]] = None,
     viz_return_value: Any = None,
 ):
     """
@@ -1685,10 +1737,10 @@ def task(
             callable that, given the total number of retries, generates a list of retry
             delays. If a number of seconds, that delay will be applied to all retries.
             If a list, each retry will wait for the corresponding delay before retrying.
-            When passing a callable or a list, the number of configured retry delays
-            cannot exceed 50.
-        retry_jitter_factor: An optional factor that defines the factor to which a retry
-            can be jittered in order to avoid a "thundering herd".
+            When passing a callable or a list, the number of
+            configured retry delays cannot exceed 50.
+        retry_jitter_factor: An optional factor that defines the factor to which a
+            retry can be jittered in order to avoid a "thundering herd".
         persist_result: A toggle indicating whether the result of this task
             should be persisted to result storage. Defaults to `None`, which
             indicates that the global default should be used (which is `True` by

prefect/telemetry/processors.py

@@ -1,6 +1,6 @@
 import time
 from threading import Event, Lock, Thread
-from typing import TYPE_CHECKING, Dict, Optional
+from typing import TYPE_CHECKING, Optional
 
 from opentelemetry.context import Context
 from opentelemetry.sdk.trace import Span, SpanProcessor
@@ -13,7 +13,7 @@ if TYPE_CHECKING:
 class InFlightSpanProcessor(SpanProcessor):
     def __init__(self, span_exporter: "SpanExporter"):
         self.span_exporter = span_exporter
-        self._in_flight: Dict[int, Span] = {}
+        self._in_flight: dict[int, Span] = {}
         self._lock = Lock()
         self._stop_event = Event()
         self._export_thread = Thread(target=self._export_periodically, daemon=True)
@@ -30,10 +30,10 @@ class InFlightSpanProcessor(SpanProcessor):
                     self.span_exporter.export(to_export)
 
     def _readable_span(self, span: "Span") -> "ReadableSpan":
-        readable = span._readable_span()
-        readable._end_time = time.time_ns()
-        readable._attributes = {
-            **(readable._attributes or {}),
+        readable = span._readable_span()  # pyright: ignore[reportPrivateUsage]
+        readable._end_time = time.time_ns()  # pyright: ignore[reportPrivateUsage]
+        readable._attributes = {  # pyright: ignore[reportPrivateUsage]
+            **(readable._attributes or {}),  # pyright: ignore[reportPrivateUsage]
             "prefect.in-flight": True,
         }
         return readable

prefect/telemetry/run_telemetry.py

@@ -53,10 +53,9 @@ class RunTelemetry:
         self,
         run: FlowOrTaskRun,
         client: PrefectClient,
-        name: Optional[str] = None,
         parameters: Optional[dict[str, Any]] = None,
     ):
-        traceparent, span = self._start_span(run, name, parameters)
+        traceparent, span = self._start_span(run, parameters)
 
         if self._run_type(run) == "flow" and traceparent:
             # Only explicitly update labels if the run is a flow as task runs
@@ -71,10 +70,9 @@ class RunTelemetry:
         self,
         run: FlowOrTaskRun,
         client: SyncPrefectClient,
-        name: Optional[str] = None,
         parameters: Optional[dict[str, Any]] = None,
     ):
-        traceparent, span = self._start_span(run, name, parameters)
+        traceparent, span = self._start_span(run, parameters)
 
         if self._run_type(run) == "flow" and traceparent:
             # Only explicitly update labels if the run is a flow as task runs
@@ -86,7 +84,6 @@ class RunTelemetry:
     def _start_span(
         self,
         run: FlowOrTaskRun,
-        name: Optional[str] = None,
         parameters: Optional[dict[str, Any]] = None,
     ) -> tuple[Optional[str], Span]:
         """
@@ -117,10 +114,10 @@ class RunTelemetry:
         run_type = self._run_type(run)
 
         self.span = self._tracer.start_span(
-            name=name or run.name,
+            name=run.name,
             context=context,
             attributes={
-                "prefect.run.name": name or run.name,
+                "prefect.run.name": run.name,
                 "prefect.run.type": run_type,
                 "prefect.run.id": str(run.id),
                 "prefect.tags": run.tags,
@@ -152,7 +149,7 @@ class RunTelemetry:
         return propagate.extract(carrier)
 
     def _traceparent_from_span(self, span: Span) -> Optional[str]:
-        carrier = {}
+        carrier: dict[str, Any] = {}
         propagate.inject(carrier, context=trace.set_span_in_context(span))
         return carrier.get(TRACEPARENT_KEY)
 
@@ -198,6 +195,14 @@ class RunTelemetry:
                 },
             )
 
+    def update_run_name(self, name: str) -> None:
+        """
+        Update the name of the run.
+        """
+        if self.span:
+            self.span.update_name(name=name)
+            self.span.set_attribute("prefect.run.name", name)
+
     def _parent_run(self) -> Union[FlowOrTaskRun, None]:
         """
         Identify the "parent run" for the current execution context.

prefect/telemetry/services.py

@@ -1,32 +1,38 @@
-from abc import abstractmethod
-from typing import Union
+from collections.abc import Sequence
+from typing import Any, Protocol, TypeVar
 
 from opentelemetry.exporter.otlp.proto.http._log_exporter import OTLPLogExporter
 from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
 from opentelemetry.sdk._logs import LogData
 from opentelemetry.sdk._logs.export import LogExporter
 from opentelemetry.sdk.trace import ReadableSpan
-from opentelemetry.sdk.trace.export import SpanExporter
+from opentelemetry.sdk.trace.export import SpanExporter, SpanExportResult
 
 from prefect._internal.concurrency.services import BatchedQueueService
 
+BatchItem = TypeVar("BatchItem", ReadableSpan, LogData)
+T_contra = TypeVar("T_contra", contravariant=True)
 
-class BaseQueueingExporter(BatchedQueueService):
+
+class OTLPExporter(Protocol[T_contra]):
+    def export(self, __items: Sequence[T_contra]) -> Any:
+        ...
+
+    def shutdown(self) -> Any:
+        ...
+
+
+class BaseQueueingExporter(BatchedQueueService[BatchItem]):
     _max_batch_size = 512
     _min_interval = 2.0
-    _otlp_exporter: Union[SpanExporter, LogExporter]
-
-    def export(self, batch: list[Union[ReadableSpan, LogData]]) -> None:
-        for item in batch:
-            self.send(item)
 
-    @abstractmethod
-    def _export_batch(self, items: list[Union[ReadableSpan, LogData]]) -> None:
-        pass
+    def __init__(self, otlp_exporter: OTLPExporter[BatchItem]) -> None:
+        super().__init__()
+        self._otlp_exporter = otlp_exporter
 
-    async def _handle_batch(self, items: list[Union[ReadableSpan, LogData]]) -> None:
+    async def _handle_batch(self, items: list[BatchItem]) -> None:
         try:
-            self._export_batch(items)
+            self._otlp_exporter.export(items)
         except Exception as e:
             self._logger.exception(f"Failed to export batch: {e}")
             raise
@@ -39,29 +45,24 @@ class BaseQueueingExporter(BatchedQueueService):
         self._otlp_exporter.shutdown()
 
 
-class QueueingSpanExporter(BaseQueueingExporter, SpanExporter):
+class QueueingSpanExporter(BaseQueueingExporter[ReadableSpan], SpanExporter):
     _otlp_exporter: OTLPSpanExporter
 
     def __init__(self, endpoint: str, headers: tuple[tuple[str, str]]):
-        super().__init__()
-        self._otlp_exporter = OTLPSpanExporter(
-            endpoint=endpoint,
-            headers=dict(headers),
-        )
+        super().__init__(OTLPSpanExporter(endpoint=endpoint, headers=dict(headers)))
 
-    def _export_batch(self, items: list[ReadableSpan]) -> None:
-        self._otlp_exporter.export(items)
+    def export(self, spans: Sequence[ReadableSpan]) -> SpanExportResult:
+        for item in spans:
+            self.send(item)
+        return SpanExportResult.SUCCESS
 
 
-class QueueingLogExporter(BaseQueueingExporter, LogExporter):
+class QueueingLogExporter(BaseQueueingExporter[LogData], LogExporter):
     _otlp_exporter: OTLPLogExporter
 
-    def __init__(self, endpoint: str, headers: tuple[tuple[str, str]]):
-        super().__init__()
-        self._otlp_exporter = OTLPLogExporter(
-            endpoint=endpoint,
-            headers=dict(headers),
-        )
+    def __init__(self, endpoint: str, headers: tuple[tuple[str, str]]) -> None:
+        super().__init__(OTLPLogExporter(endpoint=endpoint, headers=dict(headers)))
 
-    def _export_batch(self, items: list[LogData]) -> None:
-        self._otlp_exporter.export(items)
+    def export(self, batch: Sequence[LogData]) -> None:
+        for item in batch:
+            self.send(item)

prefect/transactions.py

@@ -24,10 +24,7 @@ from prefect.exceptions import (
     SerializationError,
 )
 from prefect.logging.loggers import LoggingAdapter, get_logger, get_run_logger
-from prefect.records import RecordStore
-from prefect.records.base import TransactionRecord
 from prefect.results import (
-    BaseResult,
     ResultRecord,
     ResultStore,
     get_result_store,
@@ -61,7 +58,7 @@ class Transaction(ContextModel):
     A base model for transaction state.
     """
 
-    store: Union[RecordStore, ResultStore, None] = None
+    store: Optional[ResultStore] = None
     key: Optional[str] = None
     children: List["Transaction"] = Field(default_factory=list)
     commit_mode: Optional[CommitMode] = None
@@ -254,15 +251,11 @@ class Transaction(ContextModel):
         ):
             self.state = TransactionState.COMMITTED
 
-    def read(self) -> Union["BaseResult[Any]", ResultRecord[Any], None]:
+    def read(self) -> Optional[ResultRecord[Any]]:
         if self.store and self.key:
             record = self.store.read(key=self.key)
             if isinstance(record, ResultRecord):
                 return record
-            # for backwards compatibility, if we encounter a transaction record, return the result
-            # This happens when the transaction is using a `ResultStore`
-            if isinstance(record, TransactionRecord):
-                return record.result
         return None
 
     def reset(self) -> None:
@@ -315,11 +308,7 @@ class Transaction(ContextModel):
 
             if self.store and self.key and self.write_on_commit:
                 if isinstance(self.store, ResultStore):
-                    if isinstance(self._staged_value, BaseResult):
-                        self.store.write(
-                            key=self.key, obj=self._staged_value.get(_sync=True)
-                        )
-                    elif isinstance(self._staged_value, ResultRecord):
+                    if isinstance(self._staged_value, ResultRecord):
                         self.store.persist_result_record(
                             result_record=self._staged_value
                         )
@@ -436,7 +425,7 @@ def get_transaction() -> Optional[Transaction]:
 @contextmanager
 def transaction(
     key: Optional[str] = None,
-    store: Union[RecordStore, ResultStore, None] = None,
+    store: Optional[ResultStore] = None,
     commit_mode: Optional[CommitMode] = None,
     isolation_level: Optional[IsolationLevel] = None,
     overwrite: bool = False,

prefect/utilities/_git.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+import subprocess
+import sys
+
+
+def get_git_remote_origin_url() -> str | None:
+    """
+    Returns the git remote origin URL for the current directory.
+    """
+    try:
+        origin_url = subprocess.check_output(
+            ["git", "config", "--get", "remote.origin.url"],
+            shell=sys.platform == "win32",
+            stderr=subprocess.DEVNULL,
+        )
+        origin_url = origin_url.decode().strip()
+    except subprocess.CalledProcessError:
+        return None
+
+    return origin_url
+
+
+def get_git_branch() -> str | None:
+    """
+    Returns the git branch for the current directory.
+    """
+    try:
+        branch = subprocess.check_output(["git", "rev-parse", "--abbrev-ref", "HEAD"])
+        branch = branch.decode().strip()
+    except subprocess.CalledProcessError:
+        return None
+
+    return branch

prefect/utilities/asyncutils.py

@@ -77,7 +77,7 @@ def get_thread_limiter() -> anyio.CapacityLimiter:
 
 def is_async_fn(
     func: _SyncOrAsyncCallable[P, R],
-) -> TypeGuard[Callable[P, Awaitable[R]]]:
+) -> TypeGuard[Callable[P, Coroutine[Any, Any, Any]]]:
     """
     Returns `True` if a function returns a coroutine.
 

prefect/utilities/engine.py

@@ -45,7 +45,7 @@ from prefect.exceptions import (
 from prefect.flows import Flow
 from prefect.futures import PrefectFuture
 from prefect.logging.loggers import get_logger
-from prefect.results import BaseResult, ResultRecord, should_persist_result
+from prefect.results import ResultRecord, should_persist_result
 from prefect.settings import PREFECT_LOGGING_LOG_PRINTS
 from prefect.states import State
 from prefect.tasks import Task
@@ -283,10 +283,6 @@ async def resolve_inputs(
     return resolved_parameters
 
 
-def _is_base_result(data: Any) -> TypeIs[BaseResult[Any]]:
-    return isinstance(data, BaseResult)
-
-
 def _is_result_record(data: Any) -> TypeIs[ResultRecord[Any]]:
     return isinstance(data, ResultRecord)
 
@@ -335,11 +331,7 @@ async def propose_state(
     # Handle task and sub-flow tracing
     if state.is_final():
         result: Any
-        if _is_base_result(state.data) and state.data.has_cached_object():
-            # Avoid fetching the result unless it is cached, otherwise we defeat
-            # the purpose of disabling `cache_result_in_memory`
-            result = state.result(raise_on_failure=False, fetch=True)
-        elif _is_result_record(state.data):
+        if _is_result_record(state.data):
             result = state.data.result
         else:
             result = state.data
@@ -451,13 +443,7 @@ def propose_state_sync(
 
     # Handle task and sub-flow tracing
     if state.is_final():
-        if _is_base_result(state.data) and state.data.has_cached_object():
-            # Avoid fetching the result unless it is cached, otherwise we defeat
-            # the purpose of disabling `cache_result_in_memory`
-            result = state.result(raise_on_failure=False, fetch=True)
-            if asyncio.iscoroutine(result):
-                result = run_coro_as_sync(result)
-        elif _is_result_record(state.data):
+        if _is_result_record(state.data):
             result = state.data.result
         else:
             result = state.data
@@ -636,8 +622,6 @@ def emit_task_run_state_change_event(
 
     if _is_result_record(validated_state.data) and should_persist_result():
         data = validated_state.data.metadata.model_dump(mode="json")
-    elif _is_base_result(validated_state.data):
-        data = validated_state.data.model_dump(mode="json")
     else:
         data = None
 

prefect/utilities/generics.py

@@ -0,0 +1,18 @@
+from typing import Any, TypeVar
+
+from pydantic import BaseModel
+from pydantic_core import SchemaValidator, core_schema
+
+T = TypeVar("T", bound=BaseModel)
+
+ListValidator = SchemaValidator(
+    schema=core_schema.list_schema(
+        items_schema=core_schema.dict_schema(
+            keys_schema=core_schema.str_schema(), values_schema=core_schema.any_schema()
+        )
+    )
+)
+
+
+def validate_list(model: type[T], input: Any) -> list[T]:
+    return [model.model_validate(item) for item in ListValidator.validate_python(input)]

prefect/workers/__init__.py

@@ -1 +1,3 @@
 from .process import ProcessWorker
+
+__all__ = ["ProcessWorker"]

{prefect_client-3.1.9.dist-info → prefect_client-3.1.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: prefect-client
-Version: 3.1.9
+Version: 3.1.11
 Summary: Workflow orchestration and management.
 Home-page: https://www.prefect.io
 Author: Prefect Technologies, Inc.