dagster-omni 0.28.5__py3-none-any.whl

dagster_omni/__init__.py

@@ -0,0 +1,6 @@
+from dagster_shared.libraries import DagsterLibraryRegistry
+
+from dagster_omni.component import OmniComponent as OmniComponent
+from dagster_omni.version import __version__ as __version__
+
+DagsterLibraryRegistry.register("dagster-omni", __version__)

dagster_omni/component.py

@@ -0,0 +1,186 @@
+import itertools
+from collections import defaultdict
+from pathlib import Path
+from typing import Optional
+
+import dagster as dg
+from dagster._annotations import preview, public
+from dagster._core.errors import DagsterInvalidDefinitionError
+from dagster.components.component.state_backed_component import StateBackedComponent
+from dagster.components.utils.defs_state import (
+    DefsStateConfig,
+    DefsStateConfigArgs,
+    ResolvedDefsStateConfig,
+)
+from pydantic import Field
+
+from dagster_omni.objects import OmniDocument, OmniQuery, OmniWorkspaceData
+from dagster_omni.translation import (
+    TRANSLATOR_DATA_METADATA_KEY,
+    OmniDocumentMetadataSet,
+    OmniTranslatorData,
+    ResolvedOmniTranslationFn,
+)
+from dagster_omni.workspace import OmniWorkspace
+
+
+@preview
+class OmniComponent(StateBackedComponent, dg.Model, dg.Resolvable):
+    """Pulls in the contents of an Omni workspace into Dagster assets.
+
+    Example:
+
+        .. code-block:: yaml
+
+            # defs.yaml
+
+            type: dagster_omni.OmniComponent
+            attributes:
+              workspace:
+                base_url: https://your-company.omniapp.co
+                api_key: "{{ env.OMNI_API_KEY }}"
+    """
+
+    workspace: OmniWorkspace = Field(
+        description="Defines configuration for interacting with an Omni instance.",
+    )
+    translation: Optional[ResolvedOmniTranslationFn] = Field(
+        default=None,
+        description="Defines how to translate an Omni object into an AssetSpec object.",
+    )
+    defs_state: ResolvedDefsStateConfig = DefsStateConfigArgs.versioned_state_storage()
+
+    @property
+    def defs_state_config(self) -> DefsStateConfig:
+        return DefsStateConfig.from_args(self.defs_state, default_key=self.__class__.__name__)
+
+    async def write_state_to_path(self, state_path: Path) -> None:
+        """Fetch documents from Omni API and write state to path."""
+        state = await self.workspace.fetch_omni_state()
+        state_path.write_text(dg.serialize_value(state))
+
+    def load_state_from_path(self, state_path: Path) -> OmniWorkspaceData:
+        """Load state from path using Dagster's deserialization system."""
+        return dg.deserialize_value(state_path.read_text(), OmniWorkspaceData)
+
+    def _get_default_omni_spec(
+        self, context: dg.ComponentLoadContext, data: OmniTranslatorData, workspace: OmniWorkspace
+    ) -> Optional[dg.AssetSpec]:
+        """Core function for converting an Omni document into an AssetSpec object."""
+        if isinstance(data.obj, OmniDocument):
+            doc = data.obj
+            maybe_deps = [
+                self.get_asset_spec(
+                    context, OmniTranslatorData(obj=query, workspace_data=data.workspace_data)
+                )
+                for query in data.obj.queries
+            ]
+
+            prefix = doc.folder.path.split("/") if doc.folder else []
+            user = data.workspace_data.get_user(doc.owner.id)
+            owner_email = user.primary_email if user else None
+
+            return dg.AssetSpec(
+                key=dg.AssetKey([*prefix, doc.name]),
+                group_name=prefix[0].replace("-", "_") if prefix else None,
+                tags={label.name: "" for label in doc.labels},
+                deps=list(filter(None, maybe_deps)),
+                metadata={
+                    **OmniDocumentMetadataSet.from_document(workspace, doc),
+                    TRANSLATOR_DATA_METADATA_KEY: data,
+                },
+                kinds={"omni"},
+                owners=[owner_email] if owner_email else None,
+            )
+        if isinstance(data.obj, OmniQuery):
+            return dg.AssetSpec(key=dg.AssetKey([data.obj.query_config.table]))
+        return None
+
+    @public
+    def get_asset_spec(
+        self, context: dg.ComponentLoadContext, data: OmniTranslatorData
+    ) -> Optional[dg.AssetSpec]:
+        """Generates an AssetSpec for a given Omni document.
+
+        This method can be overridden in a subclass to customize how Omni documents
+        (workbooks, queries) are converted to Dagster asset specs. By default, it applies
+        any configured translation function to the base asset spec.
+
+        Args:
+            context: The component load context provided by Dagster
+            data: The OmniTranslatorData containing information about the Omni document
+
+        Returns:
+            An AssetSpec that represents the Omni document as a Dagster asset, or None
+            if the document should not be represented as an asset
+
+        Example:
+            Override this method to add custom metadata based on document properties:
+
+            .. code-block:: python
+
+                from dagster_omni import OmniComponent
+                import dagster as dg
+
+                class CustomOmniComponent(OmniComponent):
+                    def get_asset_spec(self, context, data):
+                        base_spec = super().get_asset_spec(context, data)
+                        if base_spec:
+                            return base_spec.replace_attributes(
+                                metadata={
+                                    **base_spec.metadata,
+                                    "omni_type": type(data.obj).__name__,
+                                    "workspace": data.workspace_data.workspace_id
+                                }
+                            )
+                        return None
+        """
+        base_asset_spec = self._get_default_omni_spec(context, data, self.workspace)
+        if self.translation and base_asset_spec:
+            return self.translation(base_asset_spec, data)
+        else:
+            return base_asset_spec
+
+    def _build_asset_specs(
+        self, context: dg.ComponentLoadContext, workspace_data: OmniWorkspaceData
+    ) -> list[dg.AssetSpec]:
+        """Invokes the `get_asset_spec` method on all objects in the provided `workspace_data`.
+        Filters out any cases where the asset_spec is `None`, and provides a helpful error
+        message in cases where keys overlap between different documents.
+        """
+        maybe_specs = [
+            self.get_asset_spec(context, OmniTranslatorData(obj=doc, workspace_data=workspace_data))
+            for doc in workspace_data.documents
+        ]
+
+        specs_by_key: dict[dg.AssetKey, list[dg.AssetSpec]] = defaultdict(list)
+        for spec in filter(None, maybe_specs):
+            specs_by_key[spec.key].append(spec)
+
+        for key, specs in specs_by_key.items():
+            if len(specs) == 1:
+                continue
+
+            ids = [OmniDocumentMetadataSet.extract(spec.metadata).url or spec for spec in specs]
+            ids_str = "\n\t".join(map(str, ids))
+            raise DagsterInvalidDefinitionError(
+                f"Multiple objects map to the same key {key}:"
+                f"\n\t{ids_str}\n"
+                "Please ensure that each object has a unique name by updating the `translation` function."
+            )
+
+        return list(itertools.chain.from_iterable(specs_by_key.values()))
+
+    def build_defs_from_workspace_data(
+        self, context: dg.ComponentLoadContext, workspace_data: OmniWorkspaceData
+    ) -> dg.Definitions:
+        return dg.Definitions(assets=self._build_asset_specs(context, workspace_data))
+
+    def build_defs_from_state(
+        self, context: dg.ComponentLoadContext, state_path: Optional[Path]
+    ) -> dg.Definitions:
+        if state_path is None:
+            return dg.Definitions()
+
+        state = self.load_state_from_path(state_path)
+        return self.build_defs_from_workspace_data(context, state)

dagster_omni/objects.py

@@ -0,0 +1,180 @@
+from functools import cached_property
+from typing import Any, Optional
+
+from dagster_shared.record import record
+from dagster_shared.serdes import whitelist_for_serdes
+
+
+@whitelist_for_serdes
+@record
+class OmniFolder:
+    id: str
+    name: str
+    path: str
+    scope: str
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "OmniFolder":
+        """Create OmniFolder from JSON response data."""
+        return cls(id=data["id"], name=data["name"], path=data["path"], scope=data["scope"])
+
+
+@whitelist_for_serdes
+@record
+class OmniLabel:
+    name: str
+    verified: bool
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "OmniLabel":
+        """Create OmniLabel from JSON response data."""
+        return cls(name=data["name"], verified=data["verified"])
+
+
+@whitelist_for_serdes
+@record
+class OmniOwner:
+    id: str
+    name: str
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "OmniOwner":
+        """Create OmniOwner from JSON response data."""
+        return cls(id=data["id"], name=data["name"])
+
+
+@whitelist_for_serdes
+@record
+class OmniDocument:
+    identifier: str
+    name: str
+    scope: str
+    connection_id: str
+    deleted: bool
+    has_dashboard: bool
+    type: str
+    updated_at: str
+    owner: OmniOwner
+    folder: Optional[OmniFolder]
+    labels: list[OmniLabel]
+    queries: list["OmniQuery"]
+    favorites: Optional[int] = None
+    views: Optional[int] = None
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any], queries: list["OmniQuery"]) -> "OmniDocument":
+        """Create OmniDocument from JSON response data."""
+        folder = None
+        if data.get("folder"):
+            folder = OmniFolder.from_json(data["folder"])
+
+        labels = [OmniLabel.from_json(label_data) for label_data in data.get("labels", [])]
+        owner = OmniOwner.from_json(data["owner"])
+
+        return cls(
+            identifier=data["identifier"],
+            name=data["name"],
+            scope=data["scope"],
+            connection_id=data["connectionId"],
+            deleted=data["deleted"],
+            has_dashboard=data["hasDashboard"],
+            type=data.get("type", "document"),
+            updated_at=data["updatedAt"],
+            owner=owner,
+            folder=folder,
+            labels=labels,
+            queries=queries,
+            favorites=data.get("_count", {}).get("favorites", None),
+            views=data.get("_count", {}).get("views", None),
+        )
+
+
+@whitelist_for_serdes
+@record
+class OmniQueryConfig:
+    """Represents the essential query configuration needed for asset creation."""
+
+    table: str
+    fields: list[str]
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "OmniQueryConfig":
+        """Create OmniQueryConfig from JSON query configuration data."""
+        return cls(
+            table=data["table"],
+            fields=data["fields"],
+        )
+
+
+@whitelist_for_serdes
+@record
+class OmniQuery:
+    id: str
+    name: str
+    query_config: OmniQueryConfig
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "OmniQuery":
+        """Create OmniQuery from JSON response data."""
+        return cls(
+            id=data["id"],
+            name=data["name"],
+            query_config=OmniQueryConfig.from_json(data["query"]),
+        )
+
+
+@whitelist_for_serdes
+@record
+class OmniUser:
+    """Represents an Omni user with all user information in a single class."""
+
+    id: str
+    name: Optional[str]
+    display_name: str
+    user_name: str
+    active: bool
+    primary_email: Optional[str]
+    groups: list[str]
+    created: str
+    last_modified: str
+
+    @classmethod
+    def from_json(cls, data: dict[str, Any]) -> "OmniUser":
+        """Create OmniUser from JSON response data."""
+        primary_email = next(
+            (email["value"] for email in data.get("emails", []) if email["primary"]), None
+        )
+        groups = [group["display"] for group in data.get("groups", [])]
+
+        return cls(
+            id=data["id"],
+            name=data.get("displayName") or data.get("userName") or "",
+            display_name=data.get("displayName", ""),
+            user_name=data.get("userName", ""),
+            active=data.get("active", True),
+            primary_email=primary_email,
+            groups=groups,
+            created=data.get("meta", {}).get("created", ""),
+            last_modified=data.get("meta", {}).get("lastModified", ""),
+        )
+
+
+@whitelist_for_serdes
+@record
+class OmniWorkspaceData:
+    """Serializable container object for recording the state of the Omni API at a given point in time.
+
+    Properties:
+        documents: list[OmniDocument]
+        users: list[OmniUser]
+    """
+
+    documents: list[OmniDocument]
+    users: list[OmniUser]
+
+    @cached_property
+    def _users_by_id(self) -> dict[str, OmniUser]:
+        return {user.id: user for user in self.users}
+
+    def get_user(self, user_id: str) -> Optional[OmniUser]:
+        return self._users_by_id.get(user_id)

dagster_omni/py.typed

@@ -0,0 +1 @@
+partial

dagster_omni/translation.py

@@ -0,0 +1,143 @@
+from typing import Annotated, Optional, TypeAlias, Union
+
+import dateutil
+from dagster._core.definitions.assets.definition.asset_spec import AssetSpec
+from dagster._core.definitions.metadata.metadata_set import NamespacedMetadataSet
+from dagster._core.definitions.metadata.metadata_value import (
+    TimestampMetadataValue,
+    UrlMetadataValue,
+)
+from dagster.components import Resolvable, Resolver
+from dagster.components.resolved.base import resolve_fields
+from dagster.components.resolved.context import ResolutionContext
+from dagster.components.resolved.core_models import AssetSpecKeyUpdateKwargs, AssetSpecUpdateKwargs
+from dagster.components.utils import TranslatorResolvingInfo
+from dagster.components.utils.translation import TranslationFn, TranslationFnResolver
+from dagster_shared.record import record
+from typing_extensions import Self
+
+from dagster_omni.objects import OmniDocument, OmniQuery, OmniWorkspaceData
+from dagster_omni.workspace import OmniWorkspace
+
+TRANSLATOR_DATA_METADATA_KEY = ".dagster-omni/translator_data"
+
+
+class OmniDocumentMetadataSet(NamespacedMetadataSet):
+    """Represents metadata that is captured from an Omni document."""
+
+    url: Optional[UrlMetadataValue] = None
+    owner_name: str
+    document_name: str
+    document_type: str
+    updated_at: TimestampMetadataValue
+    favorites: Optional[int] = None
+    views: Optional[int] = None
+
+    @classmethod
+    def from_document(cls, workspace: OmniWorkspace, document: OmniDocument) -> Self:
+        url_str = f"{workspace.base_url.rstrip('/')}/dashboards/{document.identifier}"
+
+        return cls(
+            url=UrlMetadataValue(url_str) if document.has_dashboard else None,
+            document_name=document.name,
+            document_type=document.type,
+            updated_at=TimestampMetadataValue(
+                dateutil.parser.parse(document.updated_at).timestamp()
+            ),
+            owner_name=document.owner.name,
+            favorites=document.favorites,
+            views=document.views,
+        )
+
+    @classmethod
+    def namespace(cls) -> str:
+        return "dagster-omni"
+
+
+@record
+class OmniTranslatorData:
+    """Container class for data required to translate an object in an
+    Omni workspace into a Dagster definition.
+
+    Properties:
+        obj (Union[OmniDocument, OmniQuery]): The object to translate.
+        workspace_data (OmniWorkspaceData): Global workspace data.
+    """
+
+    obj: Union[OmniDocument, OmniQuery]
+    workspace_data: OmniWorkspaceData
+
+
+def _resolve_multilayer_translation(context: ResolutionContext, model):
+    """The Omni translation schema supports defining global transforms
+    as well as per-object-type transforms. This resolver composes the
+    per-object-type transforms with the global transforms.
+    """
+    info = TranslatorResolvingInfo(
+        asset_attributes=model,
+        resolution_context=context,
+        model_key="translation",
+    )
+
+    def _translation_fn(base_asset_spec: AssetSpec, data: OmniTranslatorData):
+        processed_spec = info.get_asset_spec(
+            base_asset_spec,
+            {
+                "data": data,
+                "spec": base_asset_spec,
+            },
+        )
+
+        nested_translation_fns = resolve_fields(
+            model=model,
+            resolved_cls=OmniTranslationArgs,
+            context=context.with_scope(
+                **{
+                    "data": data,
+                    "spec": processed_spec,
+                }
+            ),
+        )
+        for_document = nested_translation_fns.get("for_document")
+        for_query = nested_translation_fns.get("for_query")
+
+        if isinstance(data.obj, OmniDocument) and for_document:
+            return for_document(processed_spec, data)
+        if isinstance(data.obj, OmniQuery) and for_query:
+            return for_query(processed_spec, data)
+
+        return processed_spec
+
+    return _translation_fn
+
+
+OmniTranslationFn: TypeAlias = TranslationFn[OmniTranslatorData]
+
+ResolvedTargetedOmniTranslationFn = Annotated[
+    OmniTranslationFn,
+    TranslationFnResolver[OmniTranslatorData](lambda data: {"data": data}),
+]
+
+ResolvedTargetedKeyOnlyOmniTranslationFn = Annotated[
+    OmniTranslationFn,
+    TranslationFnResolver[OmniTranslatorData](
+        lambda data: {"data": data}, model_field_type=AssetSpecKeyUpdateKwargs.model()
+    ),
+]
+
+
+@record
+class OmniTranslationArgs(AssetSpecUpdateKwargs, Resolvable):
+    """Model used to allow per-object-type translation of an Omni object."""
+
+    for_document: Optional[ResolvedTargetedOmniTranslationFn] = None
+    for_query: Optional[ResolvedTargetedKeyOnlyOmniTranslationFn] = None
+
+
+ResolvedOmniTranslationFn = Annotated[
+    OmniTranslationFn,
+    Resolver(
+        _resolve_multilayer_translation,
+        model_field_type=Union[str, OmniTranslationArgs.model()],
+    ),
+]

dagster_omni/version.py

@@ -0,0 +1 @@
+__version__ = "0.28.5"

dagster_omni/workspace.py

@@ -0,0 +1,156 @@
+import asyncio
+import urllib.parse
+from typing import Any, Optional
+
+import aiohttp
+import dagster as dg
+from aiohttp.client_exceptions import ClientResponseError
+from dagster._utils.backoff import async_backoff, exponential_delay_generator
+from pydantic import Field
+
+from dagster_omni.objects import OmniDocument, OmniQuery, OmniUser, OmniWorkspaceData
+
+
+class OmniWorkspace(dg.Resolvable, dg.Model):
+    """Handles all interactions with the Omni API to fetch and manage state."""
+
+    base_url: str = Field(
+        description="The base URL to your Omni instance.", examples=["https://acme.omniapp.co"]
+    )
+    api_key: str = Field(
+        description="The API key to your Omni instance.",
+        examples=['"{{ env.OMNI_API_KEY }}"'],
+        repr=False,
+    )
+    max_retries: int = Field(
+        default=5, description="The maximum number of retries to make when rate-limited."
+    )
+    base_delay: float = Field(
+        default=4.0,
+        description="The base delay for exponential backoff between retries in seconds.",
+    )
+
+    @property
+    def base_api_url(self) -> str:
+        return f"{self.base_url.rstrip('/')}/api/v1"
+
+    def _get_session(self) -> aiohttp.ClientSession:
+        """Create configured session with Bearer token authentication."""
+        headers = {
+            "Accept": "application/json",
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+        }
+        return aiohttp.ClientSession(headers=headers)
+
+    def _should_retry(self, exc: BaseException) -> bool:
+        """Determine if an exception should trigger a retry."""
+        if isinstance(exc, ClientResponseError):
+            return exc.status == 429 or 500 <= exc.status < 600
+        return isinstance(exc, aiohttp.ClientError)
+
+    def _build_url(self, endpoint: str) -> str:
+        return f"{self.base_url.rstrip('/')}/{endpoint.lstrip('/')}"
+
+    async def make_request(
+        self,
+        endpoint: str,
+        params: Optional[dict[str, Any]] = None,
+        headers: Optional[dict[str, str]] = None,
+    ) -> dict[str, Any]:
+        """Make a GET request to the API with retry logic."""
+        url = self._build_url(endpoint)
+        if params:
+            url = f"{url}?{urllib.parse.urlencode(params)}"
+
+        async def _make_request():
+            async with self._get_session() as session:
+                request_headers = headers or {}
+                async with session.get(url, headers=request_headers) as response:
+                    response.raise_for_status()
+                    return await response.json()
+
+        return await async_backoff(
+            _make_request,
+            retry_on=self._should_retry,
+            max_retries=self.max_retries,
+            delay_generator=exponential_delay_generator(base_delay=self.base_delay),
+        )
+
+    async def _fetch_document_queries(self, document_identifier: str) -> list[OmniQuery]:
+        """Fetch all queries for a specific document."""
+        endpoint = f"api/v1/documents/{document_identifier}/queries"
+        try:
+            response = await self.make_request(endpoint)
+            return [OmniQuery.from_json(query_data) for query_data in response.get("queries", [])]
+        except ClientResponseError as e:
+            # When a document has no queries, this will return 404
+            if e.status == 404:
+                return []
+            raise
+
+    async def _fetch_document_with_queries(self, document_data: dict[str, Any]) -> OmniDocument:
+        """Returns an OmniDocument with its queries embedded."""
+        queries = await self._fetch_document_queries(document_data["identifier"])
+        return OmniDocument.from_json(document_data, queries)
+
+    async def _fetch_documents(self) -> list[OmniDocument]:
+        """Fetch all documents from the Omni API with their queries embedded."""
+        base_params = {"pageSize": "100", "include": "_count"}
+        documents = []
+        next_cursor = None
+
+        while True:
+            params = base_params.copy()
+            if next_cursor:
+                params["cursor"] = next_cursor
+
+            response = await self.make_request("api/v1/documents", params)
+
+            # Fan out the requests to fetch queries for each document in parallel
+            coroutines = [
+                self._fetch_document_with_queries(doc_data)
+                for doc_data in response.get("records", [])
+            ]
+            documents.extend(await asyncio.gather(*coroutines))
+
+            next_cursor = response.get("pageInfo", {}).get("nextCursor")
+            if not next_cursor:
+                break
+
+        return documents
+
+    async def _fetch_users(self) -> list[OmniUser]:
+        """Fetch all users from the Omni SCIM API."""
+        base_params = {"count": "100"}
+        users = []
+        start_index = 1
+
+        while True:
+            params = base_params.copy()
+            params["startIndex"] = str(start_index)
+
+            response = await self.make_request("api/scim/v2/users", params)
+
+            user_resources = response.get("Resources", [])
+            if not user_resources:
+                break
+
+            users.extend([OmniUser.from_json(user_data) for user_data in user_resources])
+
+            # Check if we've received fewer users than requested, indicating we're done
+            if len(user_resources) < int(base_params["count"]):
+                break
+
+            start_index += len(user_resources)
+
+        return users
+
+    async def fetch_omni_state(self) -> OmniWorkspaceData:
+        """Fetch all documents and users from the Omni API.
+
+        This is the main public method for getting complete Omni state.
+        """
+        # Fetch documents and users concurrently
+        documents, users = await asyncio.gather(self._fetch_documents(), self._fetch_users())
+        return OmniWorkspaceData(documents=documents, users=users)

dagster_omni-0.28.5.dist-info/METADATA

@@ -0,0 +1,26 @@
+Metadata-Version: 2.4
+Name: dagster_omni
+Version: 0.28.5
+Summary: Package for integrating Omni with Dagster.
+Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-omni
+Author: Dagster Labs
+Author-email: hello@dagsterlabs.com
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+License-File: LICENSE
+Requires-Dist: dagster==1.12.5
+Requires-Dist: aiohttp
+Requires-Dist: python-dateutil
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: summary

dagster_omni-0.28.5.dist-info/RECORD

@@ -0,0 +1,12 @@
+dagster_omni/__init__.py,sha256=6QUEBSqA3cRAb4kSWqkdvkUiKMbk0NY1YFdJPW0JEkQ,249
+dagster_omni/component.py,sha256=47CRd2190icq6MAynZzXU6893R5EjPmwMfED4W-tk90,7555
+dagster_omni/objects.py,sha256=4cknF4xIljTYYWYCOKe8Tkaled0_Gq9u9g8Ze_mYnyQ,4960
+dagster_omni/py.typed,sha256=mDShSrm8qg9qjacQc2F-rI8ATllqP6EdgHuEYxuCXZ0,7
+dagster_omni/translation.py,sha256=ZESIkyRe9EsPEj7vsyYRe-NsJZaBEaM89bBtlIHOTIw,4820
+dagster_omni/version.py,sha256=SdGElACDuKJX1c_iqPcfu_quaKOShee-DePM8qfbbJU,23
+dagster_omni/workspace.py,sha256=C2fjZIw64TEKWRtpzt6rRm5MSY4RKCXJW22ANJBjY-o,5893
+dagster_omni-0.28.5.dist-info/licenses/LICENSE,sha256=lY5yc1KHX4HoXjlWnIPGcCAsnNney2rb8M8ccT6NzRQ,11347
+dagster_omni-0.28.5.dist-info/METADATA,sha256=uegZrCSnj_hNa1CAq1n9K_jQoWMID4aLRfIQ0EntpPI,862
+dagster_omni-0.28.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dagster_omni-0.28.5.dist-info/top_level.txt,sha256=FJO_1xyIWRN_nGhCDQPirG5NrEsB-wPR7eY5puEgJes,13
+dagster_omni-0.28.5.dist-info/RECORD,,

dagster_omni-0.28.5.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dagster_omni-0.28.5.dist-info/licenses/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2023 Dagster Labs, Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

dagster_omni-0.28.5.dist-info/top_level.txt

@@ -0,0 +1 @@
+dagster_omni