{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"pypi_pypi-dagster","slug":"pypi-dagster","name":"dagster","type":"framework","url":"https://pypi.org/project/dagster/","page_url":"https://unfragile.ai/pypi-dagster","categories":["data-pipelines","deployment-infra"],"tags":[],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"pypi_pypi-dagster__cap_0","uri":"capability://automation.workflow.declarative.asset.definition.and.dependency.graph.construction","name":"declarative asset definition and dependency graph construction","description":"Enables developers to define data assets as Python functions decorated with @asset, automatically constructing a directed acyclic graph (DAG) of dependencies through function parameter matching and explicit asset_deps declarations. The system parses asset definitions at load time, resolves dependencies via asset keys, and builds an in-memory graph representation that tracks lineage, partitioning schemes, and materialization requirements without requiring manual DAG specification.","intents":["Define data pipelines as pure Python functions without boilerplate DAG construction","Automatically track data lineage and dependencies between assets","Organize related assets into logical groups with shared configuration","Enable IDE autocomplete and type checking for asset dependencies"],"best_for":["Data engineers building modular, maintainable data pipelines","Teams migrating from Airflow who want simpler dependency declaration","Organizations needing automatic lineage tracking for governance"],"limitations":["Circular dependencies are detected at definition time but cannot be resolved; requires manual refactoring","Dynamic asset creation (runtime-determined asset counts) requires AssetSelection or dynamic partitions, adding complexity","Asset key resolution is string-based; typos in asset names cause runtime failures, not compile-time errors"],"requires":["Python 3.9+","dagster package installed","Definitions object or Definitions class to load assets into workspace"],"input_types":["Python function definitions","Asset key specifications (strings or AssetKey objects)","Partition definitions (StaticPartitionsDefinition, DynamicPartitionsDefinition)"],"output_types":["AssetSelection objects","Asset graph representation (internal)","Materialization events"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_1","uri":"capability://data.processing.analysis.multi.dimensional.asset.partitioning.with.dynamic.partition.support","name":"multi-dimensional asset partitioning with dynamic partition support","description":"Implements a sophisticated partitioning system allowing assets to be divided across time-based (daily, hourly), static categorical, or dynamically-generated partitions, with support for multi-dimensional partitioning (e.g., date × region). The system tracks partition state, enables targeted backfills, and optimizes execution by only materializing changed partitions. Partition definitions are composable and integrate with the asset graph to automatically determine which partitions need execution.","intents":["Partition large datasets by time to enable incremental processing and backfills","Create multi-dimensional partitions (e.g., date and geography) for complex data models","Dynamically add new partitions at runtime without redefining the asset","Execute only changed partitions to reduce compute costs and improve performance"],"best_for":["Data teams processing time-series data with incremental updates","Organizations with multi-tenant or multi-region data architectures","Teams needing fine-grained control over which data subsets to recompute"],"limitations":["Dynamic partitions require a DynamicPartitionsDefinition with explicit partition key generation; cannot infer partitions from data","Partition pruning is manual via AssetSelection; no automatic detection of which partitions changed upstream","Multi-dimensional partitioning adds complexity to backfill logic; cross-partition dependencies require careful modeling"],"requires":["Python 3.9+","dagster package with partitions module","DagsterInstance configured with run storage to track partition state"],"input_types":["PartitionsDefinition objects (TimeWindowPartitionsDefinition, StaticPartitionsDefinition, DynamicPartitionsDefinition)","Partition keys (strings or tuples for multi-dimensional)","Asset definitions with partition_key_range context"],"output_types":["Partition state metadata","Backfill runs targeting specific partitions","Partition-aware materialization events"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_10","uri":"capability://safety.moderation.asset.health.and.freshness.tracking.with.automated.alerts","name":"asset health and freshness tracking with automated alerts","description":"Tracks asset freshness (time since last materialization) and health status (latest run success/failure) via the asset health system. Freshness policies define expected materialization intervals (e.g., daily); the system compares actual freshness against policies and marks assets as stale. Health status is queryable via GraphQL and can trigger alerts via sensors. Integration with external systems (Slack, PagerDuty) enables notifications when assets become unhealthy.","intents":["Monitor asset freshness and alert when data becomes stale","Track asset health status (healthy, stale, failed) in dashboards","Automatically trigger remediation (re-materialization) for stale assets","Integrate asset health into incident management workflows"],"best_for":["Data teams needing SLA enforcement for asset freshness","Organizations with critical data assets requiring high availability","Data platforms building asset monitoring dashboards"],"limitations":["Freshness policies are static; no support for dynamic SLAs based on asset properties","Health status is computed on-demand; no background health check process","Alert integration requires custom sensor code; no built-in Slack/PagerDuty connectors"],"requires":["Python 3.9+","Assets with FreshnessPolicy defined","DagsterInstance with event log storage","Sensor for alert integration (optional)"],"input_types":["FreshnessPolicy definitions (time windows)","Asset materialization events","Health status queries"],"output_types":["Asset freshness status (fresh, stale, missing)","Health status (healthy, unhealthy)","Alert notifications (via custom sensors)"],"categories":["safety-moderation","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_11","uri":"capability://planning.reasoning.dynamic.asset.selection.and.targeted.execution","name":"dynamic asset selection and targeted execution","description":"Provides AssetSelection API enabling programmatic selection of assets based on keys, tags, groups, or custom predicates. Selections can be composed (union, intersection, difference) and used to target specific assets for execution, backfills, or queries. The system resolves dependencies automatically, ensuring upstream assets are included in execution. Selections are queryable via GraphQL, enabling external systems to discover which assets will be executed.","intents":["Select subsets of assets for execution without modifying pipeline code","Build dynamic asset groups based on tags or naming patterns","Execute only assets matching specific criteria (e.g., 'all assets in the analytics group')","Programmatically determine which assets will be executed before submitting runs"],"best_for":["Teams with large asset graphs needing flexible execution targeting","Organizations building custom orchestration logic on top of Dagster","Data platforms enabling self-service asset execution"],"limitations":["AssetSelection is evaluated at execution time; no static analysis of selection correctness","Dependency resolution is automatic but opaque; difficult to debug which assets are included","No support for conditional selections based on asset state or external data"],"requires":["Python 3.9+","Asset definitions with keys, tags, or groups","AssetSelection API"],"input_types":["Asset keys, tags, or groups","Custom predicates (functions)","Selection composition operators"],"output_types":["AssetSelection objects","Resolved asset lists with dependencies","Execution plans"],"categories":["planning-reasoning","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_12","uri":"capability://tool.use.integration.configuration.management.with.environment.specific.overrides","name":"configuration management with environment-specific overrides","description":"Implements a configuration system enabling assets, resources, and jobs to accept configuration dictionaries at definition or execution time. Configuration is specified via ConfigurableResource base class or @resource decorator, with schema validation via Pydantic. Environment-specific configs are loaded from YAML files or environment variables, enabling dev/staging/prod deployments without code changes. Configuration is resolved at execution time and injected into asset context.","intents":["Define environment-specific configuration (database URLs, API endpoints) without hardcoding","Validate configuration schema at definition time","Override configuration at execution time via run config","Load configuration from external sources (environment variables, config files)"],"best_for":["Teams deploying pipelines across multiple environments","Organizations with strict configuration management requirements","Data platforms enabling user-provided configuration"],"limitations":["Configuration schema is defined in Python; no support for external schema definitions","Configuration validation is Pydantic-based; complex validation logic requires custom validators","Run config overrides are not persisted; restarting Dagster loses overrides"],"requires":["Python 3.9+","ConfigurableResource or @resource decorator","Pydantic for schema validation"],"input_types":["Configuration dictionaries","YAML config files","Environment variables","Run config overrides"],"output_types":["Validated configuration objects","Resolved resource instances","Configuration metadata"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_13","uri":"capability://memory.knowledge.asset.versioning.and.lineage.tracking.with.data.contracts","name":"asset versioning and lineage tracking with data contracts","description":"Tracks asset versions based on code changes, enabling detection of when asset definitions change and triggering re-materialization of downstream assets. Asset lineage is reconstructed from event logs, showing data flow across the pipeline. Data contracts (input/output schemas) can be defined on assets, with validation at execution time to detect schema mismatches. Lineage is queryable via GraphQL and visualizable in the UI.","intents":["Detect when asset definitions change and automatically re-materialize downstream assets","Track data lineage across the pipeline for governance and debugging","Validate asset inputs/outputs against defined schemas","Visualize data flow and dependencies in the UI"],"best_for":["Organizations with strict data governance requirements","Teams needing automatic downstream re-materialization on schema changes","Data platforms building data catalogs with lineage"],"limitations":["Asset versioning is based on code hash; changes to comments or formatting trigger re-materialization","Data contracts are optional; no enforcement of schema validation","Lineage reconstruction from event logs is expensive for large pipelines"],"requires":["Python 3.9+","Asset definitions with optional input/output schemas","DagsterInstance with event log storage"],"input_types":["Asset definitions with code","Input/output schema definitions","Event logs"],"output_types":["Asset version identifiers","Lineage graphs","Schema validation results"],"categories":["memory-knowledge","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_2","uri":"capability://data.processing.analysis.event.driven.asset.materialization.with.rich.metadata.and.observability","name":"event-driven asset materialization with rich metadata and observability","description":"Captures detailed execution events (AssetMaterializationEvent, DagsterEventType) during asset computation, including execution time, data quality metrics, row counts, and custom metadata. Events are persisted to configurable event log storage (SQLite, PostgreSQL, in-memory) and queryable via GraphQL, enabling real-time monitoring, data lineage reconstruction, and post-execution analysis without requiring external observability tools.","intents":["Track when assets were last materialized and by which run","Capture data quality metrics (row counts, null percentages) alongside materialization","Query asset execution history and debug failed runs via GraphQL","Build custom dashboards showing asset health and freshness"],"best_for":["Teams needing built-in observability without external monitoring tools","Organizations with strict data governance requiring complete execution audit trails","Data platforms building custom dashboards on top of Dagster"],"limitations":["Event log storage scales linearly with run volume; high-frequency pipelines (>1000 runs/day) may require database tuning","Event log queries via GraphQL have no built-in pagination limits; large result sets require manual pagination implementation","Custom metadata is stored as JSON; no schema validation or type safety for metadata fields"],"requires":["Python 3.9+","DagsterInstance with configured event_log_storage (defaults to SQLite)","PostgreSQL or SQLite for persistent event storage; in-memory storage loses data on restart"],"input_types":["AssetMaterializationEvent objects","Custom metadata dictionaries","DagsterEventType enums"],"output_types":["Event log records (persisted to storage)","GraphQL query results","Materialization timestamps and metadata"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_3","uri":"capability://automation.workflow.sensor.based.and.schedule.based.declarative.automation","name":"sensor-based and schedule-based declarative automation","description":"Provides two complementary automation mechanisms: Sensors poll external systems (databases, APIs, file systems) on a configurable interval to detect changes and trigger asset materialization, while Schedules execute assets on cron expressions or custom timing logic. Both are defined as Python functions decorated with @sensor or @schedule, integrated into the asset daemon that runs continuously to evaluate automation rules and submit runs to the executor.","intents":["Automatically materialize assets when upstream data changes (e.g., new files in S3)","Run assets on fixed schedules (daily, hourly) without manual triggering","Implement custom logic to decide whether to trigger materialization based on conditions","Monitor external systems and react to state changes in real-time"],"best_for":["Teams with event-driven data pipelines reacting to external changes","Organizations running scheduled batch jobs (ETL, reporting)","Data platforms needing flexible automation rules beyond simple cron"],"limitations":["Sensors poll on fixed intervals; cannot react to events faster than the polling period (default 30s)","Sensor state is stored in DagsterInstance; distributed sensor deployments require shared state store","Schedule and sensor evaluation happens in a single asset daemon process; no built-in horizontal scaling"],"requires":["Python 3.9+","DagsterInstance with asset daemon enabled","Executor configured to accept runs (in-process, multiprocess, or remote)"],"input_types":["Sensor functions with SensorExecutionContext","Schedule definitions with cron expressions or custom timing","Asset selections to target specific assets"],"output_types":["RunRequest objects triggering asset materialization","SkipReason objects to skip execution","Sensor tick records (success/failure/skipped)"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_4","uri":"capability://tool.use.integration.resource.based.dependency.injection.and.i.o.manager.abstraction","name":"resource-based dependency injection and i/o manager abstraction","description":"Implements a dependency injection system where assets and ops declare required resources (databases, APIs, cloud storage) as function parameters, resolved at execution time from a configured resource dictionary. I/O managers abstract data persistence, enabling assets to read/write data to configurable backends (filesystem, S3, Snowflake, BigQuery) without hardcoding storage logic. Resources are scoped (process, step) and support initialization/cleanup hooks, enabling connection pooling and resource lifecycle management.","intents":["Inject database connections, API clients, or cloud credentials into assets without hardcoding","Swap storage backends (local filesystem → S3 → Snowflake) via configuration without code changes","Share expensive resources (database connections) across multiple assets in a run","Implement custom I/O managers for proprietary data formats or storage systems"],"best_for":["Teams deploying pipelines across multiple environments (dev/staging/prod) with different storage","Organizations with custom data formats or storage systems requiring custom I/O managers","Data platforms needing fine-grained control over resource lifecycle and connection pooling"],"limitations":["Resource resolution is dynamic; type hints are not enforced at definition time, leading to runtime failures if resources are missing","I/O managers are asset-specific; no built-in mechanism to apply a manager to multiple assets without explicit configuration","Resource initialization happens per-run; expensive resources (large model downloads) cannot be cached across runs"],"requires":["Python 3.9+","Resource definitions with @resource decorator or ResourceDefinition class","IOManager implementations for target storage systems"],"input_types":["Resource definitions (functions or classes)","IOManager implementations","Configuration dictionaries mapping resource names to implementations"],"output_types":["Resolved resource instances injected into asset context","Persisted data via I/O managers","Resource initialization/cleanup events"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_5","uri":"capability://search.retrieval.graphql.based.asset.and.run.querying.with.workspace.context","name":"graphql-based asset and run querying with workspace context","description":"Exposes a comprehensive GraphQL API (dagster_graphql package) enabling queries on asset definitions, run history, event logs, and partition state. Queries execute against DagsterInstance storage, supporting filtering by asset key, run status, time range, and partition. The API includes mutations for triggering runs, launching backfills, and managing dynamic partitions. Workspace context provides multi-tenant isolation and permission scoping, enabling role-based access control in cloud deployments.","intents":["Query asset lineage and dependencies programmatically","Retrieve run history and event logs for analysis and debugging","Trigger asset materialization or backfills via API","Build custom dashboards and monitoring tools on top of Dagster data"],"best_for":["Teams building custom monitoring dashboards or data catalogs","Organizations integrating Dagster with external systems (Slack, PagerDuty, data catalogs)","Data platforms providing multi-tenant access with role-based permissions"],"limitations":["GraphQL queries are not optimized for large result sets; querying 10k+ runs requires pagination and multiple requests","Workspace context and permissions are implemented at the API layer; no fine-grained field-level access control","GraphQL schema changes require client updates; no built-in versioning or deprecation warnings"],"requires":["Python 3.9+","dagster-graphql package","DagsterInstance with event log and run storage configured","HTTP client to query GraphQL endpoint (curl, Python requests, Apollo Client)"],"input_types":["GraphQL query strings","Asset keys and run IDs","Filter criteria (status, time range, partition)"],"output_types":["JSON-serialized asset definitions and run data","Event log records","Mutation results (run IDs, backfill IDs)"],"categories":["search-retrieval","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_6","uri":"capability://tool.use.integration.dbt.integration.with.asset.materialization.and.metadata.sync","name":"dbt integration with asset materialization and metadata sync","description":"Integrates dbt projects as Dagster assets via the dagster-dbt library, automatically loading dbt models as asset definitions and tracking their dependencies. The integration captures dbt metadata (column descriptions, tests, freshness) and syncs it into Dagster's asset system. Supports dbt cloud execution via API or local dbt CLI invocation, with event parsing to capture dbt test results and model execution metrics as Dagster events.","intents":["Treat dbt models as Dagster assets with automatic dependency resolution","Orchestrate dbt runs alongside Python assets in a unified pipeline","Capture dbt test results and model metrics as Dagster events for observability","Sync dbt metadata (column descriptions, tests) into Dagster's asset catalog"],"best_for":["Analytics teams using dbt with Python data pipelines","Organizations migrating from dbt-only orchestration to unified data platforms","Teams needing dbt metadata in a centralized asset catalog"],"limitations":["dbt metadata sync is one-directional (dbt → Dagster); changes in Dagster are not reflected back to dbt","dbt Cloud execution requires API token and network access; local execution requires dbt CLI installed","dbt test results are parsed from dbt output; schema changes in dbt versions may break parsing"],"requires":["Python 3.9+","dagster-dbt package","dbt project with dbt_project.yml","dbt CLI installed (for local execution) or dbt Cloud API token (for cloud execution)"],"input_types":["dbt project directory","dbt manifest.json (generated by dbt parse)","dbt Cloud API credentials"],"output_types":["Asset definitions for dbt models","dbt test results as Dagster events","Model execution metrics and metadata"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_7","uri":"capability://tool.use.integration.pipes.framework.for.external.process.execution.and.event.streaming","name":"pipes framework for external process execution and event streaming","description":"Provides the Pipes framework (dagster-pipes package) enabling Dagster to orchestrate external processes (Spark jobs, Kubernetes pods, Lambda functions) while capturing their output as Dagster events. External processes write events to stdout in a structured format, which Dagster parses and converts to AssetMaterializationEvent, DagsterEventType, and custom events. Supports multiple execution contexts (Kubernetes, ECS, Spark) with language-agnostic client libraries (Python, Java, Go).","intents":["Orchestrate Spark jobs, Kubernetes pods, or Lambda functions as Dagster assets","Capture logs and metrics from external processes as Dagster events","Execute code in languages other than Python (Java, Scala, Go) within Dagster pipelines","Stream execution progress and custom events from external processes in real-time"],"best_for":["Teams running Spark jobs or Kubernetes workloads orchestrated by Dagster","Organizations with polyglot data pipelines (Python + Java + Go)","Data platforms needing to integrate external systems without custom adapters"],"limitations":["External processes must be modified to use Pipes client libraries; legacy code requires wrapping","Event streaming is unidirectional (external → Dagster); no mechanism for external processes to query Dagster state","Pipes clients are language-specific; not all languages have official implementations"],"requires":["Python 3.9+ (for Dagster side)","dagster-pipes package","Pipes client library for target language (Python, Java, Go)","Execution environment (Kubernetes, ECS, Spark, Lambda)"],"input_types":["External process invocation (subprocess, Kubernetes pod spec, Spark job)","Pipes client initialization with context","Custom event definitions"],"output_types":["AssetMaterializationEvent from external process","Custom events and logs","Process exit code and status"],"categories":["tool-use-integration","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_8","uri":"capability://automation.workflow.asset.backfill.orchestration.with.partition.aware.execution","name":"asset backfill orchestration with partition-aware execution","description":"Implements a backfill system enabling targeted re-execution of asset partitions across time ranges or custom selections. Backfills are submitted as BackfillRequest objects specifying asset selection and partition range, then executed by the executor with automatic dependency resolution. The system tracks backfill progress, enables cancellation, and optimizes execution by only materializing partitions that don't already exist or have changed upstream.","intents":["Re-execute assets for a historical date range (e.g., last 90 days)","Backfill newly added assets without re-running the entire pipeline","Recover from failed partitions without full re-execution","Test asset changes against historical data before deploying to production"],"best_for":["Data teams needing to recompute historical data after schema changes","Organizations adding new assets to existing pipelines","Teams testing pipeline changes against historical data"],"limitations":["Backfill execution is sequential by default; parallel execution requires executor configuration","Backfill progress is not persisted; restarting Dagster loses backfill state","No built-in cost estimation; large backfills can consume significant compute without warning"],"requires":["Python 3.9+","Assets with PartitionsDefinition","Executor configured to accept runs","DagsterInstance with run storage"],"input_types":["BackfillRequest with asset selection and partition range","AssetSelection objects","Partition definitions"],"output_types":["Backfill ID and status","Run records for each partition","Backfill progress tracking"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"pypi_pypi-dagster__cap_9","uri":"capability://automation.workflow.multi.process.and.distributed.executor.with.resource.allocation","name":"multi-process and distributed executor with resource allocation","description":"Provides pluggable executors (in-process, multiprocess, Kubernetes, Celery) that determine how ops and assets are executed. The multiprocess executor spawns worker processes for parallel execution with configurable concurrency limits and resource tags. Kubernetes executor submits jobs as Kubernetes pods with resource requests/limits. Executors integrate with the run launcher to manage process lifecycle, capture output, and handle failures with configurable retry logic.","intents":["Execute assets in parallel to reduce total pipeline runtime","Distribute execution across multiple machines for scalability","Allocate compute resources (CPU, memory) to specific assets","Implement custom execution logic for specialized environments (GPU clusters, HPC)"],"best_for":["Teams with large, parallelizable pipelines needing distributed execution","Organizations running Dagster on Kubernetes or cloud infrastructure","Data platforms requiring fine-grained resource allocation per asset"],"limitations":["Multiprocess executor requires shared filesystem for run storage; not suitable for cloud-native deployments","Kubernetes executor requires cluster access and pod creation permissions; adds operational complexity","Resource allocation is declarative (tags) but not enforced; executor must respect tags"],"requires":["Python 3.9+","Executor configuration in job or asset definition","For Kubernetes: Kubernetes cluster and kubeconfig","For Celery: Celery broker (Redis, RabbitMQ)"],"input_types":["Executor configuration (ExecutorDefinition)","Resource tags on ops/assets","Run requests with execution context"],"output_types":["Process/pod execution status","Captured stdout/stderr logs","Resource utilization metrics"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":31,"verified":false,"data_access_risk":"high","permissions":["Python 3.9+","dagster package installed","Definitions object or Definitions class to load assets into workspace","dagster package with partitions module","DagsterInstance configured with run storage to track partition state","Assets with FreshnessPolicy defined","DagsterInstance with event log storage","Sensor for alert integration (optional)","Asset definitions with keys, tags, or groups","AssetSelection API"],"failure_modes":["Circular dependencies are detected at definition time but cannot be resolved; requires manual refactoring","Dynamic asset creation (runtime-determined asset counts) requires AssetSelection or dynamic partitions, adding complexity","Asset key resolution is string-based; typos in asset names cause runtime failures, not compile-time errors","Dynamic partitions require a DynamicPartitionsDefinition with explicit partition key generation; cannot infer partitions from data","Partition pruning is manual via AssetSelection; no automatic detection of which partitions changed upstream","Multi-dimensional partitioning adds complexity to backfill logic; cross-partition dependencies require careful modeling","Freshness policies are static; no support for dynamic SLAs based on asset properties","Health status is computed on-demand; no background health check process","Alert integration requires custom sensor code; no built-in Slack/PagerDuty connectors","AssetSelection is evaluated at execution time; no static analysis of selection correctness","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.05,"quality":0.5,"ecosystem":0.49999999999999994,"match_graph":0.25,"freshness":0.52,"weights":{"adoption":0.3,"quality":0.2,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:25.060Z","last_scraped_at":"2026-05-03T15:20:22.334Z","last_commit":null},"community":{"stars":null,"forks":null,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=pypi-dagster","compare_url":"https://unfragile.ai/compare?artifact=pypi-dagster"}},"signature":"HLhKrS98TbuUwkCk57coUBxJebDNjHD61LlYbu6WjVm9LlZkS8IcZs+Mgx7+tu4EsgdNc8c9fJSngKcVErLdDw==","signedAt":"2026-06-20T20:23:55.406Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/pypi-dagster","artifact":"https://unfragile.ai/pypi-dagster","verify":"https://unfragile.ai/api/v1/verify?slug=pypi-dagster","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}