dagster-census 0.19.4__tar.gz → 0.28.8__tar.gz

{dagster-census-0.19.4 → dagster_census-0.28.8}/LICENSE

@@ -186,7 +186,7 @@
       same "printed page" as the copyright notice for easier
       identification within third-party archives.
 
-   Copyright 2023 Elementl, Inc.
+   Copyright 2025 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.

{dagster-census-0.19.4 → dagster_census-0.28.8}/MANIFEST.in

@@ -1,2 +1,3 @@
 include README.md
 include LICENSE
+include dagster_census/py.typed

dagster_census-0.28.8/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: dagster-census
+Version: 0.28.8
+Summary: Package for integrating Census with Dagster.
+Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-census
+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: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10,<3.15
+License-File: LICENSE
+Requires-Dist: dagster==1.12.8
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

dagster_census-0.28.8/dagster_census/__init__.py

@@ -0,0 +1,15 @@
+from dagster_shared.libraries import DagsterLibraryRegistry
+
+from dagster_census.components.census_component import CensusComponent as CensusComponent
+from dagster_census.ops import census_trigger_sync_op
+from dagster_census.resources import CensusResource
+from dagster_census.types import CensusOutput
+from dagster_census.version import __version__
+
+DagsterLibraryRegistry.register("dagster-census", __version__)
+
+__all__ = [
+    "CensusOutput",
+    "CensusResource",
+    "census_trigger_sync_op",
+]

dagster_census-0.28.8/dagster_census/components/census_component.py

@@ -0,0 +1,219 @@
+from collections.abc import Callable, Iterable, Sequence
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Annotated, Optional, Union
+
+import dagster as dg
+import pydantic
+from dagster._annotations import public
+from dagster._core.definitions.metadata import TableMetadataSet
+from dagster._utils.names import clean_name
+from dagster.components.component.state_backed_component import StateBackedComponent
+from dagster.components.resolved.base import resolve_fields
+from dagster.components.utils.defs_state import (
+    DefsStateConfig,
+    DefsStateConfigArgs,
+    ResolvedDefsStateConfig,
+)
+from dagster_shared import check
+from dagster_shared.serdes.serdes import deserialize_value
+
+from dagster_census.components.census_scaffolder import CensusComponentScaffolder
+from dagster_census.resources import CensusResource
+from dagster_census.translator import (
+    CensusMetadataSet,
+    CensusSync,
+    CensusWorkspaceData,
+    generate_table_schema,
+)
+
+
+class CensusSyncSelectorByName(dg.Resolvable, dg.Model):
+    by_name: Annotated[
+        Sequence[str],
+        pydantic.Field(..., description="A list of sync names to include in the collection."),
+    ]
+
+
+class CensusSyncSelectorById(dg.Resolvable, dg.Model):
+    by_id: Annotated[
+        Sequence[Union[int, str]],  # Allow strings for use-cases like '{{ env.ENV_VAR }}'
+        pydantic.Field(..., description="A list of sync IDs to include in the collection."),
+    ]
+
+
+def resolve_sync_selector(
+    context: dg.ResolutionContext, model
+) -> Optional[Callable[[CensusSync], bool]]:
+    if isinstance(model, str):
+        resolved = context.resolve_value(model)
+        resolved = check.callable_param(resolved, "unknown")  # pyright: ignore[reportArgumentType]
+        return resolved
+    if isinstance(model, CensusSyncSelectorByName.model()):
+        resolved = resolve_fields(model, CensusSyncSelectorByName.model(), context)
+        return lambda sync: sync.name in resolved["by_name"]
+    elif isinstance(model, CensusSyncSelectorById.model()):
+        resolved = resolve_fields(model, CensusSyncSelectorById.model(), context)
+        return lambda sync: sync.id in resolved["by_id"]
+    else:
+        check.failed(f"Unknown sync target type: {type(model)}")
+
+
+@dataclass
+class CensusResourceArgs(dg.Resolvable, dg.Model):
+    """The fields are analogous to the fields at `CensusResource`."""
+
+    api_key: Annotated[str, pydantic.Field(...)]
+    request_max_retries: Annotated[int, pydantic.Field(None)]
+    request_retry_delay: Annotated[float, pydantic.Field(None)]
+    request_timeout: Annotated[int, pydantic.Field(None)]
+
+
+def resolve_census_workspace(
+    context: dg.ResolutionContext, model: CensusResourceArgs
+) -> CensusResource:
+    return CensusResource(**resolve_fields(model, CensusResourceArgs, context))
+
+
+@public
+@dataclass
+@dg.scaffold_with(CensusComponentScaffolder)
+class CensusComponent(StateBackedComponent, dg.Resolvable):
+    """Loads Census syncs from a Census workspace as Dagster assets.
+    Materializing these assets will trigger the Census sync, enabling
+    you to schedule Census syncs using Dagster.
+
+    Example:
+
+        .. code-block:: yaml
+
+            # defs.yaml
+
+            type: dagster_census.CensusComponent
+            attributes:
+              workspace:
+                api_key: "{{ env.CENSUS_API_KEY }}"
+              sync_selector:
+                by_name:
+                  - my_first_sync
+                  - my_second_sync
+    """
+
+    workspace: Annotated[
+        CensusResource,
+        dg.Resolver(resolve_census_workspace, model_field_type=CensusResourceArgs),
+    ]
+
+    sync_selector: Annotated[
+        Optional[Callable[[CensusSync], bool]],
+        dg.Resolver(
+            resolve_sync_selector,
+            model_field_type=Union[
+                str, CensusSyncSelectorByName.model(), CensusSyncSelectorById.model()
+            ],
+            description="Function used to select Census syncs to pull into Dagster.",
+        ),
+    ] = None
+
+    defs_state: ResolvedDefsStateConfig = field(
+        default_factory=DefsStateConfigArgs.local_filesystem
+    )
+
+    @property
+    def defs_state_config(self) -> DefsStateConfig:
+        default_key = f"{self.__class__.__name__}"
+        return DefsStateConfig.from_args(self.defs_state, default_key=default_key)
+
+    def write_state_to_path(self, state_path: Path) -> None:
+        state = self.workspace.fetch_census_workspace_data()
+        state_path.write_text(dg.serialize_value(state))
+
+    @public
+    def get_asset_spec(self, sync: CensusSync) -> dg.AssetSpec:
+        metadata = {
+            **TableMetadataSet(
+                column_schema=generate_table_schema(sync.mappings),
+                table_name=sync.name,
+            ),
+            **CensusMetadataSet(
+                sync_id=sync.id,
+                sync_name=sync.name,
+                source_id=sync.source_id,
+                destination_id=sync.destination_id,
+            ),
+        }
+
+        return dg.AssetSpec(
+            key=dg.AssetKey(clean_name(sync.name)),
+            metadata=metadata,
+            description=f"Asset generated from Census sync {sync.id}",
+            kinds={"census"},
+        )
+
+    @public
+    def execute(
+        self, context: dg.AssetExecutionContext, census: CensusResource
+    ) -> Iterable[Union[dg.AssetMaterialization, dg.MaterializeResult]]:
+        """Executes a Census sync for the selected sync.
+
+        This method can be overridden in a subclass to customize the sync execution behavior,
+        such as adding custom logging or handling sync results differently.
+
+        Args:
+            context: The asset execution context provided by Dagster
+            census: The CensusResource used to trigger and monitor syncs
+
+        Returns:
+            MaterializeResult event from the Census sync
+
+        Example:
+            Override this method to add custom logging during sync execution:
+
+            .. code-block:: python
+
+                from dagster_census import CensusComponent
+                import dagster as dg
+
+                class CustomCensusComponent(CensusComponent):
+                    def execute(self, context, census):
+                        context.log.info(f"Starting Census sync for {context.asset_key}")
+                        result = super().execute(context, census)
+                        context.log.info("Census sync completed successfully")
+                        return result
+        """
+        # Select the first asset-spec (since there is only one)
+        spec = next(iter(context.assets_def.specs))
+
+        census_metadataset = CensusMetadataSet.extract(spec.metadata)
+        census.trigger_sync_and_poll(sync_id=census_metadataset.sync_id)
+        yield dg.AssetMaterialization(asset_key=clean_name(census_metadataset.sync_name))
+
+    def _load_asset_specs(self, state: CensusWorkspaceData) -> Sequence[dg.AssetSpec]:
+        connection_selector_fn = self.sync_selector or (lambda sync: True)
+        return [self.get_asset_spec(sync) for sync in state.syncs if connection_selector_fn(sync)]
+
+    def _get_census_assets_def(self, sync_name: str, spec: dg.AssetSpec) -> dg.AssetsDefinition:
+        @dg.multi_asset(
+            name=f"census_{clean_name(sync_name)}",
+            can_subset=True,
+            specs=[spec],
+        )
+        def _asset(context: dg.AssetExecutionContext):
+            yield from self.execute(context, self.workspace)
+
+        return _asset
+
+    def build_defs_from_state(
+        self, context: dg.ComponentLoadContext, state_path: Optional[Path]
+    ) -> dg.Definitions:
+        if state_path is None:
+            return dg.Definitions()
+
+        state = deserialize_value(state_path.read_text(), CensusWorkspaceData)
+
+        assets = [
+            self._get_census_assets_def(CensusMetadataSet.extract(spec.metadata).sync_name, spec)
+            for spec in self._load_asset_specs(state)
+        ]
+
+        return dg.Definitions(assets=assets)

dagster_census-0.28.8/dagster_census/components/census_scaffolder.py

@@ -0,0 +1,26 @@
+from typing import Optional
+
+from dagster.components.component.component_scaffolder import Scaffolder
+from dagster.components.component_scaffolding import scaffold_component
+from dagster.components.scaffold.scaffold import ScaffoldRequest
+from pydantic import BaseModel
+
+
+class CensusScaffolderParams(BaseModel):
+    api_key: Optional[str] = None
+
+
+class CensusComponentScaffolder(Scaffolder[CensusScaffolderParams]):
+    @classmethod
+    def get_scaffold_params(cls) -> type[CensusScaffolderParams]:
+        return CensusScaffolderParams
+
+    def scaffold(self, request: ScaffoldRequest[CensusScaffolderParams]) -> None:
+        scaffold_component(
+            request,
+            {
+                "workspace": {
+                    "api_key": "{{ env.CENSUS_API_KEY }}",
+                }
+            },
+        )

{dagster-census-0.19.4 → dagster_census-0.28.8}/dagster_census/ops.py

@@ -1,8 +1,9 @@
 from dagster import Array, Bool, Field, In, Noneable, Nothing, Out, Output, op
+from dagster._core.storage.tags import COMPUTE_KIND_TAG
 
-from .resources import DEFAULT_POLL_INTERVAL
-from .types import CensusOutput
-from .utils import generate_materialization
+from dagster_census.resources import DEFAULT_POLL_INTERVAL
+from dagster_census.types import CensusOutput
+from dagster_census.utils import generate_materialization
 
 
 @op(
@@ -59,7 +60,7 @@ from .utils import generate_materialization
             ),
         ),
     },
-    tags={"kind": "census"},
+    tags={COMPUTE_KIND_TAG: "census"},
 )
 def census_trigger_sync_op(context):
     """Executes a Census sync for a given ``sync_id`` and polls until that sync completes, raising

{dagster-census-0.19.4 → dagster_census-0.28.8}/dagster_census/resources.py

@@ -2,50 +2,89 @@ import datetime
 import json
 import logging
 import time
-from typing import Any, Mapping, Optional
+from collections.abc import Mapping
+from typing import Any, Optional
 
+import pydantic
 import requests
-from dagster import Failure, Field, StringSource, __version__, get_dagster_logger, resource
+from dagster import ConfigurableResource, Failure, __version__, get_dagster_logger
+from dagster_shared.utils.cached_method import cached_method
 from requests.auth import HTTPBasicAuth
 from requests.exceptions import RequestException
 
-from .types import CensusOutput
+from dagster_census.translator import CensusSync, CensusWorkspaceData
+from dagster_census.types import CensusOutput
 
 CENSUS_API_BASE = "app.getcensus.com/api"
 CENSUS_VERSION = "v1"
 
 DEFAULT_POLL_INTERVAL = 10
 
+SYNC_RUN_STATUSES = {"completed", "failed", "queued", "skipped", "working"}
 
-class CensusResource:
-    """This class exposes methods on top of the Census REST API."""
 
-    def __init__(
-        self,
-        api_key: str,
-        request_max_retries: int = 3,
-        request_retry_delay: float = 0.25,
-        log: logging.Logger = get_dagster_logger(),
-    ):
-        self.api_key = api_key
+class CensusResource(ConfigurableResource):
+    """This resource allows users to programatically interface with the Census REST API to launch
+    syncs and monitor their progress. This currently implements only a subset of the functionality
+    exposed by the API.
 
-        self._request_max_retries = request_max_retries
-        self._request_retry_delay = request_retry_delay
+    **Examples:**
 
-        self._log = log
+    .. code-block:: python
 
-    @property
-    def _api_key(self):
-        if self.api_key.startswith("secret-token:"):
-            return self.api_key
-        return "secret-token:" + self.api_key
+        import dagster as dg
+        from dagster_census import CensusResource
+
+        census_resource = CensusResource(
+            api_key=dg.EnvVar("CENSUS_API_KEY")
+        )
+
+        @dg.asset
+        def census_sync_asset(census: CensusResource):
+            census.trigger_sync_and_poll(sync_id=123456)
+
+        defs = dg.Definitions(
+            assets=[census_sync_asset],
+            resources={"census": census_resource}
+        )
+    """
+
+    api_key: str = pydantic.Field(..., description="The Census API key")
+    request_max_retries: int = pydantic.Field(
+        default=3,
+        description=(
+            "The maximum number of times requests to the Census API should be retried "
+            "before failing."
+        ),
+    )
+    request_retry_delay: float = pydantic.Field(
+        default=0.25,
+        description="Time (in seconds) to wait between each request retry.",
+    )
+    request_timeout: int = pydantic.Field(
+        default=15,
+        description="Time (in seconds) after which the requests to Census are declared timed out.",
+    )
 
     @property
     def api_base_url(self) -> str:
         return f"https://{CENSUS_API_BASE}/{CENSUS_VERSION}"
 
+    @classmethod
+    def _is_dagster_maintained(cls) -> bool:
+        return True
+
+    @property
+    @cached_method
+    def _log(self) -> logging.Logger:
+        return get_dagster_logger()
+
     def make_request(
-        self, method: str, endpoint: str, data: Optional[str] = None
+        self,
+        method: str,
+        endpoint: str,
+        data: Optional[str] = None,
+        page_number: Optional[int] = None,
     ) -> Mapping[str, Any]:
         """Creates and sends a request to the desired Census API endpoint.
 
@@ -63,6 +102,11 @@ class CensusResource:
             "Content-Type": "application/json;version=2",
         }
 
+        if page_number is not None:
+            params = {"page": page_number}
+        else:
+            params = {}
+
         num_retries = 0
         while True:
             try:
@@ -70,19 +114,20 @@ class CensusResource:
                     method=method,
                     url=url,
                     headers=headers,
-                    auth=HTTPBasicAuth("bearer", self._api_key),
+                    auth=HTTPBasicAuth("bearer", self.api_key),
                     data=data,
+                    params=params,
                 )
                 response.raise_for_status()
                 return response.json()
             except RequestException as e:
                 self._log.error("Request to Census API failed: %s", e)
-                if num_retries == self._request_max_retries:
+                if num_retries == self.request_max_retries:
                     break
                 num_retries += 1
-                time.sleep(self._request_retry_delay)
+                time.sleep(self.request_retry_delay)
 
-        raise Failure(f"Max retries ({self._request_max_retries}) exceeded with url: {url}.")
+        raise Failure(f"Max retries ({self.request_max_retries}) exceeded with url: {url}.")
 
     def get_sync(self, sync_id: int) -> Mapping[str, Any]:
         """Gets details about a given sync from the Census API.
@@ -157,9 +202,18 @@ class CensusResource:
                     " more."
                 )
 
+            sync_status = response_dict["data"]["status"]
             sync_id = response_dict["data"]["sync_id"]
 
-            if response_dict["data"]["status"] == "working":
+            if sync_status not in SYNC_RUN_STATUSES:
+                raise ValueError(
+                    f"Unexpected response status '{sync_status}'; "
+                    f"must be one of {','.join(sorted(SYNC_RUN_STATUSES))}. "
+                    "See Management API docs for more information: "
+                    "https://docs.getcensus.com/basics/developers/api/sync-runs"
+                )
+
+            if sync_status in {"queued", "working"}:
                 self._log.debug(
                     f"Sync {sync_id} still running after {datetime.datetime.now() - poll_start}."
                 )
@@ -237,56 +291,32 @@ class CensusResource:
             destination=destination_details,
         )
 
+    @cached_method
+    def fetch_census_workspace_data(self) -> CensusWorkspaceData:
+        """Retrieves all Census syncs from the workspace and returns it as a CensusWorkspaceData object.
 
-@resource(
-    config_schema={
-        "api_key": Field(
-            StringSource,
-            is_required=True,
-            description="Census API Key.",
-        ),
-        "request_max_retries": Field(
-            int,
-            default_value=3,
-            description=(
-                "The maximum number of times requests to the Census API should be retried "
-                "before failing."
-            ),
-        ),
-        "request_retry_delay": Field(
-            float,
-            default_value=0.25,
-            description="Time (in seconds) to wait between each request retry.",
-        ),
-    },
-    description="This resource helps manage Census connectors",
-)
-def census_resource(context) -> CensusResource:
-    """This resource allows users to programatically interface with the Census REST API to launch
-    syncs and monitor their progress. This currently implements only a subset of the functionality
-    exposed by the API.
-
-    **Examples:**
-
-    .. code-block:: python
-
-        from dagster import job
-        from dagster_census import census_resource
-
-        my_census_resource = census_resource.configured(
-            {
-                "api_key": {"env": "CENSUS_API_KEY"},
-            }
+        Returns:
+            CensusWorkspaceData: A snapshot of the Census workspace's syncs.
+        """
+        all_syncs = []
+        page = self.make_request(method="GET", endpoint="syncs")
+
+        last_page_number = page["pagination"]["last_page"]
+        for sync in page["data"]:
+            all_syncs.append(self._census_sync_struct_from_json(sync))
+
+        for i in range(2, last_page_number + 1):
+            page = self.make_request(method="GET", endpoint="syncs", page_number=i)
+            for sync in page["data"]:
+                all_syncs.append(self._census_sync_struct_from_json(sync))
+
+        return CensusWorkspaceData(syncs=all_syncs)
+
+    def _census_sync_struct_from_json(self, sync: dict[str, Any]) -> CensusSync:
+        return CensusSync(
+            id=sync["id"],
+            name=sync["label"] or sync["resource_identifier"],
+            source_id=sync["source_attributes"]["connection_id"],
+            destination_id=sync["destination_attributes"]["connection_id"],
+            mappings=sync["mappings"],
         )
-
-        @job(resource_defs={"census":my_census_resource})
-        def my_census_job():
-            ...
-
-    """
-    return CensusResource(
-        api_key=context.resource_config["api_key"],
-        request_max_retries=context.resource_config["request_max_retries"],
-        request_retry_delay=context.resource_config["request_retry_delay"],
-        log=context.log,
-    )

dagster_census-0.28.8/dagster_census/translator.py

@@ -0,0 +1,57 @@
+from collections.abc import Mapping
+from typing import Any
+
+import dagster as dg
+from dagster._core.definitions.metadata.metadata_set import NamespacedMetadataSet
+from dagster._record import record
+from dagster_shared.serdes import whitelist_for_serdes
+
+
+@whitelist_for_serdes
+@record
+class CensusSync:
+    """Represents a Census sync, based on data as returned from the API."""
+
+    id: int
+    name: str
+    source_id: int
+    destination_id: int
+    mappings: list[dict[str, Any]]
+
+
+@whitelist_for_serdes
+@record
+class CensusWorkspaceData:
+    """A record representing all content in a Census workspace.
+    Provided as context for the translator so that it can resolve dependencies between content.
+    """
+
+    syncs: list[CensusSync]
+
+    @property
+    def syncs_by_id(self) -> Mapping[int, CensusSync]:
+        """Returns a mapping of sync IDs to CensusSync objects."""
+        return {sync.id: sync for sync in self.syncs}
+
+
+def generate_table_schema(sync_mappings_props: list[dict[str, Any]]) -> dg.TableSchema:
+    return dg.TableSchema(
+        columns=sorted(
+            [
+                dg.TableColumn(name=mapping["to"], type=mapping.get("field_type", "unknown"))
+                for mapping in sync_mappings_props
+            ],
+            key=lambda col: col.name,
+        )
+    )
+
+
+class CensusMetadataSet(NamespacedMetadataSet):
+    sync_id: int
+    sync_name: str
+    source_id: int
+    destination_id: int
+
+    @classmethod
+    def namespace(cls) -> str:
+        return "dagster-census"

{dagster-census-0.19.4 → dagster_census-0.28.8}/dagster_census/types.py

@@ -1,4 +1,5 @@
-from typing import Any, Mapping, NamedTuple
+from collections.abc import Mapping
+from typing import Any, NamedTuple
 
 
 class CensusOutput(
@@ -13,7 +14,7 @@ class CensusOutput(
 ):
     """Contains recorded information about the state of a Census sync after a sync completes.
 
-    Attributes:
+    Args:
         sync_run (Dict[str, Any]):
             The details of the specific sync run.
         source (Dict[str, Any]):

{dagster-census-0.19.4 → dagster_census-0.28.8}/dagster_census/utils.py

@@ -1,8 +1,8 @@
-from typing import Sequence
+from collections.abc import Sequence
 
 from dagster import AssetMaterialization
 
-from .types import CensusOutput
+from dagster_census.types import CensusOutput
 
 
 def generate_materialization(

dagster_census-0.28.8/dagster_census/version.py

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

dagster_census-0.28.8/dagster_census.egg-info/PKG-INFO

@@ -0,0 +1,27 @@
+Metadata-Version: 2.4
+Name: dagster-census
+Version: 0.28.8
+Summary: Package for integrating Census with Dagster.
+Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-census
+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: Programming Language :: Python :: 3.14
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.10,<3.15
+License-File: LICENSE
+Requires-Dist: dagster==1.12.8
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

{dagster-census-0.19.4 → dagster_census-0.28.8}/dagster_census.egg-info/SOURCES.txt

@@ -4,7 +4,9 @@ setup.cfg
 setup.py
 dagster_census/__init__.py
 dagster_census/ops.py
+dagster_census/py.typed
 dagster_census/resources.py
+dagster_census/translator.py
 dagster_census/types.py
 dagster_census/utils.py
 dagster_census/version.py
@@ -13,4 +15,7 @@ dagster_census.egg-info/SOURCES.txt
 dagster_census.egg-info/dependency_links.txt
 dagster_census.egg-info/not-zip-safe
 dagster_census.egg-info/requires.txt
-dagster_census.egg-info/top_level.txt
+dagster_census.egg-info/top_level.txt
+dagster_census/components/__init__.py
+dagster_census/components/census_component.py
+dagster_census/components/census_scaffolder.py

dagster_census-0.28.8/dagster_census.egg-info/requires.txt

@@ -0,0 +1 @@
+dagster==1.12.8

{dagster-census-0.19.4 → dagster_census-0.28.8}/setup.py

@@ -1,11 +1,10 @@
 from pathlib import Path
-from typing import Dict
 
 from setuptools import find_packages, setup
 
 
 def get_version() -> str:
-    version: Dict[str, str] = {}
+    version: dict[str, str] = {}
     with open(Path(__file__).parent / "dagster_census/version.py", encoding="utf8") as fp:
         exec(fp.read(), version)
 
@@ -18,21 +17,23 @@ pin = "" if ver == "1!0+dev" else f"=={ver}"
 setup(
     name="dagster-census",
     version=ver,
-    author="Elementl",
-    author_email="hello@elementl.com",
+    author="Dagster Labs",
+    author_email="hello@dagsterlabs.com",
     license="Apache-2.0",
     description="Package for integrating Census with Dagster.",
     url="https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-census",
     classifiers=[
-        "Programming Language :: Python :: 3.7",
-        "Programming Language :: Python :: 3.8",
-        "Programming Language :: Python :: 3.9",
         "Programming Language :: Python :: 3.10",
         "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Programming Language :: Python :: 3.13",
+        "Programming Language :: Python :: 3.14",
         "License :: OSI Approved :: Apache Software License",
         "Operating System :: OS Independent",
     ],
     packages=find_packages(exclude=["dagster_census_tests*"]),
-    install_requires=["dagster==1.3.4"],
+    include_package_data=True,
+    python_requires=">=3.10,<3.15",
+    install_requires=["dagster==1.12.8"],
     zip_safe=False,
 )

dagster-census-0.19.4/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: dagster-census
-Version: 0.19.4
-Summary: Package for integrating Census with Dagster.
-Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-census
-Author: Elementl
-Author-email: hello@elementl.com
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-License-File: LICENSE

dagster-census-0.19.4/dagster_census/__init__.py

@@ -1,15 +0,0 @@
-from dagster._core.libraries import DagsterLibraryRegistry
-
-from .ops import census_trigger_sync_op
-from .resources import CensusResource, census_resource
-from .types import CensusOutput
-from .version import __version__
-
-DagsterLibraryRegistry.register("dagster-census", __version__)
-
-__all__ = [
-    "CensusResource",
-    "CensusOutput",
-    "census_resource",
-    "census_trigger_sync_op",
-]

dagster-census-0.19.4/dagster_census/version.py

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

dagster-census-0.19.4/dagster_census.egg-info/PKG-INFO

@@ -1,16 +0,0 @@
-Metadata-Version: 2.1
-Name: dagster-census
-Version: 0.19.4
-Summary: Package for integrating Census with Dagster.
-Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-census
-Author: Elementl
-Author-email: hello@elementl.com
-License: Apache-2.0
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
-Classifier: License :: OSI Approved :: Apache Software License
-Classifier: Operating System :: OS Independent
-License-File: LICENSE

dagster-census-0.19.4/dagster_census.egg-info/requires.txt

@@ -1 +0,0 @@
-dagster==1.3.4