def normalize_postgres_dsn_for_atoti_sql(url: PostgresDsn, /) -> Any: parts = urlparse(url) query_parts: List[str] = [] if parts.query: query_parts.append(parts.query) if parts.username or parts.password: query_parts.append( urlencode({ "user": parts.username, "password": parts.password })) return PostgresDsn( # This is how pydantic creates an instance from parts. None, scheme="postgresql", host=str(parts.hostname), port=str(parts.port) if parts.port else None, path=parts.path, query="&".join(query_parts) if query_parts else None, fragment=parts.fragment, )
def build_db_url(cls, url: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(url, str): return url return PostgresDsn.build(scheme='postgresql', user=values.get('POSTGRES_USER'), password=values.get('POSTGRES_PASSWORD'), host=values.get('POSTGRES_SERVER'), path=values.get('POSTGRES_DB', ''))
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build(scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_SERVER"), path=f"/{values.get('POSTGRES_DB') or ''}")
def generate_sql_alchemy_uri(self): self.SQLALCHEMY_DATABASE_URI = PostgresDsn.build( scheme="postgresql", user=self.POSTGRES_USER, password=self.POSTGRES_PASS, host=self.POSTGRES_HOST, port=self.POSTGRES_PORT, path=f"/{self.POSTGRES_DB or ''}", )
def dsn(self) -> str: dsn: str = PostgresDsn.build( scheme="postgresql", user=self.POSTGRES_USER, password=self.POSTGRES_PASSWORD.get_secret_value(), host=self.POSTGRES_HOST, port=f"{self.POSTGRES_PORT}", path=f"/{self.POSTGRES_DB}", ) return dsn
def db_connection(cls, v, values): if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_HOST"), path=f"/{values.get('POSTGRES_DB') or ''}", )
def autofill_dsn(cls, v, values): if not v and all(key in values for key in cls.__fields__ if key != "dsn"): return PostgresDsn.build( scheme="postgresql", user=values["user"], password=values["password"].get_secret_value(), host=values["host"], port=f"{values['port']}", path=f"/{values['db']}", ) return v
def build_database_uri(cls, value: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(value, str): return value return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_SERVER"), path=f"/{values.get('POSTGRES_DB') or ''}", )
def assemble_db_connection_data(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("SQL_USER"), password=values.get("SQL_PWD"), host=values.get("SQL_SERVER"), path=f"/{values.get('SQL_DB_DATA') or ''}", )
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("DB_USER"), password=values.get("DB_PASSWORD"), host=f'{values.get("DB_HOST")}:{values.get("DB_PORT")}', path=f"/{values.get('DB_DATABASE') or ''}", )
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme=values.get("DB_SCHEMA"), user=values.get("DB_USER"), password=values.get("DB_PASSWORD"), host=values.get("DB_SERVER"), port=values.get("DB_PORT"), path=f"/{values.get('DB_NAME') or ''}", )
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: # noqa if isinstance(v, str): return v # build SQLALCHEMY_DATABASE_URI from environment variables return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_SERVER"), path=f"/{values.get('POSTGRES_DB') or ''}", )
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("DBUSER"), password=values.get("DBPASSWORD"), host=values.get("HOST"), path=f"/{values.get('DBNAME') or ''}", port=values.get("PSQL_PORT"), )
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=quote(values.get("POSTGRES_USER")), password=quote(values.get("POSTGRES_PASSWORD")), host=values.get("POSTGRES_SERVER"), path=f"/{values.get('POSTGRES_DB') or ''}", query= f"options=-csearch_path%3D{values.get('POSTGRES_SCHEMA', '$user')},public", )
def assemble_db_connection(cls, v: Optional[str], values: dict[str, Any]) -> Any: engine = values.get("DB_ENGINE", "sqlite") if engine == "postgres": host = f"{values.get('POSTGRES_SERVER')}:{values.get('POSTGRES_PORT')}" return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=host, path=f"/{values.get('POSTGRES_DB') or ''}", ) return determine_sqlite_path()
def build_pg_dsn(cls, pg_dsn: Optional[str], values: Dict[str, Any]) -> Any: # noqa: N805 """Set POSTGRES_URI.""" if pg_dsn: return pg_dsn return PostgresDsn.build( scheme='postgresql', user=values.get('POSTGRES_USER'), password=values.get('POSTGRES_PASSWORD'), host=values.get('POSTGRES_HOST'), port=values.get('POSTGRES_PORT'), path='/{db}'.format(db=values.get('POSTGRES_DB')), )
def assemble_db_connection( cls, v: Optional[str], values: Dict[str, Any], ) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme='postgresql', user=values.get('POSTGRES_USER'), password=values.get('POSTGRES_PASSWORD'), host=values.get('POSTGRES_SERVER'), path=f'/{values.get("POSTGRES_DB") or ""}', )
def assemble_db_connection( cls, v: Optional[str], values: Dict[str, Any] # noqa ) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("ABING_DB_USER"), password=values.get("ABING_DB_PASSWORD"), host=values.get("ABING_DB_HOST"), port=values.get("ABING_DB_PORT"), path=f"/{values.get('ABING_DB', '')}", )
class Settings(BaseSettings): API_VERSION: str = "/api/v1" # BACKEND_CORS_ORIGINS is a JSON-formatted list of origins # e.g: '["http://localhost", "http://localhost:4200", "http://localhost:3000", \ # "http://localhost:8080", "http://local.dockertoolbox.tiangolo.com"]' BACKEND_CORS_ORIGINS: list[str] = [ "http://localhost:3000", "https://localhost:3000", "http://localhost", ] @classmethod @validator("BACKEND_CORS_ORIGIN", pre=True) def assemble_cors_origins( cls, v: Union[str, list[str]]) -> Union[list[str], str]: if isinstance(v, str) and not v.startswith("["): return [i.strip() for i in v.split(",")] elif isinstance(v, (list, str)): return v raise ValueError(v) PROJECT_NAME: str = "Hermes API" SQLALCHEMY_DATABASE_URI = PostgresDsn.build( scheme="postgresql", user=os.getenv("POSTGRES_USER"), password=os.getenv("POSTGRES_PASSWORD"), host=os.getenv("POSTGRES_SERVER"), path=f'/{os.getenv("POSTGRES_DB")}', ) @classmethod @validator("SQLALCHEMY_DATABASE_URI", pre=True) def assemble_db_connection(cls, v: Optional[str], values: Mapping[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_SERVER"), path=f'/{values.get("POSTGRES_DB") or ""}', ) class Config: case_sensitive = True
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), port=values.get("POSTGRES_PORT"), host=values.get("POSTGRES_HOST"), path=f"/{values.get('POSTGRES_DB'), ''}", ) class Config: case_sensitive = True # If you want to read environment variables from a .env # file instead un-comment the below line and create the # .env file at the root of the project. env_file = ".env"
def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v if (values.get("DATABASE_TYPE") != DatabaseType.PostgreSql and values.get("DATABASE_TYPE") != "PostgreSql"): raise NotImplementedError() assert values.get("POSTGRES_USER") is not None assert values.get("POSTGRES_PASSWORD") is not None assert values.get("POSTGRES_SERVER") is not None assert values.get("POSTGRES_DB") is not None return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_SERVER"), path=f"/{values.get('POSTGRES_DB') or ''}", )
def engine(pytestconfig): """Return a SQLAlchemy engine for a fresh test database.""" orig_db_url = Settings().db_url if orig_db_url.path.endswith("test"): # The database ends with test, assume the caller wanted us to use it test_db_url = orig_db_url drop_db = False assert database_exists(test_db_url) else: # Assume the regular database was passed, create a new test database test_db_url = PostgresDsn.build( scheme=orig_db_url.scheme, user=orig_db_url.user, password=orig_db_url.password, host=orig_db_url.host, port=orig_db_url.port, path=orig_db_url.path + "_test", query=orig_db_url.query, fragment=orig_db_url.fragment, ) drop_db = True # (Re)create the test database test_db_exists = database_exists(test_db_url) if test_db_exists: drop_database(test_db_url) create_database(test_db_url) echo = pytestconfig.getoption("verbose") > 2 test_engine = create_engine(test_db_url, echo=echo) # TODO: Convert to running alembic migrations Base.metadata.create_all(bind=test_engine) yield test_engine test_engine.dispose() if drop_db: drop_database(test_db_url)
def pytest_configure(): print("\nINITIAL Test configuration") print("Upload Setting object for testing pourposes") dotenv_path = ".test.env" test_env = dotenv_values(dotenv_path) TEST_POSTGRES_SERVER = test_env.get("POSTGRES_SERVER") TEST_POSTGRES_USER = test_env.get("POSTGRES_USER") TEST_POSTGRES_PASSWORD = test_env.get("POSTGRES_PASSWORD") TEST_POSTGRES_DB = test_env.get("POSTGRES_DB") TEST_DATABASE_URI = PostgresDsn.build( scheme="postgresql", user=TEST_POSTGRES_USER, password=TEST_POSTGRES_PASSWORD, host=TEST_POSTGRES_SERVER, path=f"/{TEST_POSTGRES_DB or ''}", ) settings.DATABASE_URI = TEST_DATABASE_URI print(settings.DATABASE_URI) if settings.DATABASE_URI != TEST_DATABASE_URI: raise ValueError("Tests are not using testing database") settings.LOG_LEVEL = "DEBUG" settings.LOG_FILE = "test.log"
class Settings(BaseSettings): API_V1_STR: str = "/api/v1" DOMAIN_NAME: HttpUrl SECRET_KEY: str = secrets.token_urlsafe(32) # 60 minutes * 24 hours * 8 days = 8 days ACCESS_TOKEN_EXPIRE_MINUTES: int = 60 * 24 * 8 # BACKEND_CORS_ORIGINS is a JSON-formatted list of origins # e.g: '["http://localhost", "http://*****:*****@validator("BACKEND_CORS_ORIGINS", pre=True) def assemble_cors_origins(cls, v: Union[str, List[str]]) -> Union[List[str], str]: if isinstance(v, str) and not v.startswith("["): return [i.strip() for i in v.split(",")] elif isinstance(v, (list, str)): return v raise ValueError(v) PROJECT_NAME: str POSTGRES_SERVER: str POSTGRES_USER: str POSTGRES_PASSWORD: str POSTGRES_DB: str SQLALCHEMY_DATABASE_URI: Optional[PostgresDsn] = None # TEST DB is hardcoded here for now SQLALCHEMY_DATABASE_TEST_URI: PostgresDsn = PostgresDsn.build( scheme="postgresql", user="******", password="******", host="db", path="/sedotra_test", ) @validator("SQLALCHEMY_DATABASE_URI", pre=True) def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build( scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_SERVER"), path=f"/{values.get('POSTGRES_DB') or ''}", ) SMTP_TLS: bool = True SMTP_PORT: Optional[int] = None SMTP_HOST: Optional[str] = None SMTP_USER: Optional[str] = None SMTP_PASSWORD: Optional[str] = None EMAILS_FROM_EMAIL: Optional[EmailStr] = None EMAILS_FROM_NAME: Optional[str] = None @validator("EMAILS_FROM_NAME") def get_project_name(cls, v: Optional[str], values: Dict[str, Any]) -> str: if not v: return values["PROJECT_NAME"] return v EMAIL_RESET_TOKEN_EXPIRE_HOURS: int = 48 EMAIL_TEMPLATES_DIR: str = "/app/app/email-templates/build" EMAILS_ENABLED: bool = True @validator("EMAILS_ENABLED", pre=True) def get_emails_enabled(cls, v: bool, values: Dict[str, Any]) -> bool: return bool( values.get("SMTP_HOST") and values.get("SMTP_PORT") and values.get("EMAILS_FROM_EMAIL") ) EMAIL_TEST_USER: EmailStr = "*****@*****.**" # type: ignore USERS_OPEN_REGISTRATION: bool = False # OBJECT STORAGE ACCESS OBJECT_ACCESS_KEY: str OBJECT_SECRET_KEY: str OBJECT_BUCKET: str OBJECT_ENDPOINT: AnyHttpUrl class Config: case_sensitive = True
from sqlalchemy import create_engine from sqlalchemy.orm import sessionmaker from pydantic import PostgresDsn from config.setting import settings postgres_url = PostgresDsn.build(scheme=settings.SCHEMA, user=settings.POSTUSER, password=settings.POSTPASSWORD, host=settings.POSTHOST, path=f"/{settings.POSTPATH}", port=settings.POSTPORT) print(postgres_url) engine = create_engine(postgres_url, pool_pre_ping=True, pool_size=50) session_local = sessionmaker(autocommit=False, bind=engine)
from alembic.config import Config from pydantic import PostgresDsn from sqlalchemy import create_engine from sqlalchemy_utils import create_database, database_exists, drop_database from fastapi.testclient import TestClient from app.settings import conf from main import app TEST_DB = PostgresDsn.build( scheme='postgresql', user=conf.postgres.POSTGRES_USER, password=conf.postgres.POSTGRES_PASSWORD, host='localhost', port=conf.postgres.POSTGRES_PORT, path='/{db}.{ending}'.format( db=conf.postgres.POSTGRES_DB, ending='pytest', ), ) @pytest.fixture(scope='session', autouse=True) def temp_db() -> Generator[None, None, None]: """Create new test db for testing session.""" create_engine(TEST_DB) db_exists = database_exists(TEST_DB) if db_exists: drop_database(TEST_DB) create_database(TEST_DB) # Create the test database.
import os from pydantic import PostgresDsn from sqlalchemy import create_engine from sqlalchemy.engine import Engine from sqlalchemy.orm import Session, sessionmaker from typing import Callable engine: Engine = create_engine( PostgresDsn.build( scheme="postgresql", user=os.getenv("POSTGRES_USER", 'postgres'), password=os.getenv("POSTGRES_PASSWORD", 'postgres'), host=os.getenv("POSTGRES_HOST", 'localhost'), path=f"/{os.getenv('POSTGRES_DB', 'test_apiens')}", )) # Type: any callable that returns a new SqlAlchemy Session SessionMakerCallable = Callable[[], Session] # Session maker: create a new Session object SessionMaker: SessionMakerCallable = sessionmaker(autocommit=False, autoflush=False, bind=engine) def recreate_db_tables(engine: Engine, *, Base): """ DROP all tables, then CREATE all tables """ Base.metadata.drop_all(bind=engine) Base.metadata.create_all(bind=engine)
from pydantic import PostgresDsn from sqlalchemy.engine import create_engine from sqlalchemy.orm.session import sessionmaker from app.config import settings SQLALCHEMY_DATABASE_URL = PostgresDsn.build( scheme="postgresql", user=settings.POSTGRES_USER, password=settings.POSTGRES_PASSWORD, host=settings.POSTGRES_SERVER, path=f"/{settings.POSTGRES_DB}_test") engine = create_engine(SQLALCHEMY_DATABASE_URL, pool_pre_ping=True) TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
from sqlalchemy import create_engine from sqlalchemy.ext.declarative import declarative_base from sqlalchemy.orm import sessionmaker, scoped_session from pydantic import PostgresDsn import os SQLALCHEMY_DATABASE_URL = PostgresDsn.build( scheme="postgresql", user=os.getenv("POSTGRES_USER"), password=os.getenv("POSTGRES_PASSWORD"), host=os.getenv("POSTGRES_HOST"), path=f'/{os.getenv("POSTGRES_DB")}') class Database: engine = create_engine(SQLALCHEMY_DATABASE_URL) db_session = scoped_session( sessionmaker(autocommit=False, autoflush=False, bind=engine)) SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) session = SessionLocal() Base = declarative_base()