mage-ai 0.9.75__py3-none-any.whl → 0.9.77__py3-none-any.whl

mage_ai/data_preparation/templates/constants.py

@@ -19,6 +19,13 @@ GROUP_ROW_ACTIONS = 'Row actions'
 GROUP_SHIFT = 'Shift'
 
 TEMPLATES = [
+    dict(
+        block_type=BlockType.DATA_LOADER,
+        description='Load a Table from Airtable App.',
+        language=BlockLanguage.PYTHON,
+        name='Airtable',
+        path='data_loaders/airtable.py',
+    ),
     dict(
         block_type=BlockType.DATA_LOADER,
         description='Load a Delta Table from Amazon S3.',

mage_ai/data_preparation/templates/data_loaders/airtable.py

@@ -0,0 +1,28 @@
+{% extends "data_loaders/default.jinja" %}
+{% block imports %}
+from mage_ai.settings.repo import get_repo_path
+from mage_ai.io.config import ConfigFileLoader
+from mage_ai.io.airtable import Airtable
+from os import path
+{{ super() -}}
+{% endblock %}
+
+
+{% block content %}
+@data_loader
+def load_data_from_airtable(*args, **kwargs):
+    """
+    Template for loading data from Airtable.
+    Specify your configuration settings in 'io_config.yaml'.
+    """
+    config_path = path.join(get_repo_path(), 'io_config.yaml')
+    config_profile = 'default'
+
+    base_id = 'your_base_id'
+    table_name = 'your_table_name'
+
+    return Airtable.with_config(ConfigFileLoader(config_path, config_profile)).load(
+        base_id=base_id,
+        table_name=table_name
+    )
+{% endblock %}

mage_ai/data_preparation/templates/repo/io_config.yaml

@@ -11,6 +11,8 @@ default:
   ALGOLIA_APP_ID: app_id
   ALGOLIA_API_KEY: api_key
   ALGOLIA_INDEX_NAME: index_name
+  # Airtable
+  AIRTABLE_ACCESS_TOKEN: token
   # Azure
   AZURE_CLIENT_ID: "{{ env_var('AZURE_CLIENT_ID') }}"
   AZURE_CLIENT_SECRET: "{{ env_var('AZURE_CLIENT_SECRET') }}"

mage_ai/io/airtable.py

@@ -0,0 +1,104 @@
+from typing import Union
+
+import pandas as pd
+import polars as pl
+from pyairtable.api import Api
+
+from mage_ai.io.base import BaseIO
+from mage_ai.io.config import BaseConfigLoader, ConfigKey
+
+
+class Airtable(BaseIO):
+    """
+    Handles data transfer between Airtable tables and the Mage app.
+    """
+
+    def __init__(
+            self,
+            token: str,
+            verbose: bool = True,
+            **kwargs) -> None:
+        """
+        Initializes a connection to Airtable.
+
+        Args:
+            token (str): Airtable API token.
+            verbose (bool, optional): Whether to print verbose output. Defaults to True.
+            **kwargs: Additional keyword arguments to pass to the pyairtable Api constructor.
+        """
+        super().__init__(verbose=verbose)
+        self.client = Api(token, **kwargs)  # Create the Airtable API client
+
+    @classmethod
+    def with_config(
+            cls,
+            config: BaseConfigLoader
+    ) -> 'Airtable':
+        """
+        Initializes an Airtable client from a configuration loader.
+
+        Args:
+            config (BaseConfigLoader): Configuration loader object.
+
+        Raises:
+            ValueError: If no valid Airtable API token is found in the configuration.
+
+        Returns:
+            Airtable: An instance of the Airtable class.
+        """
+        if ConfigKey.AIRTABLE_ACCESS_TOKEN not in config:
+            raise ValueError(
+                'No valid API token found for Airtable.'
+                'You must specify your access token in your config.'
+            )
+
+        return cls(
+            token=config[ConfigKey.AIRTABLE_ACCESS_TOKEN]
+        )
+
+    def load(
+            self,
+            base_id: str,
+            table_name: str,
+            **kwargs,
+    ) -> pd.DataFrame:
+        """
+        Loads data from an Airtable table into a Pandas DataFrame.
+
+        Args:
+            base_id (str): The ID of the Airtable base (e.g., 'app*****').
+            table_name (str): The name or ID of the Airtable table (e.g., 'tbl*****').
+            **kwargs: Additional keyword arguments to pass to the pyairtable table.all() method.
+
+        Returns:
+            DataFrame: A Pandas DataFrame containing the data from the Airtable table.
+        """
+        with self.printer.print_msg(
+                f'Loading data frame from table \'{table_name}\' at airtable app \'{base_id}\''
+        ):
+            table = self.client.table(base_id, table_name)  # Get the Airtable table
+            data = table.all(**kwargs)  # Fetch all records from the table
+
+            # Flatten the Airtable data structure into a list of dictionaries
+            flattened_data = []
+            for record in data:
+                flattened_record = {
+                    'id': record['id'],
+                    'createdTime': record['createdTime']
+                }
+                fields = record['fields']
+                flattened_record.update(fields)
+                flattened_data.append(flattened_record)
+
+            return pd.DataFrame(flattened_data)  # Create and return a DataFrame
+
+    def export(
+            self,
+            df: Union[pd.DataFrame, pl.DataFrame],
+            *args,
+            **kwargs
+    ) -> None:
+        """
+        Not implemented yet. This method is intended to export data to Airtable.
+        """
+        pass

mage_ai/io/base.py

@@ -16,6 +16,7 @@ QUERY_ROW_LIMIT = 10_000_000
 
 
 class DataSource(StrEnum):
+    AIRTABLE = 'airtable'
     ALGOLIA = 'algolia'
     API = 'api'
     BIGQUERY = 'bigquery'

mage_ai/io/bigquery.py

@@ -1,7 +1,9 @@
+import traceback
 import uuid
 from typing import Dict, List, Mapping, Union
 
 import numpy as np
+import pandas as pd
 from google.cloud.bigquery import (
     Client,
     LoadJobConfig,
@@ -399,7 +401,41 @@ WHERE table_id = '{table_name}'
             # Clean column names
             if type(df) is DataFrame:
                 df.columns = df.columns.str.replace(' ', '_')
+            table = None
+            try:
+                # Cast column types
+                table = self.client.get_table(table_id)
+            except Exception:
+                print(f'Table {table_id} does not exist.')
+                pass
 
+            if table is not None:
+                try:
+                    timestamp_columns = [field.name for field in table.schema
+                                         if field.field_type == 'TIMESTAMP']
+
+                    # Convert TIMESTAMP columns in DataFrame
+                    for col in timestamp_columns:
+                        if col in df.columns:
+                            df[col] = pd.to_datetime(df[col])
+                except Exception:
+                    print('Fail to cast column types in dataframe.')
+                    traceback.print_exc()
+                if (
+                    not config.schema and
+                    config.write_disposition == WriteDisposition.WRITE_TRUNCATE
+                ):
+                    df_columns = df.columns.tolist()
+                    config.schema = [
+                        SchemaField(
+                            field.name,
+                            field.field_type,
+                            mode=field.mode,
+                            fields=field.fields,
+                        )
+                        for field in table.schema
+                        if field.name in df_columns
+                    ]
             return self.client.load_table_from_dataframe(df, table_id, job_config=config).result()
 
     def execute(self, query_string: str, **kwargs) -> None:

mage_ai/io/config.py

@@ -16,6 +16,8 @@ class ConfigKey(StrEnum):
     List of configuration settings for use with data IO clients.
     """
 
+    AIRTABLE_ACCESS_TOKEN = "AIRTABLE_ACCESS_TOKEN"
+
     ALGOLIA_APP_ID = 'ALGOLIA_APP_ID'
     ALGOLIA_API_KEY = 'ALGOLIA_API_KEY'
     ALGOLIA_INDEX_NAME = 'ALGOLIA_INDEX_NAME'
@@ -64,6 +66,7 @@ class ConfigKey(StrEnum):
     MONGODB_PORT = 'MONGODB_PORT'
     MONGODB_USER = 'MONGODB_USER'
 
+    MSSQL_AUTHENTICATION = 'MSSQL_AUTHENTICATION'
     MSSQL_DATABASE = 'MSSQL_DATABASE'
     MSSQL_DRIVER = 'MSSQL_DRIVER'
     MSSQL_HOST = 'MSSQL_HOST'
@@ -78,6 +81,7 @@ class ConfigKey(StrEnum):
     MYSQL_PASSWORD = 'MYSQL_PASSWORD'
     MYSQL_PORT = 'MYSQL_PORT'
     MYSQL_USER = 'MYSQL_USER'
+    MYSQL_ALLOW_LOCAL_INFILE = 'MYSQL_ALLOW_LOCAL_INFILE'
 
     ORACLEDB_USER = 'ORACLEDB_USER'
     ORACLEDB_PASSWORD = 'ORACLEDB_PASSWORD'
@@ -338,6 +342,7 @@ class VerboseConfigKey(StrEnum):
     Config key headers for the verbose configuration file format.
     """
 
+    AIRTABLE = 'Airtable'
     ALGOLIA = 'Algolia'
     AWS = 'AWS'
     BIGQUERY = 'BigQuery'
@@ -356,6 +361,7 @@ class VerboseConfigKey(StrEnum):
 
 class ConfigFileLoader(BaseConfigLoader):
     KEY_MAP = {
+        ConfigKey.AIRTABLE_ACCESS_TOKEN: VerboseConfigKey.AIRTABLE,
         ConfigKey.ALGOLIA_APP_ID: (
             VerboseConfigKey.ALGOLIA, 'app_id'),
         ConfigKey.ALGOLIA_API_KEY: (

mage_ai/io/mssql.py

@@ -14,6 +14,7 @@ from mage_ai.io.config import BaseConfigLoader, ConfigKey
 from mage_ai.io.constants import UNIQUE_CONFLICT_METHOD_UPDATE
 from mage_ai.io.export_utils import PandasTypes
 from mage_ai.io.sql import BaseSQL
+from mage_ai.shared.hash import extract
 from mage_ai.shared.parsers import encode_complex
 
 MERGE_TABLE_SQL = '''MERGE {table_name} AS t
@@ -37,12 +38,14 @@ class MSSQL(BaseSQL):
         host: str,
         password: str,
         user: str,
+        authentication: str = None,
         schema: str = None,
         port: int = 1433,
         verbose: bool = True,
         **kwargs,
     ) -> None:
         super().__init__(
+            authentication=authentication,
             database=database,
             server=host,
             user=user,
@@ -60,15 +63,19 @@ class MSSQL(BaseSQL):
         database = self.settings['database']
         username = self.settings['user']
         password = self.settings['password']
-        return (
-            f'DRIVER={{{driver}}};'
-            f'SERVER={server};'
-            f'DATABASE={database};'
-            f'UID={username};'
-            f'PWD={password};'
-            'ENCRYPT=yes;'
-            'TrustServerCertificate=yes;'
-        )
+        conn_opts = [
+            f'DRIVER={{{driver}}}',
+            f'SERVER={server}',
+            f'DATABASE={database}',
+            f'UID={username}',
+            f'PWD={password}',
+            'ENCRYPT=yes',
+            'TrustServerCertificate=yes',
+        ]
+        if self.settings.get('authentication'):
+            authentication = self.settings.get('authentication')
+            conn_opts.append(f'Authentication={authentication}')
+        return ';'.join(conn_opts)
 
     def default_schema(self) -> str:
         return self.settings.get('schema') or 'dbo'
@@ -197,9 +204,11 @@ class MSSQL(BaseSQL):
                 TrustServerCertificate='yes',
             ),
         )
+        conn_kwargs = extract(kwargs, ['pool_size', 'max_overflow'])
         engine = create_engine(
             connection_url,
             fast_executemany=True,
+            **conn_kwargs,
         )
 
         unique_conflict_method = kwargs.get('unique_conflict_method')
@@ -242,6 +251,7 @@ class MSSQL(BaseSQL):
                     method=merge_table,
                 )
                 return
+        sql_kwargs = extract(kwargs, ['chunksize', 'method'])
 
         df.to_sql(
             table_name,
@@ -249,6 +259,7 @@ class MSSQL(BaseSQL):
             schema=schema_name,
             if_exists=if_exists or ExportWritePolicy.REPLACE,
             index=False,
+            **sql_kwargs,
         )
 
     def get_type(self, column: Series, dtype: str) -> str:
@@ -313,6 +324,7 @@ class MSSQL(BaseSQL):
     @classmethod
     def with_config(cls, config: BaseConfigLoader) -> 'MSSQL':
         return cls(
+            authentication=config[ConfigKey.MSSQL_AUTHENTICATION],
             database=config[ConfigKey.MSSQL_DATABASE],
             schema=config[ConfigKey.MSSQL_SCHEMA],
             driver=config[ConfigKey.MSSQL_DRIVER],

mage_ai/io/mysql.py

@@ -25,6 +25,7 @@ class MySQL(BaseSQL):
         password: str,
         user: str,
         port: int = 3306,
+        allow_local_infile: bool = False,
         verbose: bool = True,
         **kwargs,
     ) -> None:
@@ -35,18 +36,22 @@ class MySQL(BaseSQL):
             port=port or 3306,
             user=user,
             verbose=verbose,
+            allow_local_infile=allow_local_infile,
             **kwargs,
         )
 
     @classmethod
     def with_config(cls, config: BaseConfigLoader) -> 'MySQL':
-        return cls(
+        conn_kwargs = dict(
             database=config[ConfigKey.MYSQL_DATABASE],
             host=config[ConfigKey.MYSQL_HOST],
             password=config[ConfigKey.MYSQL_PASSWORD],
             port=config[ConfigKey.MYSQL_PORT],
             user=config[ConfigKey.MYSQL_USER],
         )
+        if config[ConfigKey.MYSQL_ALLOW_LOCAL_INFILE] is not None:
+            conn_kwargs['allow_local_infile'] = config[ConfigKey.MYSQL_ALLOW_LOCAL_INFILE]
+        return cls(**conn_kwargs)
 
     def build_create_table_command(
         self,

mage_ai/io/postgres.py

@@ -329,18 +329,21 @@ class Postgres(BaseSQL):
                 return simplejson.dumps(
                     val,
                     default=encode_complex,
+                    ensure_ascii=False,
                     ignore_nan=True,
                 )
             elif type(val) is list and len(val) >= 1 and type(val[0]) is dict:
                 return simplejson.dumps(
                     val,
                     default=encode_complex,
+                    ensure_ascii=False,
                     ignore_nan=True,
                 )
             elif not use_insert_command and type(val) is list:
                 return self._clean_array_value(simplejson.dumps(
                     val,
                     default=encode_complex,
+                    ensure_ascii=False,
                     ignore_nan=True,
                 ))
             return val

mage_ai/io/redshift.py

@@ -5,6 +5,7 @@ from typing import Dict, Union
 from pandas import DataFrame
 from redshift_connector import connect
 
+from mage_ai.data_preparation.models.block.sql.utils.shared import split_query_string
 from mage_ai.io.base import QUERY_ROW_LIMIT, ExportWritePolicy
 from mage_ai.io.config import BaseConfigLoader, ConfigKey
 from mage_ai.io.export_utils import clean_df_for_export, infer_dtypes
@@ -67,6 +68,18 @@ class Redshift(BaseSQL):
             with self.conn.cursor() as cur:
                 cur.execute(query_string, **kwargs)
 
+    def execute_query_raw(self, query: str, **kwargs) -> None:
+        """
+        Overwrite execute query to process multiple queries in one string.
+        """
+        results = []
+        with self.conn.cursor() as cursor:
+            for query_string in split_query_string(query):
+                result = cursor.execute(query_string)
+                results.append(result)
+        self.conn.commit()
+        return results
+
     def load(
         self,
         query_string: str,

mage_ai/io/sql.py

@@ -301,6 +301,7 @@ class BaseSQL(BaseSQLConnection):
                     if_exists=if_exists,
                     unique_conflict_method=unique_conflict_method,
                     unique_constraints=unique_constraints,
+                    **kwargs,
                 )
                 return
 

mage_ai/orchestration/db/__init__.py

@@ -1,5 +1,6 @@
 import logging
 import os
+from functools import wraps
 from urllib.parse import parse_qs, quote_plus, urlparse
 
 import sqlalchemy
@@ -169,6 +170,25 @@ def safe_db_query(func):
     return func_with_rollback
 
 
+def safe_db_query_async(func):
+    @wraps(func)
+    async def func_with_rollback_async(*args, **kwargs):
+        retry_count = 0
+        while True:
+            try:
+                return await func(*args, **kwargs)
+            except (
+                sqlalchemy.exc.OperationalError,
+                sqlalchemy.exc.PendingRollbackError,
+                sqlalchemy.exc.InternalError,
+            ) as e:
+                db_connection.session.rollback()
+                if retry_count >= DB_RETRY_COUNT:
+                    raise e
+                retry_count += 1
+    return func_with_rollback_async
+
+
 logging.basicConfig()
 
 if is_debug() and not os.getenv('DISABLE_DATABASE_TERMINAL_OUTPUT'):

mage_ai/orchestration/db/migrations/versions/39d36f1dab73_create_genericjob.py

@@ -0,0 +1,47 @@
+"""Create GenericJob
+
+Revision ID: 39d36f1dab73
+Revises: 0227396a216c
+Create Date: 2025-08-27 20:45:29.756869
+
+"""
+from alembic import op
+import sqlalchemy as sa
+
+
+# revision identifiers, used by Alembic.
+revision = '39d36f1dab73'
+down_revision = '0227396a216c'
+branch_labels = None
+depends_on = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.create_table('generic_job',
+    sa.Column('id', sa.Integer(), autoincrement=True, nullable=False),
+    sa.Column('created_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
+    sa.Column('updated_at', sa.DateTime(timezone=True), server_default=sa.text('(CURRENT_TIMESTAMP)'), nullable=True),
+    sa.Column('job_type', sa.Enum('CANCEL_PIPELINE_RUN', name='jobtype'), nullable=False),
+    sa.Column('status', sa.Enum('INITIAL', 'QUEUED', 'RUNNING', 'COMPLETED', 'FAILED', name='jobstatus'), nullable=True),
+    sa.Column('payload', sa.JSON(), nullable=True),
+    sa.Column('extra_metadata', sa.JSON(), nullable=True),
+    sa.Column('started_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('completed_at', sa.DateTime(timezone=True), nullable=True),
+    sa.Column('repo_path', sa.String(length=255), nullable=True),
+    sa.PrimaryKeyConstraint('id')
+    )
+    with op.batch_alter_table('generic_job', schema=None) as batch_op:
+        batch_op.create_index(batch_op.f('ix_generic_job_job_type'), ['job_type'], unique=False)
+        batch_op.create_index(batch_op.f('ix_generic_job_status'), ['status'], unique=False)
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    with op.batch_alter_table('generic_job', schema=None) as batch_op:
+        batch_op.drop_index(batch_op.f('ix_generic_job_status'))
+        batch_op.drop_index(batch_op.f('ix_generic_job_job_type'))
+
+    op.drop_table('generic_job')
+    # ### end Alembic commands ###

mage_ai/orchestration/db/models/oauth.py

@@ -882,4 +882,5 @@ class Oauth2AccessToken(BaseModel):
     def is_valid(self) -> bool:
         return self.token and \
             self.expires and \
-            self.expires >= datetime.utcnow().replace(tzinfo=self.expires.tzinfo)
+            self.expires >= datetime.utcnow().replace(tzinfo=self.expires.tzinfo) and \
+            self.user is not None

mage_ai/orchestration/db/models/schedules.py

@@ -1,4 +1,3 @@
-import asyncio
 import collections
 import traceback
 import uuid
@@ -1400,10 +1399,8 @@ class PipelineRun(PipelineRunProjectPlatformMixin, BaseModel):
 
         from mage_ai.usage_statistics.logger import UsageStatisticLogger
 
-        asyncio.run(
-            UsageStatisticLogger().pipeline_runs_impression(
-                lambda: self.query.filter(self.status == self.PipelineRunStatus.COMPLETED).count(),
-            )
+        UsageStatisticLogger().pipeline_runs_impression_sync(
+            lambda: self.query.filter(self.status == self.PipelineRunStatus.COMPLETED).count(),
         )
 
     @safe_db_query
@@ -1807,6 +1804,111 @@ class BlockRun(BlockRunProjectPlatformMixin, BaseModel):
         )
 
 
+class GenericJob(BaseModel):
+    class JobStatus(StrEnum):
+        INITIAL = 'initial'
+        QUEUED = 'queued'
+        RUNNING = 'running'
+        COMPLETED = 'completed'
+        FAILED = 'failed'
+
+    class JobType(StrEnum):
+        CANCEL_PIPELINE_RUN = 'cancel_pipeline_run'
+
+    job_type = Column(Enum(JobType), nullable=False, index=True)
+    status = Column(Enum(JobStatus), default=JobStatus.INITIAL, index=True)
+    payload = Column(JSON)  # Job-specific data (e.g., pipeline_run_id)
+    extra_metadata = Column(JSON)  # Additional metadata for the job
+    started_at = Column(DateTime(timezone=True))
+    completed_at = Column(DateTime(timezone=True))
+    repo_path = Column(String(255))
+
+    @classproperty
+    def repo_query(cls):
+        return cls.query.filter(
+            or_(
+                GenericJob.repo_path == get_repo_path(),
+                GenericJob.repo_path.is_(None),
+            )
+        )
+
+    @classmethod
+    @safe_db_query
+    def enqueue_cancel_pipeline_run(
+        cls,
+        pipeline_run_id: int,
+        cancelled_block_run_ids: List,
+        repo_path: str = None,
+    ) -> 'GenericJob':
+        """Enqueue a job to cancel a pipeline run."""
+        if repo_path is None:
+            repo_path = get_repo_path()
+
+        job = cls.create(
+            job_type=cls.JobType.CANCEL_PIPELINE_RUN,
+            payload=dict(
+                pipeline_run_id=pipeline_run_id,
+                cancelled_block_run_ids=cancelled_block_run_ids,
+            ),
+            repo_path=repo_path,
+            status=cls.JobStatus.INITIAL
+        )
+        return job
+
+    @classmethod
+    @safe_db_query
+    def get_jobs_with_initial_status(
+        cls,
+        limit: int = 10,
+        repo_path: str = None,
+    ) -> List['GenericJob']:
+        """Get up to N jobs with INITIAL status for processing."""
+        query = cls.repo_query.filter(
+            cls.status == cls.JobStatus.INITIAL,
+        )
+
+        if repo_path:
+            query = query.filter(cls.repo_path == repo_path)
+
+        jobs = query.order_by(cls.created_at.asc()).limit(limit).all()
+
+        return jobs
+
+    @safe_db_query
+    def mark_completed(self):
+        """Mark the job as completed successfully."""
+        self.update(
+            status=self.JobStatus.COMPLETED,
+            completed_at=datetime.now(tz=pytz.UTC)
+        )
+
+    @safe_db_query
+    def mark_failed(self, metadata: dict = None):
+        """Mark the job as failed."""
+        self.update(
+            status=self.JobStatus.FAILED,
+            completed_at=datetime.now(tz=pytz.UTC),
+            extra_metadata=metadata or {}
+        )
+
+    @safe_db_query
+    def mark_queued(self):
+        """Mark the job as queued."""
+        self.update(
+            status=self.JobStatus.QUEUED,
+        )
+
+    @safe_db_query
+    def mark_running(self):
+        """Mark the job as queued."""
+        self.update(
+            status=self.JobStatus.RUNNING,
+        )
+
+    def __repr__(self):
+        return f'GenericJob(id={self.id}, type={self.job_type}, status={self.status})'
+
+
 class EventMatcher(BaseModel):
     class EventType(StrEnum):
         AWS_EVENT = 'aws_event'

mage_ai/orchestration/db/models/secrets.py

@@ -3,7 +3,8 @@ from typing import Optional
 from sqlalchemy import Column, String, Text, UniqueConstraint, or_
 
 from mage_ai.orchestration.db import safe_db_query
-from mage_ai.orchestration.db.models.base import BaseModel
+from mage_ai.orchestration.db.models.base import BaseModel, classproperty
+from mage_ai.settings.repo import get_repo_path
 
 
 class Secret(BaseModel):
@@ -15,6 +16,15 @@ class Secret(BaseModel):
     key_uuid = Column(String(255), nullable=True)
     __table_args__ = (UniqueConstraint('name', 'key_uuid', name='name_key_uuid_uc'),)
 
+    @classproperty
+    def repo_query(cls):
+        return cls.query.filter(
+            or_(
+                Secret.repo_name == get_repo_path(),
+                Secret.repo_name.is_(None),
+            )
+        )
+
     @classmethod
     @safe_db_query
     def get_secret(cls, name: str, key_uuid: str) -> Optional['Secret']: