divi 0.0.1.dev21__py3-none-any.whl → 0.0.1.dev28__py3-none-any.whl

divi/__init__.py

@@ -2,6 +2,7 @@ from typing import Optional
 
 from . import proto
 from .decorators import obs_openai, observable
+from .evaluation import Evaluator, Score
 from .services import Auth, Core, DataPark
 from .session import Session
 
@@ -11,6 +12,7 @@ _session: Optional[Session] = None
 _core: Optional[Core] = None
 _auth: Optional[Auth] = None
 _datapark: Optional[DataPark] = None
+_evaluator: Optional[Evaluator] = None
 
-__version__ = "0.0.1.dev21"
-__all__ = ["proto", "obs_openai", "observable"]
+__version__ = "0.0.1.dev28"
+__all__ = ["proto", "obs_openai", "observable", "Score"]

divi/decorators/obs_openai.py

@@ -2,7 +2,10 @@ import functools
 from collections.abc import Callable
 from typing import TYPE_CHECKING, TypeVar, Union
 
+from typing_extensions import Optional
+
 from divi.decorators.observable import observable
+from divi.evaluation.scores import Score
 from divi.utils import is_async
 
 if TYPE_CHECKING:
@@ -11,23 +14,34 @@ if TYPE_CHECKING:
 C = TypeVar("C", bound=Union["OpenAI", "AsyncOpenAI"])
 
 
-def _get_observable_create(create: Callable) -> Callable:
+def _get_observable_create(
+    create: Callable,
+    name: Optional[str] = None,
+    scores: Optional[list[Score]] = None,
+) -> Callable:
     @functools.wraps(create)
     def observable_create(*args, stream: bool = False, **kwargs):
-        decorator = observable(kind="llm")
+        decorator = observable(kind="llm", name=name, scores=scores)
         return decorator(create)(*args, stream=stream, **kwargs)
 
     # TODO Async Observable Create
-    print("Is async", is_async(create))
     return observable_create if not is_async(create) else create
 
 
-def obs_openai(client: C) -> C:
+def obs_openai(
+    client: C,
+    name: Optional[str] = "Chat Bot",
+    scores: Optional[list[Score]] = None,
+) -> C:
     """Make OpenAI client observable."""
     client.chat.completions.create = _get_observable_create(
-        client.chat.completions.create
+        client.chat.completions.create,
+        name=name,
+        scores=scores,
     )
     client.completions.create = _get_observable_create(
-        client.completions.create
+        client.completions.create,
+        name=name,
+        scores=scores,
     )
     return client

divi/decorators/observable.py

@@ -1,11 +1,9 @@
 import contextvars
 import functools
-import inspect
 from typing import (
     Any,
     Callable,
     Generic,
-    List,
     Mapping,
     Optional,
     ParamSpec,
@@ -19,6 +17,8 @@ from typing import (
 from openai.types.chat import ChatCompletion
 
 import divi
+from divi.evaluation.evaluate import evaluate_scores
+from divi.evaluation.scores import Score
 from divi.proto.trace.v1.trace_pb2 import ScopeSpans
 from divi.session import SessionExtra
 from divi.session.setup import setup
@@ -54,6 +54,7 @@ def observable(
     kind: str = "function",
     *,
     name: Optional[str] = None,
+    scores: Optional[list[Score]] = None,
     metadata: Optional[Mapping[str, Any]] = None,
 ) -> Callable[[Callable[P, R]], WithSessionExtra[P, R]]: ...
 
@@ -66,6 +67,7 @@ def observable(
     kind = kwargs.pop("kind", "function")
     name = kwargs.pop("name", None)
     metadata = kwargs.pop("metadata", None)
+    scores: list[Score] = kwargs.pop("scores", None)
 
     def decorator(func):
         @functools.wraps(func)
@@ -85,7 +87,11 @@ def observable(
             # recover parent context
             _SESSION_EXTRA.reset(token)
 
-            # TODO: collect inputs and outputs
+            # get the trace to collect data
+            trace = session_extra.get("trace")
+            if not trace:
+                raise ValueError("Trace not found in session context.")
+            # TODO: collect inputs and outputs for SPAN_KIND_FUNCTION
             inputs = extract_flattened_inputs(func, *args, **kwargs)
             # create the span if it is the root span
             if divi._datapark and span.trace_id:
@@ -94,43 +100,21 @@ def observable(
                 )
             # end the trace if it is the root span
             if divi._datapark and not span.parent_span_id:
-                trace = session_extra.get("trace")
-                if trace:
-                    trace.end()
-                    divi._datapark.upsert_traces(
-                        session_id=trace.session_id, traces=[trace.signal]
-                    )
+                trace.end()
             # create the chat completion if it is a chat completion
             if divi._datapark and isinstance(result, ChatCompletion):
                 divi._datapark.create_chat_completion(
-                    span_id=span.span_id, inputs=inputs, completion=result
+                    span_id=span.span_id,
+                    trace_id=trace.trace_id,
+                    inputs=inputs,
+                    completion=result,
                 )
-            return result
+                # evaluate the scores if they are provided
+                if scores is not None and scores.__len__() > 0:
+                    evaluate_scores(inputs, outputs=result, scores=scores)
 
-        @functools.wraps(func)
-        def generator_wrapper(
-            *args, session_extra: Optional[SessionExtra] = None, **kwargs
-        ):
-            span = Span(
-                kind=kind, name=name or func.__name__, metadata=metadata
-            )
-            session_extra = setup(span, _SESSION_EXTRA.get() or session_extra)
-            # set current context
-            token = _SESSION_EXTRA.set(session_extra)
-            # execute the function
-            results: List[Any] = []
-            span.start()
-            for item in func(*args, **kwargs):
-                results.append(item)
-                yield item
-            span.end()
-
-            # recover parent context
-            _SESSION_EXTRA.reset(token)
-            # TODO: collect results
+            return result
 
-        if inspect.isgeneratorfunction(func):
-            return generator_wrapper
         return wrapper
 
     # Function Decorator

divi/evaluation/__init__.py

@@ -0,0 +1,4 @@
+from .evaluator import Evaluator
+from .scores import Score
+
+__all__ = ["Evaluator", "Score"]

divi/evaluation/evaluate.py

@@ -0,0 +1,57 @@
+import copy
+import os
+from typing import Any, Dict, Optional
+
+from openai.types.chat import ChatCompletion
+from typing_extensions import List
+
+import divi
+from divi.evaluation import Evaluator
+from divi.evaluation.evaluator import EvaluatorConfig
+from divi.evaluation.scores import Score
+
+OPENAI_API_KEY = "OPENAI_API_KEY"
+OPENAI_BASE_URL = "OPENAI_BASE_URL"
+
+
+def init_evaluator(config: Optional[EvaluatorConfig] = None):
+    _config = config or EvaluatorConfig()
+    api_key = _config.api_key if _config.api_key else os.getenv(OPENAI_API_KEY)
+    base_url = (
+        _config.base_url if _config.base_url else os.getenv(OPENAI_BASE_URL)
+    )
+    if api_key is None:
+        raise ValueError("API key is required for evaluator")
+    _config.api_key = api_key
+    _config.base_url = base_url
+    evaluator = Evaluator(_config)
+    return evaluator
+
+
+def evaluate_scores(
+    inputs: Dict[str, Any],
+    outputs: ChatCompletion,
+    scores: List[Score],
+    config: Optional[EvaluatorConfig] = None,
+):
+    if not divi._evaluator:
+        divi._evaluator = init_evaluator(config)
+
+    # create conversation with result and inputs
+    input_messages = inputs.get("messages", None)
+    if input_messages is None:
+        raise ValueError("No messages found in inputs")
+    output_message = outputs.choices[0].message
+    if output_message is None:
+        raise ValueError("No message found in outputs")
+
+    conversations = copy.deepcopy(input_messages)
+    conversations.append(
+        {"role": output_message.role, "content": output_message.content}
+    )
+    evaluation_scores = divi._evaluator.evaluate(
+        "\n".join(f"{m['role']}: {m['content']}" for m in conversations), scores
+    )
+
+    # TODO: collect all evaluation scores and link them to span
+    print(evaluation_scores)

divi/evaluation/evaluator.py

@@ -0,0 +1,161 @@
+import asyncio
+import concurrent.futures
+import random
+from typing import List, Literal, Optional
+
+import openai
+from pydantic import BaseModel
+
+from divi.evaluation.prompts import PRESET_PROMPT, PROMPT_TEMPLATE
+from divi.evaluation.scores import Score
+
+
+class EvaluatorConfig:
+    def __init__(
+        self,
+        model: str = "gpt-4.1-nano",
+        temperature: float = 0.5,
+        max_concurrency: int = 10,
+        api_key: Optional[str] = None,
+        base_url: Optional[str] = None,
+    ):
+        self.model = model
+        self.api_key = api_key
+        self.base_url = base_url
+        self.temperature = temperature
+        self.max_concurrency = max_concurrency
+
+
+class EvaluationResult(BaseModel):
+    name: Score
+    judgment: bool
+    reasoning: str
+
+
+class EvaluationScore(BaseModel):
+    name: Score
+    score: float
+    representative_reasoning: str
+    all_evaluations: List[EvaluationResult]
+
+
+class Evaluator:
+    def __init__(self, config: Optional[EvaluatorConfig] = None):
+        self.config = config or EvaluatorConfig()
+        self.async_client = openai.AsyncOpenAI(
+            api_key=self.config.api_key, base_url=self.config.base_url
+        )
+        self.sync_client = openai.OpenAI(
+            api_key=self.config.api_key, base_url=self.config.base_url
+        )
+
+    @staticmethod
+    def generate_prompt(conversation: str, score: Score) -> str:
+        return PROMPT_TEMPLATE.format(
+            requirements=PRESET_PROMPT[score.value], conversation=conversation
+        )
+
+    def _sync_evaluate_once(
+        self, conversation: str, score: Score
+    ) -> Optional[EvaluationResult]:
+        prompt = self.generate_prompt(conversation, score)
+        response = self.sync_client.beta.chat.completions.parse(
+            model=self.config.model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=self.config.temperature,
+            response_format=EvaluationResult,
+        )
+        return response.choices[0].message.parsed
+
+    async def _async_evaluate_once(
+        self, conversation: str, score: Score
+    ) -> Optional[EvaluationResult]:
+        prompt = self.generate_prompt(conversation, score)
+        response = await self.async_client.beta.chat.completions.parse(
+            model=self.config.model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=self.config.temperature,
+            response_format=EvaluationResult,
+        )
+        return response.choices[0].message.parsed
+
+    def _aggregate_result(
+        self, name: Score, evaluations: List[EvaluationResult]
+    ) -> EvaluationScore:
+        n = len(evaluations)
+        true_count = sum(1 for e in evaluations if e.judgment is True)
+        score = true_count / n
+        majority_judgment = True if true_count >= (n / 2) else False
+        majority_reasons = [
+            e.reasoning for e in evaluations if e.judgment == majority_judgment
+        ]
+        representative_reasoning = (
+            random.choice(majority_reasons) if majority_reasons else ""
+        )
+        return EvaluationScore(
+            name=name,
+            score=score,
+            representative_reasoning=representative_reasoning,
+            all_evaluations=evaluations,
+        )
+
+    def _aggregate_results(
+        self, evaluations: List[EvaluationResult]
+    ) -> List[EvaluationScore]:
+        scores = {}
+        for evaluation in evaluations:
+            if evaluation.name not in scores:
+                scores[evaluation.name] = []
+            scores[evaluation.name].append(evaluation)
+
+        aggregated_results = [
+            self._aggregate_result(name, evals)
+            for name, evals in scores.items()
+        ]
+        return aggregated_results
+
+    def evaluate_sync(
+        self, conversation: str, scores: list[Score], n_rounds: int
+    ) -> List[EvaluationScore]:
+        with concurrent.futures.ThreadPoolExecutor(
+            max_workers=self.config.max_concurrency
+        ) as executor:
+            futures = [
+                executor.submit(self._sync_evaluate_once, conversation, score)
+                for _ in range(n_rounds)
+                for score in scores
+            ]
+            evaluations = [
+                f.result() for f in concurrent.futures.as_completed(futures)
+            ]
+        return self._aggregate_results(
+            [e for e in evaluations if e is not None]
+        )
+
+    async def evaluate_async(
+        self, conversation: str, scores: list[Score], n_rounds: int
+    ) -> List[EvaluationScore]:
+        semaphore = asyncio.Semaphore(self.config.max_concurrency)
+
+        async def sem_task(score):
+            async with semaphore:
+                return await self._async_evaluate_once(conversation, score)
+
+        tasks = [sem_task(score) for _ in range(n_rounds) for score in scores]
+        evaluations = await asyncio.gather(*tasks)
+        return self._aggregate_results(
+            [e for e in evaluations if e is not None]
+        )
+
+    def evaluate(
+        self,
+        conversation: str,
+        scores: list[Score],
+        n_rounds: int = 5,
+        mode: Literal["sync", "async"] = "sync",
+    ) -> List[EvaluationScore]:
+        if mode == "async":
+            return asyncio.run(
+                self.evaluate_async(conversation, scores, n_rounds)
+            )
+        return self.evaluate_sync(conversation, scores, n_rounds)

divi/evaluation/prompts.py

@@ -0,0 +1,14 @@
+PROMPT_TEMPLATE = (
+    "Your evaluation task is: {requirements}\n\n"
+    "Please perform step-by-step reasoning to reach your judgment.\n\n"
+    "Strictly output your answer in the following JSON format:\n"
+    '{{"judgment": bool, "reasoning": "string"}}\n\n'
+    "Do not output anything else.\n\n"
+    "Here is the conversation to evaluate:\n"
+    "{conversation}"
+)
+
+PRESET_PROMPT = {
+    "task_completion": "Evaluate whether the model's output completely fulfills the user's task requirements.",
+    "instruction_adherence": "Evaluate whether the model's output strictly follows the user's instructions without omissions, deviations, or hallucinations.",
+}

divi/evaluation/scores.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class Score(str, Enum):
+    """Enum for score types."""
+
+    task_completion = "task_completion"
+    instruction_adherence = "instruction_adherence"

divi/services/datapark/datapark.py

@@ -1,16 +1,16 @@
-from typing import Any, Dict, TYPE_CHECKING
-from typing_extensions import Mapping
+from typing import Any, Dict
 
 from google.protobuf.json_format import MessageToDict
+from openai import NotGiven
 from openai.types.chat import ChatCompletion
 from pydantic import UUID4
+from typing_extensions import Mapping
 
 import divi
 from divi.proto.trace.v1.trace_pb2 import ScopeSpans
 from divi.services.service import Service
 from divi.session.session import SessionSignal
 from divi.signals.trace.trace import TraceSignal
-from openai import NotGiven
 
 
 class DataPark(Service):
@@ -33,7 +33,11 @@ class DataPark(Service):
         if not isinstance(obj, Mapping):
             return obj
 
-        return {key: value for key, value in obj.items() if not isinstance(value, NotGiven)}
+        return {
+            key: value
+            for key, value in obj.items()
+            if not isinstance(value, NotGiven)
+        }
 
     def create_session(self, session: SessionSignal) -> None:
         self.post("/api/session/", payload=session)
@@ -49,6 +53,7 @@ class DataPark(Service):
     def create_chat_completion(
         self,
         span_id: bytes,
+        trace_id: UUID4,
         inputs: Dict[str, Any],
         completion: ChatCompletion,
     ) -> None:
@@ -61,6 +66,7 @@ class DataPark(Service):
                 },
                 "/api/v1/chat/completions": {
                     "span_id": hex_span_id,
+                    "trace_id": str(trace_id),
                     "data": completion.model_dump(),
                 },
             }

divi/services/init.py

@@ -1,6 +1,7 @@
 import divi
 from divi.services.auth import init as init_auth
-from divi.services.core import init as init_core
+
+# from divi.services.core import init as init_core
 from divi.services.datapark import init as init_datapark
 
 

divi/session/session.py

@@ -9,13 +9,13 @@ class SessionExtra(TypedDict, total=False):
 
     session_name: Optional[str]
     """Name of the session"""
-    trace: Optional[Trace]
-    """Trace ID UUID4"""
+    trace: Trace
+    """Trace in session"""
     parent_span_id: Optional[bytes]
     """Parent Span ID fixed string(8)"""
 
 
-class SessionSignal(TypedDict, total=False):
+class SessionSignal(TypedDict):
     """Session request"""
 
     id: str

divi/session/setup.py

@@ -1,3 +1,5 @@
+from typing_extensions import Optional
+
 import divi
 from divi.services import init as init_services
 from divi.session import Session, SessionExtra
@@ -5,10 +7,10 @@ from divi.signals.trace import Span
 from divi.signals.trace.trace import Trace
 
 
-def init(session_extra: SessionExtra) -> Session:
+def init_session(name: Optional[str] = None) -> Session:
     """init initializes the services and the Run"""
     init_services()
-    session = Session(name=session_extra.get("session_name"))
+    session = Session(name=name)
     if divi._datapark:
         divi._datapark.create_session(session.signal)
     return session
@@ -24,39 +26,23 @@ def setup(
         span (Span): Span instance
         session_extra (SessionExtra | None): Extra information from user input
     """
-    # TOOD: merge run_extra input by user with the one from the context
-    # temp solution: Priority: run_extra_context.get() > run_extra
     session_extra = session_extra or SessionExtra()
 
     # init the session if not already initialized
     if not divi._session:
-        divi._session = init(session_extra=session_extra)
+        divi._session = init_session(
+            name=session_extra.get("session_name") or span.name
+        )
 
     # setup trace
-    # init current span
-    trace = session_extra.get("trace")
+    trace = session_extra.get("trace") or Trace(divi._session.id, span.name)
     parent_span_id = session_extra.get("parent_span_id")
-    if trace and parent_span_id:
-        span._add_parent(trace.trace_id, parent_span_id)
-    else:
-        trace = Trace(divi._session.id)
-        trace.start()
-        span._as_root(trace.trace_id)
-        # create the trace
-        if divi._datapark:
-            divi._datapark.upsert_traces(
-                session_id=divi._session.id, traces=[trace.signal]
-            )
-
-    # update the session_extra with the current span
-    # session_extra["trace_id"] = span.trace_id
-    # session_extra["parent_span_id"] = span.span_id
-    session_extra = SessionExtra(
+    span._add_node(trace.trace_id, parent_span_id)
+
+    # update the session_extra with the current trace and span
+    return SessionExtra(
         session_name=divi._session.name,
         trace=trace,
         # set the parent_span_id to the current span_id
         parent_span_id=span.span_id,
     )
-
-    # offer end hook to collect data at whe end of the span ?
-    return session_extra

divi/signals/trace/trace.py

@@ -7,6 +7,7 @@ from uuid import uuid4
 from pydantic import UUID4
 from typing_extensions import TypedDict
 
+import divi
 from divi.proto.common.v1.common_pb2 import KeyValue
 from divi.proto.trace.v1.trace_pb2 import Span as SpanProto
 
@@ -29,15 +30,19 @@ class TraceSignal(TypedDict, total=False):
     """Start time in iso format"""
     end_time: NullTime
     """End time in iso format"""
+    name: Optional[str]
 
 
 class Trace:
-    def __init__(self, session_id: UUID4):
+    def __init__(self, session_id: UUID4, name: Optional[str] = None):
         self.trace_id: UUID4 = uuid4()
         self.start_time: str | None = None
         self.end_time: str | None = None
+        self.name: Optional[str] = name
         self.session_id: UUID4 = session_id
 
+        self.start()
+
     @property
     def signal(self) -> TraceSignal:
         if self.start_time is None:
@@ -45,6 +50,7 @@ class Trace:
         signal = TraceSignal(
             id=str(self.trace_id),
             start_time=self.start_time,
+            name=self.name,
         )
         if self.end_time is not None:
             signal["end_time"] = NullTime(
@@ -60,12 +66,21 @@ class Trace:
     def start(self):
         """Start the trace by recording the current time in nanoseconds."""
         self.start_time = datetime.now(UTC).isoformat()
+        self.upsert_trace()
 
     def end(self):
         """End the trace by recording the end time in nanoseconds."""
         if self.start_time is None:
             raise ValueError("Span must be started before ending.")
         self.end_time = datetime.now(UTC).isoformat()
+        self.upsert_trace()
+
+    def upsert_trace(self):
+        """Upsert trace with datapark."""
+        if divi._datapark:
+            divi._datapark.upsert_traces(
+                session_id=self.session_id, traces=[self.signal]
+            )
 
 
 class Span:
@@ -102,7 +117,6 @@ class Span:
             trace_id=self.trace_id.bytes if self.trace_id else None,
             parent_span_id=self.parent_span_id,
         )
-        print(self.kind)
         signal.metadata.extend(
             KeyValue(key=k, value=v)
             for k, v in (self.metadata or dict()).items()
@@ -131,21 +145,7 @@ class Span:
             raise ValueError("Span must be started before ending.")
         self.end_time_unix_nano = time.time_ns()
 
-    def _as_root(self, trace_id: UUID4):
-        """Set the span as a root span."""
-        self.trace_id = trace_id
-        print("as root")
-        print(f"name: {self.name}")
-        print(f"trace_id: {self.trace_id}")
-        print(f"span_id: {self.span_id}")
-
-    def _add_parent(self, trace_id: UUID4, parent_id: bytes):
-        """Set the parent span ID."""
+    def _add_node(self, trace_id: UUID4, parent_id: Optional[bytes] = None):
+        """Add node for obs tree."""
         self.trace_id = trace_id
         self.parent_span_id = parent_id
-
-        print("add parent")
-        print(f"name: {self.name}")
-        print(f"trace_id: {trace_id}")
-        print(f"span_id: {self.span_id}")
-        print(f"parent_span_id: {parent_id}")

{divi-0.0.1.dev21.dist-info → divi-0.0.1.dev28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: divi
-Version: 0.0.1.dev21
+Version: 0.0.1.dev28
 Summary: The Agent Platform for Observability & Evaluation
 License-File: LICENSE
 Requires-Python: >=3.11

{divi-0.0.1.dev21.dist-info → divi-0.0.1.dev28.dist-info}/RECORD

@@ -1,9 +1,13 @@
-divi/__init__.py,sha256=-XjMcUmlsDSB_v0_rf5owoldPj1mXFoAgUaVZpyfwqk,396
+divi/__init__.py,sha256=IcRE_HzskERpnkps5ABPTGxtsLGcRN8eRTjozDU5OMU,485
 divi/utils.py,sha256=fXkjoyo_Lh8AZliKICOP460m0czUcNQjcEcceJbaOVA,1439
-divi/config/config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 divi/decorators/__init__.py,sha256=HkyWdC1ctTsVFucCWCkj57JB4NmwONus1d2S2dUbvs4,110
-divi/decorators/obs_openai.py,sha256=4LtQPRgJPPyTOw1318Fi04WYqjIwGX8EP0YiWrTW0dk,1003
-divi/decorators/observable.py,sha256=OZ0Ry6Q2sdZPAT_T5j2wSsM7g0nwDroxeSbP3nLMDvA,4250
+divi/decorators/obs_openai.py,sha256=CGX60JgOKsN3E06yCq2L8baN9ZLiJJm3ukBsaN3IBBg,1324
+divi/decorators/observable.py,sha256=Ko_Pmw8l_T9mNp0corXkWqawwNEmQN7gf7rcAq-DB9M,3829
+divi/evaluation/__init__.py,sha256=3qMHWu_zBh6FJa6-1dZZEWiAblQZurn5doa0OjGvDGs,93
+divi/evaluation/evaluate.py,sha256=4Li8NciQXcgmuAYRGFaB5C3EzMZR79n8IW0ubJBVrbQ,1789
+divi/evaluation/evaluator.py,sha256=22URc2pqg6WSYT-xUavxI8eT5w6t-mdVyTDZy-Qe4LU,5395
+divi/evaluation/prompts.py,sha256=yRFP3QjtcMflZ-jsFqXSu9RHlQA1cEVgDXo5D4VC6lo,662
+divi/evaluation/scores.py,sha256=ZgSxfve-ZivX3WU4TGcgPOSpUQVMbG5a15IQNPeq_bQ,173
 divi/proto/common/v1/common.proto,sha256=Rx8wr0_tOtQ1NseTMnsav4ApD1MDALzQDBA2IvLRTU0,1775
 divi/proto/common/v1/common_pb2.py,sha256=br61OHQVAi6SI3baFcb5xJv2Xd-AZ04A19xeSjLNMXo,2442
 divi/proto/common/v1/common_pb2.pyi,sha256=LmTpFFLxHg2a_qPIdNXXwGEMkbiDcTJdarR9eC-6Fq8,2133
@@ -19,7 +23,7 @@ divi/proto/trace/v1/trace_pb2.py,sha256=CuTkSSvhxCa1bk3Ku7tgLqRSovp_Gi52CZ0zLcLP
 divi/proto/trace/v1/trace_pb2.pyi,sha256=rPo2Oa3NWrINE_dyOVU9HUYHo5LY82Bm5TMenj5dnK8,2136
 divi/services/__init__.py,sha256=TcVJ_gKxyPIcwhT9GgttqHeyk0icW44uE285KmUiyh4,185
 divi/services/finish.py,sha256=XKPKGJ5cWd5H95G_VpIOlOZOLrcf9StoTs7ayRic2jY,173
-divi/services/init.py,sha256=JVzRQ1m1DTHXFVGUMYnsv-vRvzCO8XFdR6MjIwOL_NY,433
+divi/services/init.py,sha256=BFSsW6UzeujfHba8pvVPnEYmW0Y8VVFQLuIXI5Z2Mu4,436
 divi/services/service.py,sha256=539MhcYfMvsVGjDdu0UtYSZnL2cloaPeYeOSMl2eUy8,1532
 divi/services/auth/__init__.py,sha256=PIQ9rQ0jcRqcy03a3BOY7wbzwluIRG_4kI_H4J4mRFk,74
 divi/services/auth/auth.py,sha256=eRcE6Kq8jbBr6YL93HCGDIoga90SoZf3ogOAKeza9WY,445
@@ -30,16 +34,16 @@ divi/services/core/core.py,sha256=PRwPtLgrgmCrejUfKf7HJNrAhGS0paFNZ7JwDToEUAk,12
 divi/services/core/finish.py,sha256=dIGQpVXcJY4-tKe7A1_VV3yoSHNCDPfOlUltvzvk6VI,231
 divi/services/core/init.py,sha256=e7-fgpOPglBXyEoPkgOAnpJk2ApdFbo7LPupxOb8N-w,1966
 divi/services/datapark/__init__.py,sha256=GbV1mwHE07yutgOlCIYHykSEL5KJ-ApgLutGMzu2eUE,86
-divi/services/datapark/datapark.py,sha256=1CoWJI2embzvijCmIIPwTLnliU4kSolUginGuSWHsBw,2182
+divi/services/datapark/datapark.py,sha256=d2pbrzVJtR3mNW1eQpbm-Wca-SvcfJqT7IuaQy7yHT0,2285
 divi/services/datapark/init.py,sha256=C32f9t3eLsxcYNqEyheh6nW455G2oR0YhhdqBcbN3ec,92
 divi/session/__init__.py,sha256=6lYemv21VQCIHx-xIdi7BxXcPNxVdvE60--8ArReUew,82
-divi/session/session.py,sha256=ID7bQ4CuRPUcZ9S-DSjndiduslYFJukRLuCtChYm3wk,838
-divi/session/setup.py,sha256=jlc3ICR5hRDdrcxoSxi66FYS2TYxqrIJOMgI4i1tEJs,1972
+divi/session/session.py,sha256=LlB2W2qGo0Vf-0L0CTQoXfzg_gCGpf0MTFsXQW7E6i4,817
+divi/session/setup.py,sha256=XU4_wXqdIg91dZSttjmjlC6u3hIyV0Nn_xqRw8db7os,1405
 divi/session/teardown.py,sha256=YiBz_3yCiljMFEofZ60VmRL5sb8WA5GT7EYF8nFznZ4,133
 divi/signals/__init__.py,sha256=K1PaTAMwyBDsK6jJUg4QWy0xVJ_5MA6dlWiUyJeiSQA,44
 divi/signals/trace/__init__.py,sha256=K1PaTAMwyBDsK6jJUg4QWy0xVJ_5MA6dlWiUyJeiSQA,44
-divi/signals/trace/trace.py,sha256=y8Xio8Tp_e1tO8l_DAkUuzMrmENNKfIdklF0iWrjGYk,4547
-divi-0.0.1.dev21.dist-info/METADATA,sha256=xyAsE6Uj3sA8T7I83LVLtCEyum_hMQT4ULien2Q-0NU,497
-divi-0.0.1.dev21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-divi-0.0.1.dev21.dist-info/licenses/LICENSE,sha256=5OJuZ4wMMEV0DgF0tofhAlS_KLkaUsZwwwDS2U_GwQ0,1063
-divi-0.0.1.dev21.dist-info/RECORD,,
+divi/signals/trace/trace.py,sha256=OsfrZPHp241_NN8W79U4O69HsHQajez_d3rz6yJRN9s,4508
+divi-0.0.1.dev28.dist-info/METADATA,sha256=I2KiV8mzi0AnMFpUaWYHGKE0ETSDKvS6wcMMx08vLVw,497
+divi-0.0.1.dev28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+divi-0.0.1.dev28.dist-info/licenses/LICENSE,sha256=5OJuZ4wMMEV0DgF0tofhAlS_KLkaUsZwwwDS2U_GwQ0,1063
+divi-0.0.1.dev28.dist-info/RECORD,,