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()
