memmachine-server 0.2.2__tar.gz → 0.2.3__tar.gz

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: memmachine-server
-Version: 0.2.2
+Version: 0.2.3
 Summary: MemMachine Server - The complete MemMachine memory system server with episodic and profile memory
 Author-email: MemMachine <noreply@memmachine.ai>
 License-Expression: Apache-2.0
@@ -43,9 +43,16 @@ Dynamic: license-file
 
 <div align="center">
 
+![GitHub Release Version](https://img.shields.io/github/v/release/memmachine/memmachine?display_name=release)
 ![Discord](https://img.shields.io/discord/1412878659479666810)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/MemMachine/MemMachine)
 ![GitHub License](https://img.shields.io/github/license/MemMachine/MemMachine)
+<br/>
+![Docker Pulls](https://img.shields.io/docker/pulls/memmachine/memmachine)
+![GitHub Downloads](https://img.shields.io/github/downloads/memmachine/memmachine/total?label=GitHub%20Downloads)
+<br/>
+![PyPI Downloads - memmachine-client](https://img.shields.io/pypi/dm/memmachine-client?label=PyPI%20Downloads%3A%20memmachine-client)
+![PyPI Downloads - memmachine-server](https://img.shields.io/pypi/dm/memmachine-server?label=PyPI%20Downloads%3A%20memmachine-server)
 
 </div>
 

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/README.md

@@ -2,9 +2,16 @@
 
 <div align="center">
 
+![GitHub Release Version](https://img.shields.io/github/v/release/memmachine/memmachine?display_name=release)
 ![Discord](https://img.shields.io/discord/1412878659479666810)
 [![Ask DeepWiki](https://deepwiki.com/badge.svg)](https://deepwiki.com/MemMachine/MemMachine)
 ![GitHub License](https://img.shields.io/github/license/MemMachine/MemMachine)
+<br/>
+![Docker Pulls](https://img.shields.io/docker/pulls/memmachine/memmachine)
+![GitHub Downloads](https://img.shields.io/github/downloads/memmachine/memmachine/total?label=GitHub%20Downloads)
+<br/>
+![PyPI Downloads - memmachine-client](https://img.shields.io/pypi/dm/memmachine-client?label=PyPI%20Downloads%3A%20memmachine-client)
+![PyPI Downloads - memmachine-server](https://img.shields.io/pypi/dm/memmachine-server?label=PyPI%20Downloads%3A%20memmachine-server)
 
 </div>
 

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/pyproject.toml

@@ -1,10 +1,10 @@
 [build-system]
-requires = ["setuptools>=68.0", "wheel"]
+requires = ["setuptools>=68.0", "wheel", "setuptools-scm>=8.0"]
 build-backend = "setuptools.build_meta"
 
 [project]
 name = "memmachine-server"
-version = "v0.2.2"
+dynamic = ["version"]
 dependencies = [
     "alembic>=1.17.1",
     "asyncpg>=0.31.0",
@@ -96,3 +96,6 @@ packages = [
 
 [tool.setuptools.package-dir]
 "" = "src"
+
+[tool.setuptools_scm]
+root = "../.."

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/__init__.py

@@ -1,5 +1,6 @@
 """Public package exports and utilities for MemMachine."""
 
+from memmachine.common import api  # noqa: F401
 from memmachine.rest_client import MemMachineClient, Memory, Project
 
 try:

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/common/api/doc.py

@@ -128,6 +128,10 @@ class SpecDoc:
     The maximum number of memories to return in the search results.
     """
 
+    SCORE_THRESHOLD = """
+    The minimum score for a memory to be included in the search results. Defaults to -inf (no threshold) represented as None. Meaningful only for certain ranking methods.
+    """
+
     QUERY = """
     The natural language query used for semantic memory search. This should be
     a descriptive string of the information you are looking for.
@@ -208,6 +212,7 @@ class Examples:
     RERANKER: ClassVar[list[str]] = ["bge-reranker-large", "my-custom-reranker"]
     EMBEDDER: ClassVar[list[str]] = ["bge-base-en", "my-embedder"]
     TOP_K: ClassVar[list[int]] = [5, 10, 20]
+    SCORE_THRESHOLD: ClassVar[list[float | None]] = [0.0, 0.5, None]
     QUERY: ClassVar[list[str]] = [
         "What was the user's last conversation about finance?"
     ]

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/common/api/spec.py

@@ -392,6 +392,14 @@ class SearchMemoriesSpec(_WithOrgAndProj):
             examples=Examples.FILTER_MEM,
         ),
     ]
+    score_threshold: Annotated[
+        float | None,
+        Field(
+            default=None,
+            description=SpecDoc.SCORE_THRESHOLD,
+            examples=Examples.SCORE_THRESHOLD,
+        ),
+    ]
     types: Annotated[
         list[MemoryType],
         Field(

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/common/episode_store/episode_model.py

@@ -35,6 +35,7 @@ class EpisodeResponse(EpisodeEntry):
     """Episode data returned in responses."""
 
     uid: EpisodeIdT
+    score: float | None = None
 
 
 class Episode(BaseModel):

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/common/session_manager/session_data_manager_sql_impl.py

@@ -1,6 +1,6 @@
 """Manages database for session config and short term data."""
 
-import io
+import json
 import os
 import pickle
 from typing import Annotated, Any
@@ -9,17 +9,18 @@ from sqlalchemy import (
     JSON,
     ForeignKeyConstraint,
     Integer,
-    LargeBinary,
     PrimaryKeyConstraint,
     String,
     and_,
     func,
     insert,
+    inspect,
     select,
+    text,
     update,
 )
 from sqlalchemy.dialects.postgresql import JSONB
-from sqlalchemy.ext.asyncio import AsyncEngine, async_sessionmaker
+from sqlalchemy.ext.asyncio import AsyncConnection, AsyncEngine, async_sessionmaker
 from sqlalchemy.orm import (
     DeclarativeBase,
     Mapped,
@@ -44,7 +45,6 @@ IntColumn = Annotated[int, mapped_column(Integer)]
 StringKeyColumn = Annotated[str, mapped_column(String, primary_key=True)]
 StringColumn = Annotated[str, mapped_column(String)]
 JSONColumn = Annotated[dict, mapped_column(JSON_AUTO)]
-BinaryColumn = Annotated[bytes, mapped_column(LargeBinary)]
 
 
 class SessionDataManagerSQL(SessionDataManager):
@@ -57,7 +57,7 @@ class SessionDataManagerSQL(SessionDataManager):
         session_key: Mapped[StringKeyColumn]
         timestamp: Mapped[IntColumn]
         configuration: Mapped[JSONColumn]
-        param_data: Mapped[BinaryColumn]
+        param_data: Mapped[JSONColumn]
         description: Mapped[StringColumn]
         user_metadata: Mapped[JSONColumn]
         __table_args__ = (PrimaryKeyConstraint("session_key"),)
@@ -93,7 +93,24 @@ class SessionDataManagerSQL(SessionDataManager):
 
     async def create_tables(self) -> None:
         """Create the necessary tables in the database."""
+
+        def _check_migration_needed(conn: AsyncConnection) -> bool:
+            inspector = inspect(conn)
+            schema = self.SessionConfig.__table__.schema
+            table_name = "sessions"
+            table_names = inspector.get_table_names(schema=schema)
+            if table_name not in table_names:
+                return False
+            columns = inspector.get_columns(table_name, schema=schema)
+            for column in columns:
+                if column["name"] == "param_data":
+                    return "JSON" not in str(column["type"]).upper()
+            return False
+
         async with self._engine.begin() as conn:
+            if await conn.run_sync(_check_migration_needed):
+                await self._migrate_pickle_to_json()
+                return
             await conn.run_sync(Base.metadata.create_all)
 
     async def drop_tables(self) -> None:
@@ -104,6 +121,55 @@ class SessionDataManagerSQL(SessionDataManager):
     async def close(self) -> None:
         """Close any underlying connections."""
 
+    async def _migrate_pickle_to_json(self) -> None:
+        """Migrate param_data from pickle to JSON."""
+        schema = self.SessionConfig.__table__.schema
+        table_name = f"{schema}.sessions" if schema else "sessions"
+        json_type = "JSON"
+
+        async with self._engine.begin() as conn:
+            await conn.execute(
+                text(
+                    f"ALTER TABLE {table_name} RENAME COLUMN param_data TO param_data_blob"
+                )
+            )
+            await conn.execute(
+                text(f"ALTER TABLE {table_name} ADD COLUMN param_data {json_type}")
+            )
+
+            result = await conn.execute(
+                text(f"SELECT session_key, param_data_blob FROM {table_name}")
+            )
+
+            for session_key, blob_data in result:
+                if not blob_data:
+                    continue
+                try:
+                    obj = pickle.loads(blob_data)
+                    if hasattr(obj, "model_dump"):
+                        json_data = obj.model_dump(mode="json")
+                    elif hasattr(obj, "dict"):
+                        json_data = obj.dict()
+                    else:
+                        json_data = obj.__dict__
+
+                    val = json.dumps(json_data, default=str)
+
+                    await conn.execute(
+                        text(
+                            f"UPDATE {table_name} SET param_data = :val WHERE session_key = :key"
+                        ),
+                        {"val": val, "key": session_key},
+                    )
+                except Exception as exc:
+                    raise RuntimeError(
+                        f"Error migrating session {session_key}"
+                    ) from exc
+
+            await conn.execute(
+                text(f"ALTER TABLE {table_name} DROP COLUMN param_data_blob")
+            )
+
     async def create_new_session(
         self,
         session_key: str,
@@ -113,10 +179,13 @@ class SessionDataManagerSQL(SessionDataManager):
         metadata: dict[str, object],
     ) -> None:
         """Create a new session entry in the database."""
-        buffer = io.BytesIO()
-        pickle.dump(param, buffer)
-        buffer.seek(0)
-        param_data = buffer.getvalue()
+        if hasattr(param, "model_dump"):
+            param_data = param.model_dump(mode="json")
+        elif hasattr(param, "dict"):
+            param_data = param.dict()
+        else:
+            param_data = param.__dict__
+
         async with self._async_session() as dbsession:
             # Query for an existing session with the same ID
             sessions = await dbsession.execute(
@@ -164,9 +233,7 @@ class SessionDataManagerSQL(SessionDataManager):
             session = sessions.scalars().first()
             if session is None:
                 return None
-            binary_buffer = io.BytesIO(session.param_data)
-            binary_buffer.seek(0)
-            param: EpisodicMemoryConf = pickle.load(binary_buffer)
+            param = EpisodicMemoryConf(**session.param_data)
 
             return SessionDataManager.SessionInfo(
                 configuration=session.configuration,

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/common/vector_graph_store/neo4j_vector_graph_store.py

@@ -557,9 +557,8 @@ class Neo4jVectorGraphStore(VectorGraphStore):
         )
         await self._driver.execute_query(
             "UNWIND $edges AS edge\n"
-            "MATCH"
-            f"    (source:{sanitized_source_collection} {{uid: edge.source_uid}}),"
-            f"    (target:{sanitized_target_collection} {{uid: edge.target_uid}})\n"
+            f"MATCH (source:{sanitized_source_collection} {{uid: edge.source_uid}})\n"
+            f"MATCH (target:{sanitized_target_collection} {{uid: edge.target_uid}})\n"
             "CREATE (source)"
             f"    -[r:{sanitized_relation} {{uid: edge.uid}}]->"
             "    (target)\n"

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/episodic_memory/declarative_memory/declarative_memory.py

@@ -306,6 +306,39 @@ class DeclarativeMemory:
             list[Episode]:
                 A list of episodes relevant to the query, ordered chronologically.
 
+        """
+        scored_episodes = await self.search_scored(
+            query,
+            max_num_episodes=max_num_episodes,
+            property_filter=property_filter,
+        )
+        return [episode for _, episode in scored_episodes]
+
+    async def search_scored(
+        self,
+        query: str,
+        *,
+        max_num_episodes: int = 20,
+        property_filter: FilterExpr | None = None,
+    ) -> list[tuple[float, Episode]]:
+        """
+        Search declarative memory for episodes relevant to the query, returning scored episodes.
+
+        Args:
+            query (str):
+                The search query.
+            max_num_episodes (int):
+                The maximum number of episodes to return
+                (default: 20).
+            property_filter (FilterExpr | None):
+                Filterable property keys and values
+                to use for filtering episodes
+                (default: None).
+
+        Returns:
+            list[tuple[float, Episode]]:
+                A list of scored episodes relevant to the query, ordered chronologically.
+
         """
         mangled_property_filter = DeclarativeMemory._mangle_property_filter(
             property_filter,
@@ -377,9 +410,9 @@ class DeclarativeMemory:
             episode_contexts,
         )
 
-        reranked_anchored_episode_contexts = [
-            (nuclear_episode, episode_context)
-            for _, nuclear_episode, episode_context in sorted(
+        reranked_scored_anchored_episode_contexts = [
+            (episode_context_score, nuclear_episode, episode_context)
+            for episode_context_score, nuclear_episode, episode_context in sorted(
                 zip(
                     episode_context_scores,
                     nuclear_episodes,
@@ -392,11 +425,13 @@ class DeclarativeMemory:
         ]
 
         # Unify episode contexts.
-        unified_episode_context = DeclarativeMemory._unify_anchored_episode_contexts(
-            reranked_anchored_episode_contexts,
-            max_num_episodes=max_num_episodes,
+        unified_scored_episode_context = (
+            DeclarativeMemory._unify_scored_anchored_episode_contexts(
+                reranked_scored_anchored_episode_contexts,
+                max_num_episodes=max_num_episodes,
+            )
         )
-        return unified_episode_context
+        return unified_scored_episode_context
 
     async def _contextualize_episode(
         self,
@@ -569,21 +604,29 @@ class DeclarativeMemory:
         await asyncio.gather(*delete_nodes_tasks)
 
     @staticmethod
-    def _unify_anchored_episode_contexts(
-        anchored_episode_contexts: Iterable[tuple[Episode, Iterable[Episode]]],
+    def _unify_scored_anchored_episode_contexts(
+        scored_anchored_episode_contexts: Iterable[
+            tuple[float, Episode, Iterable[Episode]]
+        ],
         max_num_episodes: int,
-    ) -> list[Episode]:
+    ) -> list[tuple[float, Episode]]:
         """Unify anchored episode contexts into a single list within the limit."""
-        episode_set: set[Episode] = set()
+        episode_scores: dict[Episode, float] = {}
 
-        for nuclear_episode, context in anchored_episode_contexts:
+        for score, nuclear_episode, context in scored_anchored_episode_contexts:
             context = list(context)
 
-            if len(episode_set) >= max_num_episodes:
+            if len(episode_scores) >= max_num_episodes:
                 break
-            if (len(episode_set) + len(context)) <= max_num_episodes:
+            if (len(episode_scores) + len(context)) <= max_num_episodes:
                 # It is impossible that the context exceeds the limit.
-                episode_set.update(context)
+                episode_scores.update(
+                    {
+                        episode: score
+                        for episode in context
+                        if episode not in episode_scores
+                    }
+                )
             else:
                 # It is possible that the context exceeds the limit.
                 # Prioritize episodes near the nuclear episode.
@@ -603,15 +646,15 @@ class DeclarativeMemory:
                 # Add episodes to unified context until limit is reached,
                 # or until the context is exhausted.
                 for episode in nuclear_context:
-                    if len(episode_set) >= max_num_episodes:
+                    if len(episode_scores) >= max_num_episodes:
                         break
-                    episode_set.add(episode)
+                    episode_scores.setdefault(episode, score)
 
         unified_episode_context = sorted(
-            episode_set,
-            key=lambda episode: (
-                episode.timestamp,
-                episode.uid,
+            [(score, episode) for episode, score in episode_scores.items()],
+            key=lambda scored_episode: (
+                scored_episode[1].timestamp,
+                scored_episode[1].uid,
             ),
         )
 

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/episodic_memory/episodic_memory.py

@@ -305,7 +305,9 @@ class EpisodicMemory:
     async def query_memory(
         self,
         query: str,
+        *,
         limit: int | None = None,
+        score_threshold: float = -float("inf"),
         property_filter: FilterExpr | None = None,
     ) -> QueryResponse | None:
         """
@@ -320,6 +322,7 @@ class EpisodicMemory:
             limit: The maximum number of episodes to return. The limit is
                    applied to both short and long term memories. The default
                    value is 20.
+            score_threshold: Minimum score to consider a match.
             property_filter: Properties to filter declarative memory searches.
 
         Returns:
@@ -336,9 +339,12 @@ class EpisodicMemory:
         if self._short_term_memory is None:
             short_episode: list[Episode] = []
             short_summary = ""
-            long_episode = await cast("LongTermMemory", self._long_term_memory).search(
+            scored_long_episodes = await cast(
+                "LongTermMemory", self._long_term_memory
+            ).search_scored(
                 query,
                 num_episodes_limit=search_limit,
+                score_threshold=score_threshold,
                 property_filter=property_filter,
             )
         elif self._long_term_memory is None:
@@ -349,19 +355,20 @@ class EpisodicMemory:
                     filters=property_filter,
                 )
             )
-            long_episode = []
+            scored_long_episodes = []
             short_episode, short_summary = session_result
         else:
             # Concurrently search both memory stores
-            session_result, long_episode = await asyncio.gather(
+            session_result, scored_long_episodes = await asyncio.gather(
                 self._short_term_memory.get_short_term_memory_context(
                     query,
                     limit=search_limit,
                     filters=property_filter,
                 ),
-                self._long_term_memory.search(
+                self._long_term_memory.search_scored(
                     query,
                     num_episodes_limit=search_limit,
+                    score_threshold=score_threshold,
                     property_filter=property_filter,
                 ),
             )
@@ -371,11 +378,11 @@ class EpisodicMemory:
         # short-term memory
         episode_uid_set = {episode.uid for episode in short_episode}
 
-        unique_long_episodes = []
-        for episode in long_episode:
+        unique_scored_long_episodes = []
+        for score, episode in scored_long_episodes:
             if episode.uid not in episode_uid_set:
                 episode_uid_set.add(episode.uid)
-                unique_long_episodes.append(episode)
+                unique_scored_long_episodes.append((score, episode))
 
         end_time = time.monotonic_ns()
         delta = (end_time - start_time) / 1000000
@@ -391,8 +398,8 @@ class EpisodicMemory:
             ),
             long_term_memory=EpisodicMemory.QueryResponse.LongTermMemoryResponse(
                 episodes=[
-                    EpisodeResponse(**episode.model_dump())
-                    for episode in unique_long_episodes
+                    EpisodeResponse(score=score, **episode.model_dump())
+                    for score, episode in unique_scored_long_episodes
                 ],
             ),
         )
@@ -401,6 +408,7 @@ class EpisodicMemory:
         self,
         query: str,
         limit: int | None = None,
+        score_threshold: float = -float("inf"),
         property_filter: FilterExpr | None = None,
     ) -> str:
         """
@@ -412,6 +420,7 @@ class EpisodicMemory:
         Args:
             query: The original query string.
             limit: The maximum number of episodes to include in the context.
+            score_threshold: Minimum score to include in the context.
             property_filter: Properties to filter the search.
 
         Returns:
@@ -420,8 +429,9 @@ class EpisodicMemory:
         """
         query_result = await self.query_memory(
             query,
-            limit,
-            property_filter,
+            limit=limit,
+            score_threshold=score_threshold,
+            property_filter=property_filter,
         )
         if query_result is None:
             logger.warning("Query result is None in formalize_query_with_context")

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/episodic_memory/long_term_memory/long_term_memory.py

@@ -139,18 +139,45 @@ class LongTermMemory:
         query: str,
         *,
         num_episodes_limit: int,
+        score_threshold: float = -float("inf"),
         property_filter: FilterExpr | None = None,
     ) -> list[Episode]:
-        declarative_memory_episodes = await self._declarative_memory.search(
+        scored_episodes = await self.search_scored(
             query,
-            max_num_episodes=num_episodes_limit,
-            property_filter=LongTermMemory._sanitize_property_filter(property_filter),
+            num_episodes_limit=num_episodes_limit,
+            score_threshold=score_threshold,
+            property_filter=property_filter,
+        )
+        return [episode for _, episode in scored_episodes]
+
+    async def search_scored(
+        self,
+        query: str,
+        *,
+        num_episodes_limit: int,
+        score_threshold: float = -float("inf"),
+        property_filter: FilterExpr | None = None,
+    ) -> list[tuple[float, Episode]]:
+        scored_declarative_memory_episodes = (
+            await self._declarative_memory.search_scored(
+                query,
+                max_num_episodes=num_episodes_limit,
+                property_filter=LongTermMemory._sanitize_property_filter(
+                    property_filter
+                ),
+            )
         )
         return [
-            LongTermMemory._episode_from_declarative_memory_episode(
-                declarative_memory_episode,
+            (
+                score,
+                LongTermMemory._episode_from_declarative_memory_episode(
+                    declarative_memory_episode,
+                ),
             )
-            for declarative_memory_episode in declarative_memory_episodes
+            for score, declarative_memory_episode in (
+                scored_declarative_memory_episodes
+            )
+            if score >= score_threshold
         ]
 
     async def get_episodes(self, uids: Iterable[str]) -> list[Episode]:

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/main/memmachine.py

@@ -309,6 +309,7 @@ class MemMachine:
         session_data: InstanceOf[SessionData],
         query: str,
         limit: int | None = None,
+        score_threshold: float = -float("inf"),
         search_filter: FilterExpr | None = None,
     ) -> EpisodicMemory.QueryResponse | None:
         episodic_memory_manager = await self._resources.get_episodic_memory_manager()
@@ -324,6 +325,7 @@ class MemMachine:
             response = await episodic_session.query_memory(
                 query=query,
                 limit=limit,
+                score_threshold=score_threshold,
                 property_filter=search_filter,
             )
 
@@ -337,6 +339,7 @@ class MemMachine:
         query: str,
         limit: int
         | None = None,  # TODO: Define if limit is per memory or is global limit
+        score_threshold: float = -float("inf"),
         search_filter: str | None = None,
     ) -> SearchResponse:
         episodic_task: Task | None = None
@@ -349,6 +352,7 @@ class MemMachine:
                     session_data=session_data,
                     query=query,
                     limit=limit,
+                    score_threshold=score_threshold,
                     search_filter=property_filter,
                 )
             )

{memmachine_server-0.2.2 → memmachine_server-0.2.3}/src/memmachine/rest_client/memory.py

@@ -325,6 +325,7 @@ class Memory:
         self,
         query: str,
         limit: int | None = None,
+        score_threshold: float | None = None,
         filter_dict: dict[str, str] | None = None,
         timeout: int | None = None,
     ) -> SearchResult:
@@ -339,6 +340,7 @@ class Memory:
         Args:
             query: Search query string
             limit: Maximum number of results to return
+            score_threshold: Minimum score to include in results.
             filter_dict: Additional filters for the search (key-value pairs as strings).
                         These filters will be merged with built-in filters from metadata.
                         User-provided filters take precedence over built-in filters
@@ -377,6 +379,7 @@ class Memory:
             project_id=self.__project_id,
             query=query,
             top_k=limit or 10,
+            score_threshold=score_threshold,
             filter=filter_str,
             types=[MemoryType.Episodic, MemoryType.Semantic],  # Search both types
         )

memmachine_server-0.2.3/src/memmachine/semantic_memory/storage/alembic_pg/script.py.mako

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}