dagster-postgres 0.19.2__py3-none-any.whl → 0.28.11__py3-none-any.whl

dagster_postgres/__init__.py

@@ -1,10 +1,10 @@
-from dagster._core.libraries import DagsterLibraryRegistry
+from dagster_shared.libraries import DagsterLibraryRegistry
 
-from .event_log import PostgresEventLogStorage
-from .run_storage import PostgresRunStorage
-from .schedule_storage import PostgresScheduleStorage
-from .storage import DagsterPostgresStorage
-from .version import __version__
+from dagster_postgres.event_log import PostgresEventLogStorage
+from dagster_postgres.run_storage import PostgresRunStorage
+from dagster_postgres.schedule_storage import PostgresScheduleStorage
+from dagster_postgres.storage import DagsterPostgresStorage
+from dagster_postgres.version import __version__
 
 DagsterLibraryRegistry.register("dagster-postgres", __version__)
 __all__ = [

dagster_postgres/alembic/alembic.ini

@@ -8,11 +8,11 @@ script_location = dagster:_core/storage/alembic
 # on newly generated revision scripts.  See the documentation for further
 # detail and examples
 
-# format using "black" - use the console_scripts runner, against the "black" entrypoint
-hooks = black
-black.type = console_scripts
-black.entrypoint = black
-black.options = --line-length 100 --target-version py36 --target-version py37 --target-version py38 -S --fast
+# format using "ruff" - use the console_scripts runner, against the "ruff" entrypoint
+hooks = ruff
+ruff.type = console_scripts
+ruff.entrypoint = ruff
+ruff.options = format --target-version=py38 --line-length=100
 
 # Logging configuration
 [loggers]

dagster_postgres/event_log/__init__.py

@@ -1,2 +1 @@
-from .event_log import PostgresEventLogStorage as PostgresEventLogStorage
-from .event_watcher import PostgresEventWatcher as PostgresEventWatcher
+from dagster_postgres.event_log.event_log import PostgresEventLogStorage as PostgresEventLogStorage

dagster_postgres/event_log/event_log.py

@@ -1,4 +1,6 @@
-from typing import Any, ContextManager, Mapping, Optional
+from collections.abc import Iterator, Mapping, Sequence
+from contextlib import contextmanager
+from typing import Any, ContextManager, Optional, cast  # noqa: UP035
 
 import dagster._check as check
 import sqlalchemy as db
@@ -7,17 +9,19 @@ import sqlalchemy.pool as db_pool
 from dagster._config.config_schema import UserConfigSchema
 from dagster._core.errors import DagsterInvariantViolationError
 from dagster._core.event_api import EventHandlerFn
-from dagster._core.events import ASSET_EVENTS
+from dagster._core.events import ASSET_CHECK_EVENTS, ASSET_EVENTS, BATCH_WRITABLE_EVENTS
 from dagster._core.events.log import EventLogEntry
 from dagster._core.storage.config import pg_config
 from dagster._core.storage.event_log import (
     AssetKeyTable,
+    DynamicPartitionsTable,
     SqlEventLogStorage,
     SqlEventLogStorageMetadata,
     SqlEventLogStorageTable,
 )
 from dagster._core.storage.event_log.base import EventLogCursor
 from dagster._core.storage.event_log.migration import ASSET_KEY_INDEX_COLS
+from dagster._core.storage.event_log.polling_event_watcher import SqlPollingEventWatcher
 from dagster._core.storage.sql import (
     AlembicVersion,
     check_alembic_revision,
@@ -25,18 +29,19 @@ from dagster._core.storage.sql import (
     run_alembic_upgrade,
     stamp_alembic_rev,
 )
+from dagster._core.storage.sqlalchemy_compat import db_select
 from dagster._serdes import ConfigurableClass, ConfigurableClassData, deserialize_value
+from sqlalchemy import event
 from sqlalchemy.engine import Connection
 
-from ..utils import (
+from dagster_postgres.utils import (
     create_pg_connection,
     pg_alembic_config,
-    pg_statement_timeout,
     pg_url_from_config,
     retry_pg_connection_fn,
     retry_pg_creation_fn,
+    set_pg_statement_timeout,
 )
-from .event_watcher import PostgresEventWatcher
 
 CHANNEL_NAME = "run_events"
 
@@ -45,7 +50,7 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
     """Postgres-backed event log storage.
 
     Users should not directly instantiate this class; it is instantiated by internal machinery when
-    ``dagit`` and ``dagster-graphql`` load, based on the values in the ``dagster.yaml`` file in
+    ``dagster-webserver`` and ``dagster-graphql`` load, based on the values in the ``dagster.yaml`` file in
     ``$DAGSTER_HOME``. Configuration of this class should be done by setting values in that file.
 
     To use Postgres for all of the components of your instance storage, you can add the following
@@ -82,15 +87,11 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
             should_autocreate_tables, "should_autocreate_tables"
         )
 
-        self._disposed = False
-
         # Default to not holding any connections open to prevent accumulating connections per DagsterInstance
         self._engine = create_engine(
             self.postgres_url, isolation_level="AUTOCOMMIT", poolclass=db_pool.NullPool
         )
-
-        # lazy init
-        self._event_watcher: Optional[PostgresEventWatcher] = None
+        self._event_watcher: Optional[SqlPollingEventWatcher] = None
 
         self._secondary_index_cache = {}
 
@@ -111,20 +112,24 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
                 SqlEventLogStorageMetadata.create_all(conn)
                 stamp_alembic_rev(pg_alembic_config(__file__), conn)
 
-    def optimize_for_dagit(self, statement_timeout: int, pool_recycle: int) -> None:
-        # When running in dagit, hold an open connection and set statement_timeout
+    def optimize_for_webserver(
+        self, statement_timeout: int, pool_recycle: int, max_overflow: int
+    ) -> None:
+        # When running in dagster-webserver, hold an open connection and set statement_timeout
+        kwargs = {
+            "isolation_level": "AUTOCOMMIT",
+            "pool_size": 1,
+            "pool_recycle": pool_recycle,
+            "max_overflow": max_overflow,
+        }
         existing_options = self._engine.url.query.get("options")
-        timeout_option = pg_statement_timeout(statement_timeout)
         if existing_options:
-            options = f"{timeout_option} {existing_options}"
-        else:
-            options = timeout_option
-        self._engine = create_engine(
-            self.postgres_url,
-            isolation_level="AUTOCOMMIT",
-            pool_size=1,
-            connect_args={"options": options},
-            pool_recycle=pool_recycle,
+            kwargs["connect_args"] = {"options": existing_options}
+        self._engine = create_engine(self.postgres_url, **kwargs)
+        event.listen(
+            self._engine,
+            "connect",
+            lambda connection, _: set_pg_statement_timeout(connection, statement_timeout),
         )
 
     def upgrade(self) -> None:
@@ -165,7 +170,7 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
         return PostgresEventLogStorage(conn_string, should_autocreate_tables)
 
     def store_event(self, event: EventLogEntry) -> None:
-        """Store an event corresponding to a pipeline run.
+        """Store an event corresponding to a run.
 
         Args:
             event (EventLogEntry): The event to store.
@@ -180,11 +185,13 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
             )
             res = result.fetchone()
             result.close()
+
+            # LISTEN/NOTIFY no longer used for pg event watch - preserved here to support version skew
             conn.execute(
-                f"""NOTIFY {CHANNEL_NAME}, %s; """,
-                (res[0] + "_" + str(res[1]),),  # type: ignore
+                db.text(f"""NOTIFY {CHANNEL_NAME}, :notify_id; """),
+                {"notify_id": res[0] + "_" + str(res[1])},  # type: ignore
             )
-            event_id = res[1]  # type: ignore
+            event_id = int(res[1])  # type: ignore
 
         if (
             event.is_dagster_event
@@ -198,7 +205,51 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
                     "Cannot store asset event tags for null event id."
                 )
 
-            self.store_asset_event_tags(event, event_id)
+            self.store_asset_event_tags([event], [event_id])
+
+        if event.is_dagster_event and event.dagster_event_type in ASSET_CHECK_EVENTS:
+            self.store_asset_check_event(event, event_id)
+
+    def store_event_batch(self, events: Sequence[EventLogEntry]) -> None:
+        from dagster import DagsterEventType
+
+        check.sequence_param(events, "event", of_type=EventLogEntry)
+
+        event_types = {event.get_dagster_event().event_type for event in events}
+
+        check.invariant(
+            all(event_type in BATCH_WRITABLE_EVENTS for event_type in event_types),
+            f"{BATCH_WRITABLE_EVENTS} are the only currently supported events for batch writes.",
+        )
+        events = [
+            event
+            for event in events
+            if not event.get_dagster_event().is_asset_failed_to_materialize
+        ]
+        if len(events) == 0:
+            return
+
+        if event_types == {DagsterEventType.ASSET_MATERIALIZATION} or event_types == {
+            DagsterEventType.ASSET_OBSERVATION
+        }:
+            insert_event_statement = self.prepare_insert_event_batch(events)
+            with self._connect() as conn:
+                result = conn.execute(
+                    insert_event_statement.returning(SqlEventLogStorageTable.c.id)
+                )
+                event_ids = [cast("int", row[0]) for row in result.fetchall()]
+
+            # We only update the asset table with the last event
+            self.store_asset_event(events[-1], event_ids[-1])
+
+            if any(event_id is None for event_id in event_ids):
+                raise DagsterInvariantViolationError(
+                    "Cannot store asset event tags for null event id."
+                )
+
+            self.store_asset_event_tags(events, event_ids)
+        else:
+            return super().store_event_batch(events)
 
     def store_asset_event(self, event: EventLogEntry, event_id: int) -> None:
         check.inst_param(event, "event", EventLogEntry)
@@ -207,7 +258,7 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
 
         # We switched to storing the entire event record of the last materialization instead of just
         # the AssetMaterialization object, so that we have access to metadata like timestamp,
-        # pipeline, run_id, etc.
+        # job, run_id, etc.
         #
         # This should make certain asset queries way more performant, without having to do extra
         # queries against the event log.
@@ -222,7 +273,7 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
         # This column is used nowhere else, and as of AssetObservation/AssetMaterializationPlanned
         # event creation, we want to extend this functionality to ensure that assets with any event
         # (observation, materialization, or materialization planned) yielded with timestamp
-        # > wipe timestamp display in Dagit.
+        # > wipe timestamp display in the Dagster UI.
 
         # As of the following PRs, we update last_materialization_timestamp to store the timestamp
         # of the latest asset observation, materialization, or materialization_planned that has occurred.
@@ -252,6 +303,26 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
                 query = query.on_conflict_do_nothing()
             conn.execute(query)
 
+    def add_dynamic_partitions(
+        self, partitions_def_name: str, partition_keys: Sequence[str]
+    ) -> None:
+        if not partition_keys:
+            return
+
+        # Overload base implementation to push upsert logic down into the db layer
+        self._check_partitions_table()
+        with self.index_connection() as conn:
+            conn.execute(
+                db_dialects.postgresql.insert(DynamicPartitionsTable)
+                .values(
+                    [
+                        dict(partitions_def_name=partitions_def_name, partition=partition_key)
+                        for partition_key in partition_keys
+                    ]
+                )
+                .on_conflict_do_nothing(),
+            )
+
     def _connect(self) -> ContextManager[Connection]:
         return create_pg_connection(self._engine)
 
@@ -261,18 +332,27 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
     def index_connection(self) -> ContextManager[Connection]:
         return self._connect()
 
+    @contextmanager
+    def index_transaction(self) -> Iterator[Connection]:
+        """Context manager yielding a connection to the index shard that has begun a transaction."""
+        with self.index_connection() as conn:
+            if conn.in_transaction():
+                yield conn
+            else:
+                conn = conn.execution_options(isolation_level="READ COMMITTED")  # noqa: PLW2901
+                with conn.begin():
+                    yield conn
+
     def has_table(self, table_name: str) -> bool:
         return bool(self._engine.dialect.has_table(self._engine.connect(), table_name))
 
     def has_secondary_index(self, name: str) -> bool:
         if name not in self._secondary_index_cache:
-            self._secondary_index_cache[name] = super(
-                PostgresEventLogStorage, self
-            ).has_secondary_index(name)
+            self._secondary_index_cache[name] = super().has_secondary_index(name)
         return self._secondary_index_cache[name]
 
     def enable_secondary_index(self, name: str) -> None:
-        super(PostgresEventLogStorage, self).enable_secondary_index(name)
+        super().enable_secondary_index(name)
         if name in self._secondary_index_cache:
             del self._secondary_index_cache[name]
 
@@ -284,40 +364,28 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
     ) -> None:
         if cursor and EventLogCursor.parse(cursor).is_offset_cursor():
             check.failed("Cannot call `watch` with an offset cursor")
-
         if self._event_watcher is None:
-            self._event_watcher = PostgresEventWatcher(
-                self.postgres_url,
-                [CHANNEL_NAME],
-                self._gen_event_log_entry_from_cursor,
-            )
+            self._event_watcher = SqlPollingEventWatcher(self)
 
         self._event_watcher.watch_run(run_id, cursor, callback)
 
     def _gen_event_log_entry_from_cursor(self, cursor) -> EventLogEntry:
         with self._engine.connect() as conn:
             cursor_res = conn.execute(
-                db.select([SqlEventLogStorageTable.c.event]).where(
+                db_select([SqlEventLogStorageTable.c.event]).where(
                     SqlEventLogStorageTable.c.id == cursor
                 ),
             )
             return deserialize_value(cursor_res.scalar(), EventLogEntry)  # type: ignore
 
     def end_watch(self, run_id: str, handler: EventHandlerFn) -> None:
-        if self._event_watcher is None:
-            return
-
-        self._event_watcher.unwatch_run(run_id, handler)
-
-    def __del__(self) -> None:
-        # Keep the inherent limitations of __del__ in Python in mind!
-        self.dispose()
+        if self._event_watcher:
+            self._event_watcher.unwatch_run(run_id, handler)
 
     def dispose(self) -> None:
-        if not self._disposed:
-            self._disposed = True
-            if self._event_watcher:
-                self._event_watcher.close()
+        if self._event_watcher:
+            self._event_watcher.close()
+            self._event_watcher = None
 
     def alembic_version(self) -> AlembicVersion:
         alembic_config = pg_alembic_config(__file__)

dagster_postgres/run_storage/__init__.py

@@ -1 +1 @@
-from .run_storage import PostgresRunStorage as PostgresRunStorage
+from dagster_postgres.run_storage.run_storage import PostgresRunStorage as PostgresRunStorage

dagster_postgres/run_storage/run_storage.py

@@ -1,4 +1,6 @@
-from typing import ContextManager, Mapping, Optional
+import zlib
+from collections.abc import Mapping
+from typing import ContextManager, Optional  # noqa: UP035
 
 import dagster._check as check
 import sqlalchemy as db
@@ -12,7 +14,8 @@ from dagster._core.storage.runs import (
     RunStorageSqlMetadata,
     SqlRunStorage,
 )
-from dagster._core.storage.runs.schema import KeyValueStoreTable
+from dagster._core.storage.runs.schema import KeyValueStoreTable, SnapshotsTable
+from dagster._core.storage.runs.sql_run_storage import SnapshotType
 from dagster._core.storage.sql import (
     AlembicVersion,
     check_alembic_revision,
@@ -22,16 +25,17 @@ from dagster._core.storage.sql import (
 )
 from dagster._daemon.types import DaemonHeartbeat
 from dagster._serdes import ConfigurableClass, ConfigurableClassData, serialize_value
-from dagster._utils import utc_datetime_from_timestamp
+from dagster._time import datetime_from_timestamp
+from sqlalchemy import event
 from sqlalchemy.engine import Connection
 
-from ..utils import (
+from dagster_postgres.utils import (
     create_pg_connection,
     pg_alembic_config,
-    pg_statement_timeout,
     pg_url_from_config,
     retry_pg_connection_fn,
     retry_pg_creation_fn,
+    set_pg_statement_timeout,
 )
 
 
@@ -39,7 +43,7 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
     """Postgres-backed run storage.
 
     Users should not directly instantiate this class; it is instantiated by internal machinery when
-    ``dagit`` and ``dagster-graphql`` load, based on the values in the ``dagster.yaml`` file in
+    ``dagster-webserver`` and ``dagster-graphql`` load, based on the values in the ``dagster.yaml`` file in
     ``$DAGSTER_HOME``. Configuration of this class should be done by setting values in that file.
 
     To use Postgres for all of the components of your instance storage, you can add the following
@@ -104,20 +108,24 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
                 # This revision may be shared by any other dagster storage classes using the same DB
                 stamp_alembic_rev(pg_alembic_config(__file__), conn)
 
-    def optimize_for_dagit(self, statement_timeout: int, pool_recycle: int) -> None:
-        # When running in dagit, hold 1 open connection and set statement_timeout
+    def optimize_for_webserver(
+        self, statement_timeout: int, pool_recycle: int, max_overflow: int
+    ) -> None:
+        # When running in dagster-webserver, hold an open connection and set statement_timeout
+        kwargs = {
+            "isolation_level": "AUTOCOMMIT",
+            "pool_size": 1,
+            "pool_recycle": pool_recycle,
+            "max_overflow": max_overflow,
+        }
         existing_options = self._engine.url.query.get("options")
-        timeout_option = pg_statement_timeout(statement_timeout)
         if existing_options:
-            options = f"{timeout_option} {existing_options}"
-        else:
-            options = timeout_option
-        self._engine = create_engine(
-            self.postgres_url,
-            isolation_level="AUTOCOMMIT",
-            pool_size=1,
-            connect_args={"options": options},
-            pool_recycle=pool_recycle,
+            kwargs["connect_args"] = {"options": existing_options}
+        self._engine = create_engine(self.postgres_url, **kwargs)
+        event.listen(
+            self._engine,
+            "connect",
+            lambda connection, _: set_pg_statement_timeout(connection, statement_timeout),
         )
 
     @property
@@ -129,7 +137,7 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
         return pg_config()
 
     @classmethod
-    def from_config_value(
+    def from_config_value(  # pyright: ignore[reportIncompatibleMethodOverride]
         cls, inst_data: Optional[ConfigurableClassData], config_value: PostgresStorageConfig
     ):
         return PostgresRunStorage(
@@ -160,13 +168,11 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
 
     def has_built_index(self, migration_name: str) -> bool:
         if migration_name not in self._index_migration_cache:
-            self._index_migration_cache[migration_name] = super(
-                PostgresRunStorage, self
-            ).has_built_index(migration_name)
+            self._index_migration_cache[migration_name] = super().has_built_index(migration_name)
         return self._index_migration_cache[migration_name]
 
     def mark_index_built(self, migration_name: str) -> None:
-        super(PostgresRunStorage, self).mark_index_built(migration_name)
+        super().mark_index_built(migration_name)
         if migration_name in self._index_migration_cache:
             del self._index_migration_cache[migration_name]
 
@@ -176,7 +182,7 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
             conn.execute(
                 db_dialects.postgresql.insert(DaemonHeartbeatsTable)
                 .values(
-                    timestamp=utc_datetime_from_timestamp(daemon_heartbeat.timestamp),
+                    timestamp=datetime_from_timestamp(daemon_heartbeat.timestamp),
                     daemon_type=daemon_heartbeat.daemon_type,
                     daemon_id=daemon_heartbeat.daemon_id,
                     body=serialize_value(daemon_heartbeat),
@@ -184,7 +190,7 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
                 .on_conflict_do_update(
                     index_elements=[DaemonHeartbeatsTable.c.daemon_type],
                     set_={
-                        "timestamp": utc_datetime_from_timestamp(daemon_heartbeat.timestamp),
+                        "timestamp": datetime_from_timestamp(daemon_heartbeat.timestamp),
                         "daemon_id": daemon_heartbeat.daemon_id,
                         "body": serialize_value(daemon_heartbeat),
                     },
@@ -199,7 +205,7 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
     def set_cursor_values(self, pairs: Mapping[str, str]) -> None:
         check.mapping_param(pairs, "pairs", key_type=str, value_type=str)
 
-        # pg speciic on_conflict_do_update
+        # pg specific on_conflict_do_update
         insert_stmt = db_dialects.postgresql.insert(KeyValueStoreTable).values(
             [{"key": k, "value": v} for k, v in pairs.items()]
         )
@@ -217,6 +223,20 @@ class PostgresRunStorage(SqlRunStorage, ConfigurableClass):
         with self.connect() as conn:
             conn.execute(upsert_stmt)
 
+    def _add_snapshot(self, snapshot_id: str, snapshot_obj, snapshot_type: SnapshotType) -> str:
+        with self.connect() as conn:
+            snapshot_insert = (
+                db_dialects.postgresql.insert(SnapshotsTable)
+                .values(
+                    snapshot_id=snapshot_id,
+                    snapshot_body=zlib.compress(serialize_value(snapshot_obj).encode("utf-8")),
+                    snapshot_type=snapshot_type.value,
+                )
+                .on_conflict_do_nothing()
+            )
+            conn.execute(snapshot_insert)
+            return snapshot_id
+
     def alembic_version(self) -> AlembicVersion:
         alembic_config = pg_alembic_config(__file__)
         with self.connect() as conn:

dagster_postgres/schedule_storage/__init__.py

@@ -1 +1,3 @@
-from .schedule_storage import PostgresScheduleStorage as PostgresScheduleStorage
+from dagster_postgres.schedule_storage.schedule_storage import (
+    PostgresScheduleStorage as PostgresScheduleStorage,
+)

dagster_postgres/schedule_storage/schedule_storage.py

@@ -1,15 +1,22 @@
-from typing import ContextManager, Optional
+from collections.abc import Sequence
+from typing import ContextManager, Optional  # noqa: UP035
 
 import dagster._check as check
-import pendulum
 import sqlalchemy as db
 import sqlalchemy.dialects as db_dialects
 import sqlalchemy.pool as db_pool
 from dagster._config.config_schema import UserConfigSchema
+from dagster._core.definitions.asset_key import EntityKey
+from dagster._core.definitions.declarative_automation.serialized_objects import (
+    AutomationConditionEvaluationWithRunIds,
+)
 from dagster._core.scheduler.instigation import InstigatorState
 from dagster._core.storage.config import PostgresStorageConfig, pg_config
 from dagster._core.storage.schedules import ScheduleStorageSqlMetadata, SqlScheduleStorage
-from dagster._core.storage.schedules.schema import InstigatorsTable
+from dagster._core.storage.schedules.schema import (
+    AssetDaemonAssetEvaluationsTable,
+    InstigatorsTable,
+)
 from dagster._core.storage.sql import (
     AlembicVersion,
     check_alembic_revision,
@@ -18,15 +25,17 @@ from dagster._core.storage.sql import (
     stamp_alembic_rev,
 )
 from dagster._serdes import ConfigurableClass, ConfigurableClassData, serialize_value
+from dagster._time import get_current_datetime
+from sqlalchemy import event
 from sqlalchemy.engine import Connection
 
-from ..utils import (
+from dagster_postgres.utils import (
     create_pg_connection,
     pg_alembic_config,
-    pg_statement_timeout,
     pg_url_from_config,
     retry_pg_connection_fn,
     retry_pg_creation_fn,
+    set_pg_statement_timeout,
 )
 
 
@@ -34,7 +43,7 @@ class PostgresScheduleStorage(SqlScheduleStorage, ConfigurableClass):
     """Postgres-backed run storage.
 
     Users should not directly instantiate this class; it is instantiated by internal machinery when
-    ``dagit`` and ``dagster-graphql`` load, based on the values in the ``dagster.yaml`` file in
+    ``dagster-webserver`` and ``dagster-graphql`` load, based on the values in the ``dagster.yaml`` file in
     ``$DAGSTER_HOME``. Configuration of this class should be done by setting values in that file.
 
     To use Postgres for all of the components of your instance storage, you can add the following
@@ -95,20 +104,24 @@ class PostgresScheduleStorage(SqlScheduleStorage, ConfigurableClass):
         self.migrate()
         self.optimize()
 
-    def optimize_for_dagit(self, statement_timeout: int, pool_recycle: int) -> None:
-        # When running in dagit, hold an open connection and set statement_timeout
+    def optimize_for_webserver(
+        self, statement_timeout: int, pool_recycle: int, max_overflow: int
+    ) -> None:
+        # When running in dagster-webserver, hold an open connection and set statement_timeout
+        kwargs = {
+            "isolation_level": "AUTOCOMMIT",
+            "pool_size": 1,
+            "pool_recycle": pool_recycle,
+            "max_overflow": max_overflow,
+        }
         existing_options = self._engine.url.query.get("options")
-        timeout_option = pg_statement_timeout(statement_timeout)
         if existing_options:
-            options = f"{timeout_option} {existing_options}"
-        else:
-            options = timeout_option
-        self._engine = create_engine(
-            self.postgres_url,
-            isolation_level="AUTOCOMMIT",
-            pool_size=1,
-            connect_args={"options": options},
-            pool_recycle=pool_recycle,
+            kwargs["connect_args"] = {"options": existing_options}
+        self._engine = create_engine(self.postgres_url, **kwargs)
+        event.listen(
+            self._engine,
+            "connect",
+            lambda connection, _: set_pg_statement_timeout(connection, statement_timeout),
         )
 
     @property
@@ -120,7 +133,7 @@ class PostgresScheduleStorage(SqlScheduleStorage, ConfigurableClass):
         return pg_config()
 
     @classmethod
-    def from_config_value(
+    def from_config_value(  # pyright: ignore[reportIncompatibleMethodOverride]
         cls, inst_data: Optional[ConfigurableClassData], config_value: PostgresStorageConfig
     ) -> "PostgresScheduleStorage":
         return PostgresScheduleStorage(
@@ -167,11 +180,44 @@ class PostgresScheduleStorage(SqlScheduleStorage, ConfigurableClass):
                     "status": state.status.value,
                     "instigator_type": state.instigator_type.value,
                     "instigator_body": serialize_value(state),
-                    "update_timestamp": pendulum.now("UTC"),
+                    "update_timestamp": get_current_datetime(),
                 },
             )
         )
 
+    def add_auto_materialize_asset_evaluations(
+        self,
+        evaluation_id: int,
+        asset_evaluations: Sequence[AutomationConditionEvaluationWithRunIds[EntityKey]],
+    ):
+        if not asset_evaluations:
+            return
+
+        insert_stmt = db_dialects.postgresql.insert(AssetDaemonAssetEvaluationsTable).values(
+            [
+                {
+                    "evaluation_id": evaluation_id,
+                    "asset_key": evaluation.key.to_db_string(),
+                    "asset_evaluation_body": serialize_value(evaluation),
+                    "num_requested": evaluation.num_requested,
+                }
+                for evaluation in asset_evaluations
+            ]
+        )
+        upsert_stmt = insert_stmt.on_conflict_do_update(
+            index_elements=[
+                AssetDaemonAssetEvaluationsTable.c.evaluation_id,
+                AssetDaemonAssetEvaluationsTable.c.asset_key,
+            ],
+            set_={
+                "asset_evaluation_body": insert_stmt.excluded.asset_evaluation_body,
+                "num_requested": insert_stmt.excluded.num_requested,
+            },
+        )
+
+        with self.connect() as conn:
+            conn.execute(upsert_stmt)
+
     def alembic_version(self) -> AlembicVersion:
         alembic_config = pg_alembic_config(__file__)
         with self.connect() as conn:

dagster_postgres/storage.py

@@ -9,17 +9,17 @@ from dagster._core.storage.runs import RunStorage
 from dagster._core.storage.schedules import ScheduleStorage
 from dagster._serdes import ConfigurableClass, ConfigurableClassData
 
-from .event_log import PostgresEventLogStorage
-from .run_storage import PostgresRunStorage
-from .schedule_storage import PostgresScheduleStorage
-from .utils import pg_url_from_config
+from dagster_postgres.event_log import PostgresEventLogStorage
+from dagster_postgres.run_storage import PostgresRunStorage
+from dagster_postgres.schedule_storage import PostgresScheduleStorage
+from dagster_postgres.utils import pg_url_from_config
 
 
 class DagsterPostgresStorage(DagsterStorage, ConfigurableClass):
     """Postgres-backed dagster storage.
 
     Users should not directly instantiate this class; it is instantiated by internal machinery when
-    ``dagit`` and ``dagster-daemon`` load, based on the values in the ``dagster.yaml`` file in
+    ``dagster-webserver`` and ``dagster-daemon`` load, based on the values in the ``dagster.yaml`` file in
     ``$DAGSTER_HOME``. Configuration of this class should be done by setting values in that file.
 
     To use Postgres for storage, you can add a block such as the following to your
@@ -59,7 +59,7 @@ class DagsterPostgresStorage(DagsterStorage, ConfigurableClass):
         return pg_config()
 
     @classmethod
-    def from_config_value(
+    def from_config_value(  # pyright: ignore[reportIncompatibleMethodOverride]
         cls, inst_data: Optional[ConfigurableClassData], config_value: PostgresStorageConfig
     ) -> "DagsterPostgresStorage":
         return DagsterPostgresStorage(

dagster_postgres/test_fixtures/__init__.py

@@ -0,0 +1,75 @@
+import tempfile
+from contextlib import contextmanager
+from pathlib import Path
+
+import pytest
+from dagster._core.test_utils import instance_for_test
+from dagster._utils.merger import merge_dicts
+from dagster_test.fixtures import docker_compose_cm, network_name_from_yml
+
+from dagster_postgres.utils import get_conn_string, wait_for_connection
+
+compose_file = Path(__file__).parent / "docker-compose.yml"
+
+
+@pytest.fixture(scope="session")
+def postgres_network():
+    yield network_name_from_yml(compose_file)
+
+
+@pytest.fixture(scope="session")
+def postgres_hostname():
+    with docker_compose_cm(docker_compose_yml=compose_file) as hostnames:
+        yield hostnames["postgres"]
+
+
+@pytest.fixture(scope="session")
+def postgres_conn_str(postgres_hostname):
+    conn_str = get_conn_string(
+        username="test",
+        password="test",
+        hostname=postgres_hostname,
+        db_name="test",
+        params=dict(connect_timeout=5),
+    )
+    wait_for_connection(
+        conn_str,
+        retry_limit=10,
+        retry_wait=3,
+    )
+
+    yield conn_str
+
+
+@pytest.fixture
+def postgres_instance(postgres_conn_str):
+    @contextmanager
+    def _instance(overrides=None):
+        with tempfile.TemporaryDirectory() as temp_dir:
+            with instance_for_test(
+                temp_dir=temp_dir,
+                overrides=merge_dicts(
+                    {
+                        "run_storage": {
+                            "module": "dagster_postgres.run_storage.run_storage",
+                            "class": "PostgresRunStorage",
+                            "config": {"postgres_url": postgres_conn_str},
+                        },
+                        "event_log_storage": {
+                            "module": "dagster_postgres.event_log.event_log",
+                            "class": "PostgresEventLogStorage",
+                            "config": {"postgres_url": postgres_conn_str},
+                        },
+                        "schedule_storage": {
+                            "module": "dagster_postgres.schedule_storage.schedule_storage",
+                            "class": "PostgresScheduleStorage",
+                            "config": {"postgres_url": postgres_conn_str},
+                        },
+                    },
+                    overrides if overrides else {},
+                ),
+            ) as instance:
+                instance.wipe()
+                yield instance
+
+    return _instance

dagster_postgres/test_fixtures/docker-compose.yml

@@ -0,0 +1,10 @@
+services:
+  postgres:
+    image: postgres:16
+    container_name: postgres
+    ports:
+      - "5432:5432"
+    environment:
+      POSTGRES_PASSWORD: "test"
+      POSTGRES_USER: "test"
+      POSTGRES_DB: "test"

dagster_postgres/utils.py

@@ -1,7 +1,8 @@
 import logging
 import time
+from collections.abc import Callable, Iterator, Mapping
 from contextlib import contextmanager
-from typing import Any, Callable, Iterator, Mapping, Optional, TypeVar
+from typing import Any, Optional, TypeVar
 from urllib.parse import quote, urlencode
 
 import alembic.config
@@ -169,6 +170,8 @@ def create_pg_connection(
             conn.close()
 
 
-def pg_statement_timeout(millis: int) -> str:
+def set_pg_statement_timeout(conn: psycopg2.extensions.connection, millis: int):
     check.int_param(millis, "millis")
-    return f"-c statement_timeout={millis}"
+    with conn:
+        with conn.cursor() as curs:
+            curs.execute(f"SET statement_timeout = {millis};")

dagster_postgres/version.py

@@ -1 +1 @@
-__version__ = "0.19.2"
+__version__ = "0.28.11"

dagster_postgres-0.28.11.dist-info/METADATA

@@ -0,0 +1,28 @@
+Metadata-Version: 2.4
+Name: dagster-postgres
+Version: 0.28.11
+Summary: A Dagster integration for postgres
+Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-postgres
+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.11
+Requires-Dist: psycopg2-binary
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

dagster_postgres-0.28.11.dist-info/RECORD

@@ -0,0 +1,19 @@
+dagster_postgres/__init__.py,sha256=rZfjhBDGC_SIGnKuiSCzi7D0xD36mAnchDLRL-n1Tmk,561
+dagster_postgres/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
+dagster_postgres/storage.py,sha256=CiPA773j0BQvPtCEz5vVqKjap9h0ODAxR_R_CvbI-bI,4310
+dagster_postgres/utils.py,sha256=BzkzfQ9t9U9FMCs_3NazAKW7stK0Wrz_nH0KK4NQfi8,5930
+dagster_postgres/version.py,sha256=MlSqB7SmZ8R1F0K_PtG4rMWRGGllC7hEsX-reHAF_8A,24
+dagster_postgres/alembic/alembic.ini,sha256=GovyDEhu_6HvkWV6txqjdDBOe4BseSM0YDWGxXM5_cA,986
+dagster_postgres/event_log/__init__.py,sha256=wRcUR-StRNrPCqpEzi0MRY8b-r_TEWV17OsEynFqlLs,100
+dagster_postgres/event_log/event_log.py,sha256=w8_ZsvDb0vt7qDVSS912jmNRpLDI6F0KQrwribyAmwM,16145
+dagster_postgres/run_storage/__init__.py,sha256=oW_546mJ5K-e-RF0Ou7r-4fHWxFthHgPPhWxklsVK1g,94
+dagster_postgres/run_storage/run_storage.py,sha256=VMXT5sb5n04ViWOYj2eOoZqOk78hqL38J6CuikM79No,9757
+dagster_postgres/schedule_storage/__init__.py,sha256=-jW-1S4Xf5Ew-cz-DjKjU5sVs9EEly_2ELMLOXTewv0,123
+dagster_postgres/schedule_storage/schedule_storage.py,sha256=iPKcvnj1eEeG5LH73GoFvoS3hmE8MFddiFyf7QoKZ3g,8826
+dagster_postgres/test_fixtures/__init__.py,sha256=ZIcbGYa_CMmVF0YkuiX4uI3wRjBke_2VE8QXKcji0Y4,2447
+dagster_postgres/test_fixtures/docker-compose.yml,sha256=hp2VTnENYK6CL2Yae3IsktssahPFQiHyhpNcG36CivM,208
+dagster_postgres-0.28.11.dist-info/licenses/LICENSE,sha256=4lsMW-RCvfVD4_F57wrmpe3vX1xwUk_OAKKmV_XT7Z0,11348
+dagster_postgres-0.28.11.dist-info/METADATA,sha256=971I43x8Ltg7CRFX9AILtVaxOlw1PK7fsQ0jwuGdEYo,947
+dagster_postgres-0.28.11.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dagster_postgres-0.28.11.dist-info/top_level.txt,sha256=lScMtAEKDX1yIv2tGa1nzntBa0HEStfWPfCwD8FWlHk,17
+dagster_postgres-0.28.11.dist-info/RECORD,,

{dagster_postgres-0.19.2.dist-info → dagster_postgres-0.28.11.dist-info}/WHEEL

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

{dagster_postgres-0.19.2.dist-info → dagster_postgres-0.28.11.dist-info/licenses}/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_postgres/event_log/event_watcher.py

@@ -1,137 +0,0 @@
-import logging
-import threading
-from collections import defaultdict
-from typing import Callable, List, MutableMapping, Optional, Sequence
-
-import dagster._check as check
-from dagster._core.event_api import EventHandlerFn
-from dagster._core.events.log import EventLogEntry
-from dagster._core.storage.event_log.base import EventLogCursor
-from dagster._core.storage.event_log.polling_event_watcher import CallbackAfterCursor
-
-from ..pynotify import await_pg_notifications
-
-POLLING_CADENCE = 0.25
-
-
-def watcher_thread(
-    conn_string: str,
-    handlers_dict: MutableMapping[str, Sequence[CallbackAfterCursor]],
-    dict_lock: threading.Lock,
-    watcher_thread_exit: threading.Event,
-    watcher_thread_started: threading.Event,
-    channels: Sequence[str],
-    gen_event_log_entry_from_cursor: Callable[[int], EventLogEntry],
-) -> None:
-    for notif in await_pg_notifications(
-        conn_string,
-        channels=channels,
-        timeout=POLLING_CADENCE,
-        yield_on_timeout=True,
-        exit_event=watcher_thread_exit,
-        started_event=watcher_thread_started,
-    ):
-        if notif is None:
-            if watcher_thread_exit.is_set():
-                break
-        else:
-            run_id, index_str = notif.payload.split("_")
-            with dict_lock:
-                if run_id not in handlers_dict:
-                    continue
-
-            index = int(index_str)
-            with dict_lock:
-                handlers = handlers_dict.get(run_id, [])
-
-            dagster_event = gen_event_log_entry_from_cursor(index)
-
-            for callback_with_cursor in handlers:
-                try:
-                    if (
-                        callback_with_cursor.cursor is None
-                        or EventLogCursor.parse(callback_with_cursor.cursor).storage_id() < index
-                    ):
-                        callback_with_cursor.callback(
-                            dagster_event, str(EventLogCursor.from_storage_id(index))
-                        )
-                except:
-                    logging.exception("Exception in callback for event watch on run %s.", run_id)
-
-
-class PostgresEventWatcher:
-    def __init__(
-        self,
-        conn_string: str,
-        channels: Sequence[str],
-        gen_event_log_entry_from_cursor: Callable[[int], EventLogEntry],
-    ):
-        self._conn_string: str = check.str_param(conn_string, "conn_string")
-        self._handlers_dict: MutableMapping[str, List[CallbackAfterCursor]] = defaultdict(list)
-        self._dict_lock: threading.Lock = threading.Lock()
-        self._watcher_thread_exit: Optional[threading.Event] = None
-        self._watcher_thread_started: Optional[threading.Event] = None
-        self._watcher_thread: Optional[threading.Thread] = None
-        self._channels: Sequence[str] = check.sequence_param(channels, "channels")
-        self._gen_event_log_entry_from_cursor: Callable[
-            [int], EventLogEntry
-        ] = check.callable_param(gen_event_log_entry_from_cursor, "gen_event_log_entry_from_cursor")
-
-    def watch_run(
-        self,
-        run_id: str,
-        cursor: Optional[str],
-        callback: EventHandlerFn,
-        start_timeout: int = 15,
-    ) -> None:
-        check.str_param(run_id, "run_id")
-        check.opt_str_param(cursor, "cursor")
-        check.callable_param(callback, "callback")
-        if not self._watcher_thread:
-            self._watcher_thread_exit = threading.Event()
-            self._watcher_thread_started = threading.Event()
-
-            self._watcher_thread = threading.Thread(
-                target=watcher_thread,
-                args=(
-                    self._conn_string,
-                    self._handlers_dict,
-                    self._dict_lock,
-                    self._watcher_thread_exit,
-                    self._watcher_thread_started,
-                    self._channels,
-                    self._gen_event_log_entry_from_cursor,
-                ),
-                name="postgres-event-watch",
-            )
-            self._watcher_thread.daemon = True
-            self._watcher_thread.start()
-
-            # Wait until the watcher thread is actually listening before returning
-            self._watcher_thread_started.wait(start_timeout)
-            if not self._watcher_thread_started.is_set():
-                raise Exception("Watcher thread never started")
-
-        with self._dict_lock:
-            self._handlers_dict[run_id].append(CallbackAfterCursor(cursor, callback))
-
-    def unwatch_run(self, run_id: str, handler: EventHandlerFn) -> None:
-        check.str_param(run_id, "run_id")
-        check.callable_param(handler, "handler")
-        with self._dict_lock:
-            if run_id in self._handlers_dict:
-                self._handlers_dict[run_id] = [
-                    callback_with_cursor
-                    for callback_with_cursor in self._handlers_dict[run_id]
-                    if callback_with_cursor.callback != handler
-                ]
-                if not self._handlers_dict[run_id]:
-                    del self._handlers_dict[run_id]
-
-    def close(self) -> None:
-        if self._watcher_thread:
-            self._watcher_thread_exit.set()  # type: ignore
-            if self._watcher_thread.is_alive():
-                self._watcher_thread.join()
-            self._watcher_thread_exit = None
-            self._watcher_thread = None

dagster_postgres/pynotify.py

@@ -1,138 +0,0 @@
-# copied from https://github.com/djrobstep/pgnotify/blob/43bbe7bd3cedfb99700e4ab370cb6f5d7426bea3/pgnotify/notify.py
-
-# This is free and unencumbered software released into the public domain.
-
-# Anyone is free to copy, modify, publish, use, compile, sell, or
-# distribute this software, either in source code form or as a compiled
-# binary, for any purpose, commercial or non-commercial, and by any
-# means.
-
-# In jurisdictions that recognize copyright laws, the author or authors
-# of this software dedicate any and all copyright interest in the
-# software to the public domain. We make this dedication for the benefit
-# of the public at large and to the detriment of our heirs and
-# successors. We intend this dedication to be an overt act of
-# relinquishment in perpetuity of all present and future rights to this
-# software under copyright law.
-
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-# IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
-# OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
-# ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
-
-# For more information, please refer to <http://unlicense.org>
-
-import errno
-import os
-import select
-import signal
-import sys
-from threading import Event
-from typing import Iterator, Optional, Sequence
-
-import dagster._check as check
-from dagster._core.storage.sql import create_engine
-from psycopg2.extensions import Notify
-
-from .utils import create_pg_connection
-
-
-def get_wakeup_fd() -> int:
-    pipe_r, pipe_w = os.pipe()
-    if "win" not in sys.platform:
-        import fcntl
-
-        flags = fcntl.fcntl(pipe_w, fcntl.F_GETFL, 0)
-        flags = os.O_NONBLOCK
-        flags = fcntl.fcntl(pipe_w, fcntl.F_SETFL, flags)
-    signal.set_wakeup_fd(pipe_w)
-    return pipe_r
-
-
-def _empty_handler(_signal, _frame):
-    pass
-
-
-def quote_table_name(name: str) -> str:
-    return f'"{name}"'
-
-
-def start_listening(connection, channels):
-    names = (quote_table_name(each) for each in channels)
-    listens = "; ".join([f"LISTEN {n}" for n in names])
-
-    with connection.cursor() as curs:
-        curs.execute(listens)
-
-
-def construct_signals(arg) -> signal.Signals:
-    # function exists to consolidate and scope pylint directive
-    return signal.Signals(arg)
-
-
-def await_pg_notifications(
-    conn_string: str,
-    channels: Optional[Sequence[str]] = None,
-    timeout: float = 5.0,
-    yield_on_timeout: bool = False,
-    exit_event: Optional[Event] = None,
-    started_event: Optional[Event] = None,
-) -> Iterator[Optional[Notify]]:
-    """Subscribe to PostgreSQL notifications, and handle them
-    in infinite-loop style.
-
-    Args:
-        conn_string (str): connection string to PG DB
-        channels (Optional[List[str]], optional): List of channel names to listen to. Defaults to None.
-        timeout (float, optional): Timeout interval. Defaults to 5.0.
-        yield_on_timeout (bool, optional): Should the function yield on timeout. Defaults to False.
-        exit_event (Optional[Event], optional): Event that indicates that polling for new notifications should stop. Defaults to None.
-        started_event (Optional[Event], optional): Event that this function can set to notify that the subscription has been established. Defaults to None.
-
-    Yields:
-        Iterator[Optional[Notify]]: Can yield one of two types:
-            1: None, in case of timeout
-            2: Notify, in case of successful notification reception
-    """
-    check.str_param(conn_string, "conn_string")
-    channels = None if channels is None else check.sequence_param(channels, "channels", of_type=str)
-    check.float_param(timeout, "timeout")
-    check.bool_param(yield_on_timeout, "yield_on_timeout")
-
-    engine = create_engine(
-        conn_string,
-        isolation_level="AUTOCOMMIT",
-    )
-
-    with create_pg_connection(engine) as conn:
-        connection = conn.connection.connection  # DBAPI connection  # type: ignore
-
-        if channels:
-            start_listening(connection, channels)
-
-        if started_event:
-            started_event.set()
-
-        while True and not (exit_event and exit_event.is_set()):
-            try:
-                r, w, x = select.select([connection], [], [], max(0, timeout))
-                if (r, w, x) == ([], [], []):
-                    if yield_on_timeout:
-                        yield None
-
-                if connection in r:
-                    connection.poll()
-
-                    # copy the conn.notifies list/queue & empty it
-                    notify_list, connection.notifies = connection.notifies, []
-                    for notif in notify_list:
-                        yield notif
-
-            except select.error as e:
-                if e.errno == errno.EINTR:
-                    pass
-                else:
-                    raise

dagster_postgres-0.19.2.dist-info/METADATA

@@ -1,19 +0,0 @@
-Metadata-Version: 2.1
-Name: dagster-postgres
-Version: 0.19.2
-Summary: A Dagster integration for postgres
-Home-page: https://github.com/dagster-io/dagster/tree/master/python_modules/libraries/dagster-postgres
-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
-Requires-Dist: dagster (==1.3.2)
-Requires-Dist: psycopg2-binary
-

dagster_postgres-0.19.2.dist-info/RECORD

@@ -1,19 +0,0 @@
-dagster_postgres/__init__.py,sha256=LEcXwiGeuZgIvfDg0PVcRuKjUmg0t9Uslx5nLZ8Yg08,480
-dagster_postgres/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-dagster_postgres/pynotify.py,sha256=kpAZ24THE1qYQIxScUk21Mp3QV9qd92P3CMXYGEgRIU,5004
-dagster_postgres/storage.py,sha256=cEr8Hkab9jgLzimC-efkSwwQXWpVKUvN-RHhf4IpuB8,4181
-dagster_postgres/utils.py,sha256=b_KukmD2puOJdvTFy0OUZtM5sGWyE1Fq6nP9hmUmRCc,5798
-dagster_postgres/version.py,sha256=qZNYBPCf5y9eOSOCnc71mXgsDo0Xwb9v1HTFq7X3sdU,23
-dagster_postgres/alembic/alembic.ini,sha256=S0-B6cHIaS_CJaJc2dd0NiQfDLIWfvaZJGZYQsH7tSY,1040
-dagster_postgres/event_log/__init__.py,sha256=T95tRLYxnC-g69K_5G9i1NLTXi3pGexLVKeGug8niMA,146
-dagster_postgres/event_log/event_log.py,sha256=tSBNxccx8bXFMDcWYPNqBpjG-EbF86zgFNZ_Ix3-ttc,13001
-dagster_postgres/event_log/event_watcher.py,sha256=59TuxkNX56Va54GJFqdQSzSCmA14onS_4l5IFYbRxb8,5346
-dagster_postgres/run_storage/__init__.py,sha256=4bI2C2kkZO9glXH8jIUViYBRSeMjdDHiVQVi_k1HkYw,66
-dagster_postgres/run_storage/run_storage.py,sha256=x35qMKJVhOtEw-CiYiHBw8K4WcdCd8AUYYao7mYMQiQ,8867
-dagster_postgres/schedule_storage/__init__.py,sha256=GKJlFZYh27fUxJDMQwNJUwibbTnip1ledbcokczutmk,81
-dagster_postgres/schedule_storage/schedule_storage.py,sha256=UDKJ1ZEWYtNWHACI8ap1mZlfB8WXSwGtNgqgXrleSLU,7045
-dagster_postgres-0.19.2.dist-info/LICENSE,sha256=-gtoVIAZYUHYmNHISZg982FI4Oh19mV1nxgTVW8eCB8,11344
-dagster_postgres-0.19.2.dist-info/METADATA,sha256=whK5RB_yBbNjR367aSYLqTOh80XZ9mEzhdXg7pFo5aI,727
-dagster_postgres-0.19.2.dist-info/WHEEL,sha256=p46_5Uhzqz6AzeSosiOnxK-zmFja1i22CrQCjmYe8ec,92
-dagster_postgres-0.19.2.dist-info/top_level.txt,sha256=lScMtAEKDX1yIv2tGa1nzntBa0HEStfWPfCwD8FWlHk,17
-dagster_postgres-0.19.2.dist-info/RECORD,,