datajunction-query 0.0.1a58__py3-none-any.whl → 0.0.28__py3-none-any.whl

djqs/exceptions.py

@@ -4,8 +4,6 @@ Errors and warnings.
 
 from typing import Any, Dict, List, Literal, Optional, TypedDict
 
-from sqlmodel import SQLModel
-
 from djqs.enum import IntEnum
 
 
@@ -53,14 +51,20 @@ class DJErrorType(TypedDict):
     debug: Optional[DebugType]
 
 
-class DJError(SQLModel):
+class DJError:
     """
     An error.
     """
 
-    code: ErrorCode
-    message: str
-    debug: Optional[Dict[str, Any]]
+    def __init__(
+        self,
+        code: ErrorCode,
+        message: str,
+        debug: Optional[Dict[str, Any]] = None,
+    ):
+        self.code = code
+        self.message = message
+        self.debug = debug
 
     def __str__(self) -> str:
         """
@@ -68,6 +72,16 @@ class DJError(SQLModel):
         """
         return f"{self.message} (error code: {self.code})"
 
+    def dict(self) -> Dict[str, Any]:
+        """
+        Convert the error to a dictionary.
+        """
+        return {
+            "code": self.code,
+            "message": self.message,
+            "debug": self.debug,
+        }
+
 
 class DJWarningType(TypedDict):
     """
@@ -79,14 +93,30 @@ class DJWarningType(TypedDict):
     debug: Optional[DebugType]
 
 
-class DJWarning(SQLModel):
+class DJWarning:  # pylint: disable=too-few-public-methods
     """
     A warning.
     """
 
-    code: Optional[ErrorCode] = None
-    message: str
-    debug: Optional[Dict[str, Any]]
+    def __init__(
+        self,
+        message: str,
+        code: Optional[ErrorCode] = None,
+        debug: Optional[Dict[str, Any]] = None,
+    ):
+        self.code = code
+        self.message = message
+        self.debug = debug
+
+    def dict(self) -> Dict[str, Any]:
+        """
+        Convert the warning to a dictionary.
+        """
+        return {
+            "code": self.code,
+            "message": self.message,
+            "debug": self.debug,
+        }
 
 
 DBAPIExceptions = Literal[
@@ -118,16 +148,6 @@ class DJException(Exception):
     Base class for errors.
     """
 
-    message: str
-    errors: List[DJError]
-    warnings: List[DJWarning]
-
-    # exception that should be raised when ``DJException`` is caught by the DB API cursor
-    dbapi_exception: DBAPIExceptions = "Error"
-
-    # status code that should be returned when ``DJException`` is caught by the API layer
-    http_status_code: int = 500
-
     def __init__(  # pylint: disable=too-many-arguments
         self,
         message: Optional[str] = None,
@@ -139,15 +159,12 @@ class DJException(Exception):
         self.errors = errors or []
         self.warnings = warnings or []
         self.message = message or "\n".join(error.message for error in self.errors)
-
-        if dbapi_exception is not None:
-            self.dbapi_exception = dbapi_exception
-        if http_status_code is not None:
-            self.http_status_code = http_status_code
+        self.dbapi_exception = dbapi_exception or "Error"
+        self.http_status_code = http_status_code or 500
 
         super().__init__(self.message)
 
-    def to_dict(self) -> DJExceptionType:
+    def to_dict(self) -> dict:
         """
         Convert to dict.
         """
@@ -186,8 +203,13 @@ class DJInvalidInputException(DJException):
     Exception raised when the input provided by the user is invalid.
     """
 
-    dbapi_exception: DBAPIExceptions = "ProgrammingError"
-    http_status_code: int = 422
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            dbapi_exception="ProgrammingError",
+            http_status_code=422,
+            **kwargs,
+        )
 
 
 class DJNotImplementedException(DJException):
@@ -195,8 +217,13 @@ class DJNotImplementedException(DJException):
     Exception raised when some functionality hasn't been implemented in DJ yet.
     """
 
-    dbapi_exception: DBAPIExceptions = "NotSupportedError"
-    http_status_code: int = 500
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            dbapi_exception="NotSupportedError",
+            http_status_code=500,
+            **kwargs,
+        )
 
 
 class DJInternalErrorException(DJException):
@@ -204,8 +231,13 @@ class DJInternalErrorException(DJException):
     Exception raised when we do something wrong in the code.
     """
 
-    dbapi_exception: DBAPIExceptions = "InternalError"
-    http_status_code: int = 500
+    def __init__(self, *args, **kwargs):
+        super().__init__(
+            *args,
+            dbapi_exception="InternalError",
+            http_status_code=500,
+            **kwargs,
+        )
 
 
 class DJInvalidTableRef(DJException):
@@ -218,3 +250,21 @@ class DJTableNotFound(DJException):
     """
     Raised for tables that cannot be found
     """
+
+
+class DJDatabaseError(DJException):
+    """
+    Ran into an issue while submitting a query to the backend DB
+    """
+
+
+class DJUnknownCatalog(DJException):
+    """
+    Raised when a catalog cannot be found
+    """
+
+
+class DJUnknownEngine(DJException):
+    """
+    Raised when an engine or engine version cannot be found
+    """

djqs/models/query.py

@@ -3,66 +3,60 @@ Models for queries.
 """
 
 import uuid
+from dataclasses import dataclass, field
 from datetime import datetime
 from typing import Any, List, Optional
 from uuid import UUID, uuid4
 
 import msgpack
-from pydantic import AnyHttpUrl
-from sqlalchemy.sql.schema import Column as SqlaColumn
-from sqlalchemy_utils import UUIDType
-from sqlmodel import Field, SQLModel
 
 from djqs.enum import IntEnum
 from djqs.typing import QueryState, Row
 
 
-class BaseQuery(SQLModel):
+@dataclass
+class BaseQuery:
     """
     Base class for query models.
     """
 
-    catalog_name: Optional[str]
+    catalog_name: Optional[str] = None
     engine_name: Optional[str] = None
     engine_version: Optional[str] = None
 
-    class Config:  # pylint: disable=too-few-public-methods, missing-class-docstring
-        allow_population_by_field_name = True
 
-
-class Query(BaseQuery, table=True):  # type: ignore
+@dataclass
+class Query(BaseQuery):  # pylint: disable=too-many-instance-attributes
     """
     A query.
     """
 
-    id: UUID = Field(
-        default_factory=uuid4,
-        sa_column=SqlaColumn(UUIDType(), primary_key=True),
-    )
-    submitted_query: str
-    catalog_name: str
-    engine_name: str
-    engine_version: str
-    async_: bool
+    id: UUID = field(default_factory=uuid4)  # pylint: disable=invalid-name
+    submitted_query: str = ""
+    catalog_name: str = ""
+    engine_name: str = ""
+    engine_version: str = ""
+    async_: bool = False
     executed_query: Optional[str] = None
     scheduled: Optional[datetime] = None
     started: Optional[datetime] = None
     finished: Optional[datetime] = None
-
     state: QueryState = QueryState.UNKNOWN
     progress: float = 0.0
 
 
+@dataclass
 class QueryCreate(BaseQuery):
     """
     Model for submitted queries.
     """
 
-    submitted_query: str
+    submitted_query: str = ""
     async_: bool = False
 
 
-class ColumnMetadata(SQLModel):
+@dataclass
+class ColumnMetadata:
     """
     A simple model for column metadata.
     """
@@ -71,7 +65,8 @@ class ColumnMetadata(SQLModel):
     type: str
 
 
-class StatementResults(SQLModel):
+@dataclass
+class StatementResults:
     """
     Results for a given statement.
 
@@ -79,43 +74,32 @@ class StatementResults(SQLModel):
     """
 
     sql: str
-    columns: List[ColumnMetadata]
-    rows: List[Row]
-
-    # this indicates the total number of rows, and is useful for paginated requests
-    row_count: int = 0
+    columns: List[ColumnMetadata] = field(default_factory=list)
+    rows: List[Row] = field(default_factory=list)
+    row_count: int = 0  # used for pagination
 
 
-class Results(SQLModel):
-    """
-    Results for a given query.
-    """
-
-    __root__: List[StatementResults]
-
-
-class QueryResults(BaseQuery):
+@dataclass
+class QueryResults(BaseQuery):  # pylint: disable=too-many-instance-attributes
     """
     Model for query with results.
     """
 
-    id: uuid.UUID
+    id: uuid.UUID = field(default_factory=uuid4)  # pylint: disable=invalid-name
     engine_name: Optional[str] = None
     engine_version: Optional[str] = None
-    submitted_query: str
+    submitted_query: str = ""
     executed_query: Optional[str] = None
-
     scheduled: Optional[datetime] = None
     started: Optional[datetime] = None
     finished: Optional[datetime] = None
-
     state: QueryState = QueryState.UNKNOWN
+    async_: bool = False
     progress: float = 0.0
-
-    results: Results
-    next: Optional[AnyHttpUrl] = None
-    previous: Optional[AnyHttpUrl] = None
-    errors: List[str]
+    results: List[StatementResults] = field(default_factory=list)
+    next: Optional[str] = None  # Changed to str, as AnyHttpUrl was from pydantic
+    previous: Optional[str] = None  # Changed to str, as AnyHttpUrl was from pydantic
+    errors: List[str] = field(default_factory=list)
 
 
 class QueryExtType(IntEnum):

djqs/models/table.py

@@ -1,6 +1,7 @@
 """
 Models for use in table API requests and responses
 """
+
 from typing import Dict, List
 
 from pydantic import BaseModel

djqs/utils.py

@@ -3,17 +3,12 @@ Utility functions.
 """
 # pylint: disable=line-too-long
 
-import datetime
 import logging
 import os
 from functools import lru_cache
-from typing import Iterator
 
 from dotenv import load_dotenv
-from pydantic.datetime_parse import parse_datetime
 from rich.logging import RichHandler
-from sqlalchemy.engine import Engine
-from sqlmodel import Session, create_engine
 
 from djqs.config import Settings
 
@@ -36,7 +31,7 @@ def setup_logging(loglevel: str) -> None:
     )
 
 
-@lru_cache
+@lru_cache(1)
 def get_settings() -> Settings:
     """
     Return a cached settings object.
@@ -44,47 +39,3 @@ def get_settings() -> Settings:
     dotenv_file = os.environ.get("DOTENV_FILE", ".env")
     load_dotenv(dotenv_file)
     return Settings()
-
-
-def get_metadata_engine() -> Engine:
-    """
-    Create the metadata engine.
-    """
-    settings = get_settings()
-    engine = create_engine(settings.index)
-
-    return engine
-
-
-def get_session() -> Iterator[Session]:
-    """
-    Per-request session.
-    """
-    engine = get_metadata_engine()
-
-    with Session(engine, autoflush=False) as session:  # pragma: no cover
-        yield session
-
-
-class UTCDatetime(datetime.datetime):  # pragma: no cover
-    """
-    A UTC extension of pydantic's normal datetime handling
-    """
-
-    @classmethod
-    def __get_validators__(cls):
-        """
-        Extend the builtin pydantic datetime parser with a custom validate method
-        """
-        yield parse_datetime
-        yield cls.validate
-
-    @classmethod
-    def validate(cls, value) -> str:
-        """
-        Convert to UTC
-        """
-        if value.tzinfo is None:
-            return value.replace(tzinfo=datetime.timezone.utc)
-
-        return value.astimezone(datetime.timezone.utc)

datajunction_query-0.0.1a58.dist-info/RECORD

@@ -1,27 +0,0 @@
-djqs/__about__.py,sha256=8V1Y3GlOIENmZdxogzyStiLOAhaYsAxXEbZpddJSW2s,51
-djqs/__init__.py,sha256=nN5-uJoSVEwuc8n-wMygqeF0Xhxi_zqqbCgutZvAt3E,384
-djqs/config.py,sha256=Flva9W8McnTunUlHGhYd0CsgbsjWbZIoPW25ZTzFxws,3029
-djqs/constants.py,sha256=T-sO5C5-NNdEywGglTIu6bjT1VooFwW4XWNA_ZwSYM8,412
-djqs/engine.py,sha256=5HvrFnQmy89j2duPNT-zSktpfl7zKj-FZdeJ5SvFf8M,5719
-djqs/enum.py,sha256=GJVLYDJ2zWjjUBENgyjZZ_94A24BJtvci-AKTmA0zek,590
-djqs/exceptions.py,sha256=z-EjGLRwHL_v3zl1-RICwQis7wUwl3000tse0YwuoBE,4992
-djqs/fixes.py,sha256=TcXnh0I1z4vEAupPatzrvnqyToGihndnxmLJtIn-_Z8,33
-djqs/typing.py,sha256=TpZHhrK_lzEYg_ZlT5qVCJz8seQBKwrULiTPO-lMxEU,6220
-djqs/utils.py,sha256=R-t2A8RvwLu2Lxcs8r5kxQ7AfuDRKJ7G9XcjfdXAhvQ,2075
-djqs/api/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-djqs/api/catalogs.py,sha256=I_i8-Nok0V3ND1FpOCQ5Nmgaof5MLH8i0oeTjvDxQgw,3062
-djqs/api/engines.py,sha256=278fsgIgQXe4WAmbfbxoA08ALe57us_zKlaK_hbiDrc,1611
-djqs/api/helpers.py,sha256=91UGqs-SAq3fCU9yElBMev9vqtDospOjBq0icfFl1qs,2468
-djqs/api/main.py,sha256=cbZHxkfmushgw8e0G2q8f5Ytexqk-qjKtZPyHK5sbjQ,2075
-djqs/api/queries.py,sha256=gSdzI7pVhCsZDpjP5l0NTvHq4ykF20CFzKiLZrrlUmQ,5523
-djqs/api/tables.py,sha256=1hwYPRAG9kZfS8HE3r_omC4AjHadAbdhFIwx3e4KOvo,1582
-djqs/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-djqs/models/catalog.py,sha256=o3Wlghwr6ax4Eo-3zE5Mdq478xyUxeaf2o3whFprXtU,2038
-djqs/models/engine.py,sha256=k9cBvnYAfzz4yaBDvErDqXIwlqrRsKRbGikBKTQHJPA,889
-djqs/models/query.py,sha256=Qsy69Cfrkn5myOZZfLrR83JB4ynPXogitUo8A7hRsz8,3338
-djqs/models/table.py,sha256=7HmiXWHBWEthqdwPYLlsOgeKD-w9urCHoC4xaQ1RnM8,238
-datajunction_query-0.0.1a58.dist-info/METADATA,sha256=ehByOgLgh-X4iKB7tEfAeTVWddeCTp46KzwnwW9GOQY,9495
-datajunction_query-0.0.1a58.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
-datajunction_query-0.0.1a58.dist-info/licenses/AUTHORS.rst,sha256=G9YmXPfQ0kAuxqlCwvWVvUnZitP9hAc-rPfZ5q7Pv1U,235
-datajunction_query-0.0.1a58.dist-info/licenses/LICENSE.txt,sha256=KuSxhVgPuUGoYWphJig4POcTAIUNLUj8vOx-cqQFMj8,1081
-datajunction_query-0.0.1a58.dist-info/RECORD,,

djqs/api/catalogs.py

@@ -1,115 +0,0 @@
-"""
-Catalog related APIs.
-"""
-
-import logging
-from http import HTTPStatus
-from typing import List
-
-from fastapi import APIRouter, Depends, HTTPException
-from sqlmodel import Session, select
-
-from djqs.api.engines import EngineInfo
-from djqs.api.helpers import get_catalog, get_engine
-from djqs.exceptions import DJException
-from djqs.models.catalog import Catalog, CatalogInfo
-from djqs.models.engine import BaseEngineInfo
-from djqs.utils import get_session
-
-_logger = logging.getLogger(__name__)
-get_router = APIRouter(tags=["Catalogs & Engines"])
-post_router = APIRouter(tags=["Catalogs & Engines - Dynamic Configuration"])
-
-
-@get_router.get("/catalogs/", response_model=List[CatalogInfo])
-def list_catalogs(*, session: Session = Depends(get_session)) -> List[CatalogInfo]:
-    """
-    List all available catalogs
-    """
-    return list(session.exec(select(Catalog)))
-
-
-@get_router.get("/catalogs/{name}/", response_model=CatalogInfo)
-def read_catalog(name: str, *, session: Session = Depends(get_session)) -> CatalogInfo:
-    """
-    Return a catalog by name
-    """
-    return get_catalog(session, name)
-
-
-@post_router.post("/catalogs/", response_model=CatalogInfo, status_code=201)
-def add_catalog(
-    data: CatalogInfo,
-    *,
-    session: Session = Depends(get_session),
-) -> CatalogInfo:
-    """
-    Add a Catalog
-    """
-    try:
-        get_catalog(session, data.name)
-    except DJException:
-        pass
-    else:
-        raise HTTPException(
-            status_code=HTTPStatus.CONFLICT,
-            detail=f"Catalog already exists: `{data.name}`",
-        )
-
-    catalog = Catalog.from_orm(data)
-    catalog.engines.extend(
-        list_new_engines(
-            session=session,
-            catalog=catalog,
-            create_engines=data.engines,
-        ),
-    )
-    session.add(catalog)
-    session.commit()
-    session.refresh(catalog)
-
-    return catalog
-
-
-@post_router.post(
-    "/catalogs/{name}/engines/",
-    response_model=CatalogInfo,
-    status_code=201,
-)
-def add_engines_to_catalog(
-    name: str,
-    data: List[BaseEngineInfo],
-    *,
-    session: Session = Depends(get_session),
-) -> CatalogInfo:
-    """
-    Attach one or more engines to a catalog
-    """
-    catalog = get_catalog(session, name)
-    catalog.engines.extend(
-        list_new_engines(session=session, catalog=catalog, create_engines=data),
-    )
-    session.add(catalog)
-    session.commit()
-    session.refresh(catalog)
-    return catalog
-
-
-def list_new_engines(
-    session: Session,
-    catalog: Catalog,
-    create_engines: List[EngineInfo],
-) -> List[EngineInfo]:
-    """
-    Filter to engines that are not already set on a catalog
-    """
-    new_engines = []
-    for engine_ref in create_engines:
-        already_set = False
-        engine = get_engine(session, engine_ref.name, engine_ref.version)
-        for set_engine in catalog.engines:
-            if engine.name == set_engine.name and engine.version == set_engine.version:
-                already_set = True
-        if not already_set:
-            new_engines.append(engine)
-    return new_engines

djqs/api/engines.py

@@ -1,61 +0,0 @@
-"""
-Engine related APIs.
-"""
-
-from http import HTTPStatus
-from typing import List
-
-from fastapi import APIRouter, Depends, HTTPException
-from sqlmodel import Session, select
-
-from djqs.api.helpers import get_engine
-from djqs.models.engine import BaseEngineInfo, Engine, EngineInfo
-from djqs.utils import get_session
-
-get_router = APIRouter(tags=["Catalogs & Engines"])
-post_router = APIRouter(tags=["Catalogs & Engines - Dynamic Configuration"])
-
-
-@get_router.get("/engines/", response_model=List[EngineInfo])
-def list_engines(*, session: Session = Depends(get_session)) -> List[EngineInfo]:
-    """
-    List all available engines
-    """
-    return list(session.exec(select(Engine)))
-
-
-@get_router.get("/engines/{name}/{version}/", response_model=BaseEngineInfo)
-def list_engine(
-    name: str, version: str, *, session: Session = Depends(get_session)
-) -> BaseEngineInfo:
-    """
-    Return an engine by name and version
-    """
-    return get_engine(session, name, version)
-
-
-@post_router.post("/engines/", response_model=BaseEngineInfo, status_code=201)
-def add_engine(
-    data: EngineInfo,
-    *,
-    session: Session = Depends(get_session),
-) -> BaseEngineInfo:
-    """
-    Add an Engine
-    """
-    try:
-        get_engine(session, data.name, data.version)
-    except HTTPException:
-        pass
-    else:
-        raise HTTPException(
-            status_code=HTTPStatus.CONFLICT,
-            detail=f"Engine already exists: `{data.name}` version `{data.version}`",
-        )
-
-    engine = Engine.from_orm(data)
-    session.add(engine)
-    session.commit()
-    session.refresh(engine)
-
-    return engine

djqs/models/catalog.py

@@ -1,75 +0,0 @@
-"""
-Models for columns.
-"""
-from datetime import datetime, timezone
-from functools import partial
-from typing import TYPE_CHECKING, Dict, List, Optional
-from uuid import UUID, uuid4
-
-from sqlalchemy import DateTime
-from sqlalchemy.sql.schema import Column as SqlaColumn
-from sqlalchemy_utils import UUIDType
-from sqlmodel import JSON, Field, Relationship, SQLModel
-
-from djqs.models.engine import BaseEngineInfo, Engine
-
-if TYPE_CHECKING:
-    from djqs.utils import UTCDatetime
-
-
-class CatalogEngines(SQLModel, table=True):  # type: ignore
-    """
-    Join table for catalogs and engines.
-    """
-
-    catalog_id: Optional[int] = Field(
-        default=None,
-        foreign_key="catalog.id",
-        primary_key=True,
-    )
-    engine_id: Optional[int] = Field(
-        default=None,
-        foreign_key="engine.id",
-        primary_key=True,
-    )
-
-
-class Catalog(SQLModel, table=True):  # type: ignore
-    """
-    A catalog.
-    """
-
-    id: Optional[int] = Field(default=None, primary_key=True)
-    uuid: UUID = Field(default_factory=uuid4, sa_column=SqlaColumn(UUIDType()))
-    name: str
-    engines: List[Engine] = Relationship(
-        link_model=CatalogEngines,
-        sa_relationship_kwargs={
-            "primaryjoin": "Catalog.id==CatalogEngines.catalog_id",
-            "secondaryjoin": "Engine.id==CatalogEngines.engine_id",
-        },
-    )
-    created_at: "UTCDatetime" = Field(
-        sa_column=SqlaColumn(DateTime(timezone=True)),
-        default_factory=partial(datetime.now, timezone.utc),
-    )
-    updated_at: "UTCDatetime" = Field(
-        sa_column=SqlaColumn(DateTime(timezone=True)),
-        default_factory=partial(datetime.now, timezone.utc),
-    )
-    extra_params: Dict = Field(default={}, sa_column=SqlaColumn(JSON))
-
-    def __str__(self) -> str:
-        return self.name  # pragma: no cover
-
-    def __hash__(self) -> int:
-        return hash(self.id)  # pragma: no cover
-
-
-class CatalogInfo(SQLModel):
-    """
-    Class for catalog creation
-    """
-
-    name: str
-    engines: List[BaseEngineInfo] = []