extralit-server 0.1.0a0__py3-none-any.whl

argilla_server/.ipynb_checkpoints/__init__-checkpoint.py

@@ -0,0 +1,23 @@
+#  coding=utf-8
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import warnings
+
+from argilla_server.pydantic_v1 import PYDANTIC_MAJOR_VERSION
+
+if PYDANTIC_MAJOR_VERSION >= 2:
+    # warnings.warn("The argilla_server package is not compatible with Pydantic 2. " "Please use Pydantic 1.x instead.")
+    pass
+else:
+    from argilla_server._app import app  # noqa

argilla_server/.ipynb_checkpoints/settings-checkpoint.py

@@ -0,0 +1,244 @@
+#  coding=utf-8
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+"""
+Common environment vars / settings
+"""
+import logging
+import os
+import re
+import warnings
+from pathlib import Path
+from typing import List, Optional
+from urllib.parse import urlparse
+
+from argilla_server.constants import (
+    DEFAULT_LABEL_SELECTION_OPTIONS_MAX_ITEMS,
+    DEFAULT_MAX_KEYWORD_LENGTH,
+    DEFAULT_SPAN_OPTIONS_MAX_ITEMS,
+    DEFAULT_TELEMETRY_KEY,
+)
+from argilla_server.pydantic_v1 import BaseSettings, Field, root_validator, validator
+
+
+class Settings(BaseSettings):
+    """
+    Main application settings. The pydantic BaseSettings class makes
+    accessible environment variables by setting attributes.
+
+    See <https://pydantic-docs.helpmanual.io/usage/settings/>
+
+    only_bulk_api: (ONLY_BULK_API env var)
+         If True, activate only bulk and search endpoints
+
+    elasticseach: (ELASTICSEARCH env var)
+        The elasticsearch endpoint for datasets persistence
+
+    cors_origins: (CORS_ORIGINS env var)
+        List of host patterns for CORS origin access
+
+    docs_enabled: True
+        If True, enable openapi docs endpoint at /api/docs
+
+    es_records_index_shards:
+        Configures the number of shards for dataset records index creation. Default=1
+
+    es_records_index_replicas:
+        Configures the number of shard replicas for dataset records index creation. Default=0
+
+    disable_es_index_template_creation: (DISABLE_ES_INDEX_TEMPLATE_CREATION env var)
+         Allowing advanced users to create their own es index settings and mappings. Default=False
+
+    """
+
+    __LOGGER__ = logging.getLogger(__name__)
+
+    __DATASETS_INDEX_NAME__ = "ar.datasets"
+    __DATASETS_RECORDS_INDEX_NAME__ = "ar.dataset.{}"
+
+    home_path: Optional[str] = Field(description="The home path where argilla related files will be stored")
+    base_url: Optional[str] = Field(description="The default base url where server will be deployed")
+    database_url: Optional[str] = Field(description="The database url that argilla will use as data store")
+
+    s3_endpoint: Optional[str] = Field(description="The S3 endpoint for data storage")
+    s3_access_key: Optional[str] = Field(description="The access key for the S3 storage")
+    s3_secret_key: Optional[str] = Field(description="The secret key for the S3 storage")
+
+    elasticsearch: str = "http://localhost:9200"
+    elasticsearch_ssl_verify: bool = True
+    elasticsearch_ca_path: Optional[str] = None
+    cors_origins: List[str] = ["*"]
+
+    docs_enabled: bool = True
+
+    namespace: str = Field(default=None, regex=r"^[a-z]+$")
+
+    enable_migration: bool = Field(
+        default=False,
+        description="If enabled, try to migrate data from old rubrix installation",
+    )
+
+    # Analyzer configuration
+    default_es_search_analyzer: str = "standard"
+    exact_es_search_analyzer: str = "whitespace"
+    # This line will be enabled once words field won't be used anymore
+    # wordcloud_es_search_analyzer: str = "multilingual_stop_analyzer"
+
+    es_records_index_shards: int = 1
+    es_records_index_replicas: int = 0
+
+    es_mapping_total_fields_limit: int = 2000
+
+    search_engine: str = "elasticsearch"
+
+    vectors_fields_limit: int = Field(
+        default=5,
+        description="Max number of supported vectors per record",
+    )
+
+    metadata_fields_limit: int = Field(
+        default=50,
+        gt=0,
+        le=100,
+        description="Max number of fields in metadata",
+    )
+    metadata_field_length: int = Field(
+        default=DEFAULT_MAX_KEYWORD_LENGTH,
+        description="Max length supported for the string metadata fields."
+        " Values containing higher than this will be truncated",
+    )
+
+    # Questions settings
+    label_selection_options_max_items: int = Field(
+        default=DEFAULT_LABEL_SELECTION_OPTIONS_MAX_ITEMS,
+        description="Max number of label options for questions of type `label_selection` and `multi_label_selection`",
+    )
+
+    span_options_max_items: int = Field(
+        default=DEFAULT_SPAN_OPTIONS_MAX_ITEMS, description="Max number of label options for questions of type `span`"
+    )
+
+    # See also the telemetry.py module
+    enable_telemetry: bool = True
+    telemetry_key: str = DEFAULT_TELEMETRY_KEY
+
+    @validator("home_path", always=True)
+    def set_home_path_default(cls, home_path: str):
+        return home_path or os.path.join(Path.home(), ".argilla")
+
+    @validator("base_url", always=True)
+    def normalize_base_url(cls, base_url: str):
+        if not base_url:
+            base_url = "/"
+        if not base_url.startswith("/"):
+            base_url = "/" + base_url
+        if not base_url.endswith("/"):
+            base_url += "/"
+
+        return base_url
+
+    @validator("database_url", pre=True, always=True)
+    def set_database_url(cls, database_url: str, values: dict) -> str:
+        if not database_url:
+            database_url = os.getenv("ARGILLA_DATABASE_URL")
+
+        if not database_url:
+            postgres_password = os.getenv("POSTGRES_PASSWORD")
+            postgres_host = os.getenv("POSTGRES_HOST")
+
+            if not postgres_password or not postgres_host:
+                warnings.warn("ARGILLA_DATABASE_URL or POSTGRES_PASSWORD and POSTGRES_HOST environment variables are "
+                              "not set properly, so certain configurations to argilla server may not work as expected.")
+            database_url = f"postgresql+asyncpg://postgres:{postgres_password}@{postgres_host}/postgres"
+
+        if "sqlite" in database_url:
+            regex = re.compile(r"sqlite(?!\+aiosqlite)")
+            if regex.match(database_url):
+                warnings.warn(
+                    "From version 1.14.0, Argilla will use `aiosqlite` as default SQLite driver. The protocol in the"
+                    " provided database URL has been automatically replaced from `sqlite` to `sqlite+aiosqlite`."
+                    " Please, update your database URL to use `sqlite+aiosqlite` protocol."
+                )
+                return re.sub(regex, "sqlite+aiosqlite", database_url)
+
+        if "postgresql" in database_url:
+            regex = re.compile(r"postgresql(?!\+asyncpg)(\+psycopg2)?")
+            if regex.match(database_url):
+                warnings.warn(
+                    "From version 1.14.0, Argilla will use `asyncpg` as default PostgreSQL driver. The protocol in the"
+                    " provided database URL has been automatically replaced from `postgresql` to `postgresql+asyncpg`."
+                    " Please, update your database URL to use `postgresql+asyncpg` protocol."
+                )
+                return re.sub(regex, "postgresql+asyncpg", database_url)
+
+        return database_url
+    
+    @root_validator(pre=True)
+    def set_s3_credentials(cls, values):
+        print('set_s3_credentials', values)
+        values["s3_endpoint"] = os.getenv("S3_ENDPOINT", values.get("s3_endpoint"))
+        values["s3_access_key"] = os.getenv("S3_ACCESS_KEY", values.get("s3_access_key"))
+        values["s3_secret_key"] = os.getenv("S3_SECRET_KEY", values.get("s3_secret_key"))
+
+        return values
+
+    @root_validator(skip_on_failure=True)
+    def create_home_path(cls, values):
+        Path(values["home_path"]).mkdir(parents=True, exist_ok=True)
+
+        return values
+
+    @property
+    def dataset_index_name(self) -> str:
+        ns = self.namespace
+        if ns:
+            return f"{self.namespace}.{self.__DATASETS_INDEX_NAME__}"
+        return self.__DATASETS_INDEX_NAME__
+
+    @property
+    def dataset_records_index_name(self) -> str:
+        ns = self.namespace
+        if ns:
+            return f"{self.namespace}.{self.__DATASETS_RECORDS_INDEX_NAME__}"
+        return self.__DATASETS_RECORDS_INDEX_NAME__
+
+    @property
+    def old_dataset_index_name(self) -> str:
+        index_name = ".rubrix<NAMESPACE>.datasets-v0"
+        ns = self.namespace
+        if ns is None:
+            return index_name.replace("<NAMESPACE>", "")
+        return index_name.replace("<NAMESPACE>", f".{ns}")
+
+    @property
+    def old_dataset_records_index_name(self) -> str:
+        index_name = ".rubrix<NAMESPACE>.dataset.{}.records-v0"
+        ns = self.namespace
+        if ns is None:
+            return index_name.replace("<NAMESPACE>", "")
+        return index_name.replace("<NAMESPACE>", f".{ns}")
+
+    def obfuscated_elasticsearch(self) -> str:
+        """Returns configured elasticsearch url obfuscating the provided password, if any"""
+        parsed = urlparse(self.elasticsearch)
+        if parsed.password:
+            return self.elasticsearch.replace(parsed.password, "XXXX")
+        return self.elasticsearch
+
+    class Config:
+        env_prefix = "ARGILLA_"
+
+
+settings = Settings()

argilla_server/__init__.py

@@ -0,0 +1,22 @@
+#  coding=utf-8
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import warnings
+
+from argilla_server.pydantic_v1 import PYDANTIC_MAJOR_VERSION
+
+if PYDANTIC_MAJOR_VERSION >= 2:
+    warnings.warn("The argilla_server package is not compatible with Pydantic 2. " "Please use Pydantic 1.x instead.")
+else:
+    from argilla_server._app import app  # noqa

argilla_server/__main__.py

@@ -0,0 +1,19 @@
+#  coding=utf-8
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from argilla_server.cli import app
+
+if __name__ == "__main__":
+    app()

argilla_server/_app.py

@@ -0,0 +1,247 @@
+#  coding=utf-8
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+import contextlib
+import glob
+import inspect
+import logging
+import os
+import shutil
+import tempfile
+from pathlib import Path
+
+import backoff
+from brotli_asgi import BrotliMiddleware
+from fastapi import FastAPI
+from starlette.middleware.cors import CORSMiddleware
+from starlette.responses import RedirectResponse
+
+from argilla_server import helpers
+from argilla_server._version import __version__ as argilla_version
+from argilla_server.apis.routes import api_v0, api_v1
+from argilla_server.constants import DEFAULT_API_KEY, DEFAULT_PASSWORD, DEFAULT_USERNAME
+from argilla_server.contexts import accounts
+from argilla_server.daos.backend import GenericElasticEngineBackend
+from argilla_server.daos.backend.base import GenericSearchError
+from argilla_server.daos.datasets import DatasetsDAO
+from argilla_server.daos.records import DatasetRecordsDAO
+from argilla_server.database import get_async_db
+from argilla_server.logging import configure_logging
+from argilla_server.models import User
+from argilla_server.pydantic_v1.errors import ConfigError
+from argilla_server.security import auth
+from argilla_server.settings import settings
+from argilla_server.static_rewrite import RewriteStaticFiles
+
+_LOGGER = logging.getLogger("argilla")
+
+
+def create_server_app() -> FastAPI:
+    """Configure the argilla server"""
+
+    app = FastAPI(
+        title="Argilla",
+        description="Argilla API",
+        docs_url=None,
+        redoc_url=None,
+        version=str(argilla_version),
+    )
+
+    @app.get("/docs", include_in_schema=False)
+    async def redirect_docs():
+        return RedirectResponse(url=f"{settings.base_url}api/docs")
+
+    @app.get("/api", include_in_schema=False)
+    async def redirect_api():
+        return RedirectResponse(url=f"{settings.base_url}api/docs")
+
+    for app_configure in [
+        configure_app_logging,
+        configure_database,
+        configure_storage,
+        configure_telemetry,
+        configure_middleware,
+        configure_app_security,
+        configure_api_router,
+        configure_app_statics,
+    ]:
+        app_configure(app)
+
+    # This if-else clause is needed to simplify the test dependencies setup. Otherwise we cannot override dependencies
+    # easily. We can review this once we have separate fastapi application for the api and the webapp.
+    if settings.base_url and settings.base_url != "/":
+        _app = FastAPI(docs_url=None, redoc_url=None, openapi_url=None)
+        _app.mount(settings.base_url, app)
+        return _app
+    else:
+        return app
+
+
+def configure_middleware(app: FastAPI):
+    """Configures fastapi middleware"""
+
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=settings.cors_origins,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
+    app.add_middleware(BrotliMiddleware, minimum_size=512, quality=7)
+
+
+def configure_api_router(app: FastAPI):
+    """Configures and set the api router to app"""
+    app.mount("/api/v1", api_v1)
+    app.mount("/api", api_v0)
+
+
+def configure_app_statics(app: FastAPI):
+    """Configure static folder for app"""
+
+    parent_path = Path(__file__).parent.absolute()
+    statics_folder = Path(os.path.join(parent_path, "static"))
+    if not (statics_folder.exists() and statics_folder.is_dir()):
+        return
+
+    def _create_statics_folder(path_from):
+        """
+        Application statics will be created with a parameterized baseUrl variable.
+
+        This function will replace the variable by the real runtime value found in settings.base_url
+
+        This allow us to deploy the argilla server under a custom base url, even when webapp does not
+        support it.
+
+        """
+        BASE_URL_VAR_NAME = "@@baseUrl@@"
+        temp_dir = tempfile.mkdtemp()
+        new_folder = shutil.copytree(path_from, temp_dir + "/statics")
+        base_url = helpers.remove_suffix(settings.base_url, suffix="/")
+        for extension in ["*.js", "*.html"]:
+            for file in glob.glob(
+                f"{new_folder}/**/{extension}",
+                recursive=True,
+            ):
+                helpers.replace_string_in_file(
+                    file,
+                    string=BASE_URL_VAR_NAME,
+                    replace_by=base_url,
+                )
+
+        return new_folder
+
+    temp_statics = _create_statics_folder(statics_folder)
+
+    app.mount(
+        "/",
+        RewriteStaticFiles(directory=temp_statics, html=True, check_dir=False),
+        name="static",
+    )
+
+
+def configure_storage(app: FastAPI):
+    def _on_backoff(event):
+        _LOGGER.warning(
+            f"Connection to {settings.obfuscated_elasticsearch()} is not ready. "
+            f"Tried {event['tries']} times. Retrying..."
+        )
+
+    @backoff.on_exception(
+        lambda: backoff.constant(interval=15),
+        ConfigError,
+        max_time=60,
+        on_backoff=_on_backoff,
+    )
+    def _setup_elasticsearch():
+        try:
+            backend = GenericElasticEngineBackend.get_instance()
+            dataset_records: DatasetRecordsDAO = DatasetRecordsDAO(backend)
+            datasets: DatasetsDAO = DatasetsDAO.get_instance(
+                es=backend,
+                records_dao=dataset_records,
+            )
+            datasets.init()
+            dataset_records.init()
+        except GenericSearchError as error:
+            raise ConfigError(
+                f"Your Elasticsearch endpoint at {settings.obfuscated_elasticsearch()} "
+                "is not available or not responding.\n"
+                "Please make sure your Elasticsearch instance is launched and correctly running and\n"
+                "you have the necessary access permissions. "
+                "Once you have verified this, restart the argilla server.\n"
+            ) from error
+
+    @app.on_event("startup")
+    async def setup_elasticsearch():
+        _setup_elasticsearch()
+
+
+def configure_app_security(app: FastAPI):
+    auth.configure_app(app)
+
+
+def configure_app_logging(app: FastAPI):
+    """Configure app logging using"""
+    app.on_event("startup")(configure_logging)
+
+
+def configure_telemetry(app: FastAPI):
+    message = "\n"
+    message += inspect.cleandoc(
+        """
+        Argilla uses telemetry to report anonymous usage and error information.
+
+        You can know more about what information is reported at:
+
+            https://docs.argilla.io/en/latest/reference/telemetry.html
+
+        Telemetry is currently enabled. If you want to disable it, you can configure
+        the environment variable before relaunching the server:
+    """
+    )
+    message += "\n\n    "
+    message += "#set ARGILLA_ENABLE_TELEMETRY=0" if os.name == "nt" else "$>export ARGILLA_ENABLE_TELEMETRY=0"
+    message += "\n"
+
+    @app.on_event("startup")
+    async def check_telemetry():
+        if settings.enable_telemetry:
+            print(message, flush=True)
+
+
+_get_db_wrapper = contextlib.asynccontextmanager(get_async_db)
+
+
+def configure_database(app: FastAPI):
+    def _user_has_default_credentials(user: User):
+        return user.api_key == DEFAULT_API_KEY or accounts.verify_password(DEFAULT_PASSWORD, user.password_hash)
+
+    def _log_default_user_warning():
+        _LOGGER.warning(
+            f"User {DEFAULT_USERNAME!r} with default credentials has been found in the database. "
+            "If you are using argilla in a production environment this can be a serious security problem. "
+            f"We recommend that you create a new admin user and then delete the default {DEFAULT_USERNAME!r} one."
+        )
+
+    @app.on_event("startup")
+    async def log_default_user_warning_if_present():
+        async with _get_db_wrapper() as db:
+            default_user = await accounts.get_user_by_username(db, DEFAULT_USERNAME)
+            if default_user and _user_has_default_credentials(default_user):
+                _log_default_user_warning()
+
+
+app = create_server_app()

argilla_server/_messages.py

@@ -0,0 +1,18 @@
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+ARGILLA_METADATA_FIELD_WARNING_MESSAGE = (
+    "You can configure this length in the server with the ARGILLA_METADATA_FIELD_LENGTH "
+    "environment variable. Note that, setting this too high may lead to Elastic performance issues."
+)

argilla_server/_version.py

@@ -0,0 +1,16 @@
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+# coding: utf-8
+__version__ = "0.1.0a0"

argilla_server/alembic/env.py

@@ -0,0 +1,94 @@
+#  Copyright 2021-present, the Recognai S.L. team.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from logging.config import fileConfig
+
+from alembic import context
+from argilla_server.database import database_url_sync
+from argilla_server.models.base import DatabaseModel
+from argilla_server.models.database import *  # noqa: I001
+from sqlalchemy import engine_from_config, pool
+
+# this is the Alembic Config object, which provides
+# access to the values within the .ini file in use.
+config = context.config
+
+# Overwrites the SQLAlchemy URL getting it from argilla database_url settings
+config.set_main_option("sqlalchemy.url", database_url_sync())
+
+# Interpret the config file for Python logging.
+# This line sets up loggers basically.
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+# add your model's MetaData object here
+# for 'autogenerate' support
+# from myapp import mymodel
+# target_metadata = mymodel.Base.metadata
+target_metadata = DatabaseModel.metadata
+
+# other values from the config, defined by the needs of env.py,
+# can be acquired:
+# my_important_option = config.get_main_option("my_important_option")
+# ... etc.
+
+
+def run_migrations_offline() -> None:
+    """Run migrations in 'offline' mode.
+
+    This configures the context with just a URL
+    and not an Engine, though an Engine is acceptable
+    here as well.  By skipping the Engine creation
+    we don't even need a DBAPI to be available.
+
+    Calls to context.execute() here emit the given string to the
+    script output.
+
+    """
+    url = config.get_main_option("sqlalchemy.url")
+    context.configure(
+        url=url,
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={"paramstyle": "named"},
+    )
+
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def run_migrations_online() -> None:
+    """Run migrations in 'online' mode.
+
+    In this scenario we need to create an Engine
+    and associate a connection with the context.
+
+    """
+    connectable = engine_from_config(
+        config.get_section(config.config_ini_section),
+        prefix="sqlalchemy.",
+        poolclass=pool.NullPool,
+    )
+
+    with connectable.connect() as connection:
+        context.configure(connection=connection, target_metadata=target_metadata)
+
+        with context.begin_transaction():
+            context.run_migrations()
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()