dagster-postgres 0.23.7__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/event_log/__init__.py

@@ -1 +1 @@
-from .event_log import PostgresEventLogStorage as PostgresEventLogStorage
+from dagster_postgres.event_log.event_log import PostgresEventLogStorage as PostgresEventLogStorage

dagster_postgres/event_log/event_log.py

@@ -1,5 +1,6 @@
+from collections.abc import Iterator, Mapping, Sequence
 from contextlib import contextmanager
-from typing import Any, ContextManager, Iterator, Mapping, Optional, Sequence, cast
+from typing import Any, ContextManager, Optional, cast  # noqa: UP035
 
 import dagster._check as check
 import sqlalchemy as db
@@ -30,15 +31,16 @@ from dagster._core.storage.sql import (
 )
 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,
 )
 
 CHANNEL_NAME = "run_events"
@@ -110,20 +112,24 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
                 SqlEventLogStorageMetadata.create_all(conn)
                 stamp_alembic_rev(pg_alembic_config(__file__), conn)
 
-    def optimize_for_webserver(self, statement_timeout: int, pool_recycle: int) -> None:
+    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:
@@ -170,7 +176,6 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
             event (EventLogEntry): The event to store.
         """
         check.inst_param(event, "event", EventLogEntry)
-
         insert_event_statement = self.prepare_insert_event(event)  # from SqlEventLogStorage.py
         with self._connect() as conn:
             result = conn.execute(
@@ -206,25 +211,45 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
             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.get_dagster_event().event_type in BATCH_WRITABLE_EVENTS for event in events),
+            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
 
-        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()]
+        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])
+            # 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.")
+            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)
+            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)
@@ -323,13 +348,11 @@ class PostgresEventLogStorage(SqlEventLogStorage, ConfigurableClass):
 
     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]
 

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,5 +1,6 @@
 import zlib
-from typing import ContextManager, Mapping, Optional
+from collections.abc import Mapping
+from typing import ContextManager, Optional  # noqa: UP035
 
 import dagster._check as check
 import sqlalchemy as db
@@ -24,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,
 )
 
 
@@ -106,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_webserver(self, statement_timeout: int, pool_recycle: int) -> None:
-        # When running in dagster-webserver, 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
@@ -131,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(
@@ -162,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]
 
@@ -178,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),
@@ -186,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),
                     },

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,13 +1,14 @@
-from typing import ContextManager, Optional, Sequence
+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.declarative_scheduling.serialized_objects import (
-    AssetConditionEvaluationWithRunIds,
+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
@@ -24,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,
 )
 
 
@@ -101,20 +104,24 @@ class PostgresScheduleStorage(SqlScheduleStorage, ConfigurableClass):
         self.migrate()
         self.optimize()
 
-    def optimize_for_webserver(self, statement_timeout: int, pool_recycle: int) -> None:
+    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
@@ -126,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(
@@ -173,7 +180,7 @@ 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(),
                 },
             )
         )
@@ -181,7 +188,7 @@ class PostgresScheduleStorage(SqlScheduleStorage, ConfigurableClass):
     def add_auto_materialize_asset_evaluations(
         self,
         evaluation_id: int,
-        asset_evaluations: Sequence[AssetConditionEvaluationWithRunIds],
+        asset_evaluations: Sequence[AutomationConditionEvaluationWithRunIds[EntityKey]],
     ):
         if not asset_evaluations:
             return
@@ -190,7 +197,7 @@ class PostgresScheduleStorage(SqlScheduleStorage, ConfigurableClass):
             [
                 {
                     "evaluation_id": evaluation_id,
-                    "asset_key": evaluation.asset_key.to_string(),
+                    "asset_key": evaluation.key.to_db_string(),
                     "asset_evaluation_body": serialize_value(evaluation),
                     "num_requested": evaluation.num_requested,
                 }

dagster_postgres/storage.py

@@ -9,10 +9,10 @@ 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):
@@ -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.23.7"
+__version__ = "0.28.11"

{dagster_postgres-0.23.7.dist-info → dagster_postgres-0.28.11.dist-info}/METADATA

@@ -1,20 +1,28 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: dagster-postgres
-Version: 0.23.7
+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.8
-Classifier: Programming Language :: Python :: 3.9
 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.8,<3.13
+Requires-Python: >=3.10,<3.15
 License-File: LICENSE
-Requires-Dist: dagster ==1.7.7
+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.23.7.dist-info → dagster_postgres-0.28.11.dist-info}/WHEEL

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

{dagster_postgres-0.23.7.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 Dagster Labs, 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-0.23.7.dist-info/RECORD

@@ -1,17 +0,0 @@
-dagster_postgres/__init__.py,sha256=LEcXwiGeuZgIvfDg0PVcRuKjUmg0t9Uslx5nLZ8Yg08,480
-dagster_postgres/py.typed,sha256=la67KBlbjXN-_-DfGNcdOcjYumVpKG_Tkw-8n5dnGB4,8
-dagster_postgres/storage.py,sha256=uo264Cr0it0KzduaGD5_54YmjAPng5Vy5AhPsffPPEU,4193
-dagster_postgres/utils.py,sha256=b_KukmD2puOJdvTFy0OUZtM5sGWyE1Fq6nP9hmUmRCc,5798
-dagster_postgres/version.py,sha256=cC_HEsX6d06QmpjNLfRezzJvL501PPwiQYXWDM2_2UI,23
-dagster_postgres/alembic/alembic.ini,sha256=GovyDEhu_6HvkWV6txqjdDBOe4BseSM0YDWGxXM5_cA,986
-dagster_postgres/event_log/__init__.py,sha256=pQ7nZw5Fp60xVd_JPsZ61n6G5V4d0y8MfUGNkHvgbik,74
-dagster_postgres/event_log/event_log.py,sha256=w8QheUMubekLwynbsMI3FZCsolKplYMrd1aoGWny6BU,15390
-dagster_postgres/run_storage/__init__.py,sha256=4bI2C2kkZO9glXH8jIUViYBRSeMjdDHiVQVi_k1HkYw,66
-dagster_postgres/run_storage/run_storage.py,sha256=KqsJ_vOJyDL6dfO3kgah-10ZbbTPJFXLbTSmvDoGaww,9589
-dagster_postgres/schedule_storage/__init__.py,sha256=GKJlFZYh27fUxJDMQwNJUwibbTnip1ledbcokczutmk,81
-dagster_postgres/schedule_storage/schedule_storage.py,sha256=NbcPd3ia45su1_v9d65ZLUUAW0m53-KBQO8zvGdhvZI,8458
-dagster_postgres-0.23.7.dist-info/LICENSE,sha256=TMatHW4_G9ldRdodEAp-l2Xa2WvsdeOh60E3v1R2jis,11349
-dagster_postgres-0.23.7.dist-info/METADATA,sha256=tOsQTETMefyuaNUKDNyEaHHm0eSmqNeQzg_jPlQVF0c,762
-dagster_postgres-0.23.7.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
-dagster_postgres-0.23.7.dist-info/top_level.txt,sha256=lScMtAEKDX1yIv2tGa1nzntBa0HEStfWPfCwD8FWlHk,17
-dagster_postgres-0.23.7.dist-info/RECORD,,