squirrels 0.5.0b3__py3-none-any.whl → 0.5.0b4__py3-none-any.whl

squirrels/_project.py

@@ -5,14 +5,16 @@ import asyncio, typing as t, functools as ft, shutil, json, os
 import logging as l, matplotlib.pyplot as plt, networkx as nx, polars as pl
 import sqlglot, sqlglot.expressions
 
-from ._auth import Authenticator, BaseUser
+from ._auth import Authenticator, BaseUser, AuthProviderArgs, ProviderFunctionType
+from ._schemas import response_models as rm
 from ._model_builder import ModelBuilder
 from ._exceptions import InvalidInputError, ConfigurationError
-from . import _utils as u, _constants as c, _manifest as mf, _connection_set as cs, _api_response_models as arm
+from ._py_module import PyModule
+from . import _dashboards as d, _utils as u, _constants as c, _manifest as mf, _connection_set as cs
 from . import _seeds as s, _models as m, _model_configs as mc, _model_queries as mq, _sources as so
-from . import _parameter_sets as ps, _dashboards_io as d, _dashboard_types as dash, _dataset_types as dr
+from . import _parameter_sets as ps, _dataset_types as dr
 
-T = t.TypeVar("T", bound=dash.Dashboard)
+T = t.TypeVar("T", bound=d.Dashboard)
 M = t.TypeVar("M", bound=m.DataModel)
 
 
@@ -129,16 +131,33 @@ class SquirrelsProject:
         return cs.ConnectionSetIO.load_from_file(self._logger, self._filepath, self._manifest_cfg, self._conn_args)
     
     @ft.cached_property
-    def _auth(self) -> Authenticator:
-        return Authenticator(self._logger, self._filepath, self._env_vars)
+    def _user_cls_and_provider_functions(self) -> tuple[type[BaseUser], list[ProviderFunctionType]]:
+        user_module_path = u.Path(self._filepath, c.PYCONFIGS_FOLDER, c.USER_FILE)
+        user_module = PyModule(user_module_path)
+        
+        User = user_module.get_func_or_class("User", default_attr=BaseUser)  # adds to Authenticator.providers as side effect
+        provider_functions = Authenticator.providers
+        Authenticator.providers = []
+        
+        if not issubclass(User, BaseUser):
+            raise ConfigurationError(f"User class in '{c.USER_FILE}' must inherit from BaseUser")
+        
+        return User, provider_functions
+    
+    @ft.cached_property
+    def _auth_args(self) -> AuthProviderArgs:
+        conn_args = self._conn_args
+        return AuthProviderArgs(conn_args.project_path, conn_args.proj_vars, conn_args.env_vars)
     
     @ft.cached_property
-    def User(self) -> t.Type[BaseUser]:
-        return self._auth.User
+    def _auth(self) -> Authenticator[BaseUser]:
+        User, provider_functions = self._user_cls_and_provider_functions
+        return Authenticator(self._logger, self._filepath, self._auth_args, provider_functions, user_cls=User)
     
     @ft.cached_property
     def _param_args(self) -> ps.ParametersArgs:
-        return ps.ParameterConfigsSetIO.get_param_args(self._conn_args)
+        conn_args = self._conn_args
+        return ps.ParametersArgs(conn_args.project_path, conn_args.proj_vars, conn_args.env_vars)
     
     @ft.cached_property
     def _param_cfg_set(self) -> ps.ParameterConfigsSet:
@@ -261,7 +280,7 @@ class SquirrelsProject:
             for model_name in dependencies:
                 model = models_dict[model_name]
                 if isinstance(model, m.SourceModel) and not model.model_config.load_to_duckdb:
-                    raise InvalidInputError(203, f"Source model '{model_name}' cannot be queried with DuckDB")
+                    raise InvalidInputError(400, "Unqueryable source model", f"Source model '{model_name}' cannot be queried with DuckDB")
                 if isinstance(model, (m.SourceModel, m.BuildModel)):
                     substitutions[model_name] = f"venv.{model_name}"
             
@@ -310,18 +329,18 @@ class SquirrelsProject:
         await dag.execute(self._param_args, self._param_cfg_set, self._context_func, user, selections, runquery=False, default_traits=default_traits)
         return dag
     
-    def _get_all_connections(self) -> list[arm.ConnectionItemModel]:
+    def _get_all_connections(self) -> list[rm.ConnectionItemModel]:
         connections = []
         for conn_name, conn_props in self._conn_set.get_connections_as_dict().items():
             if isinstance(conn_props, mf.ConnectionProperties):
                 label = conn_props.label if conn_props.label is not None else conn_name
-                connections.append(arm.ConnectionItemModel(name=conn_name, label=label))
+                connections.append(rm.ConnectionItemModel(name=conn_name, label=label))
         return connections
     
-    def _get_all_data_models(self, compiled_dag: m.DAG) -> list[arm.DataModelItem]:
+    def _get_all_data_models(self, compiled_dag: m.DAG) -> list[rm.DataModelItem]:
         return compiled_dag.get_all_data_models()
     
-    async def get_all_data_models(self) -> list[arm.DataModelItem]:
+    async def get_all_data_models(self) -> list[rm.DataModelItem]:
         """
         Get all data models in the project
 
@@ -331,26 +350,26 @@ class SquirrelsProject:
         compiled_dag = await self._get_compiled_dag()
         return self._get_all_data_models(compiled_dag)
 
-    def _get_all_data_lineage(self, compiled_dag: m.DAG) -> list[arm.LineageRelation]:
+    def _get_all_data_lineage(self, compiled_dag: m.DAG) -> list[rm.LineageRelation]:
         all_lineage = compiled_dag.get_all_model_lineage()
 
         # Add dataset nodes to the lineage
         for dataset in self._manifest_cfg.datasets.values():
-            target_dataset = arm.LineageNode(name=dataset.name, type="dataset")
-            source_model = arm.LineageNode(name=dataset.model, type="model")
-            all_lineage.append(arm.LineageRelation(type="runtime", source=source_model, target=target_dataset))
+            target_dataset = rm.LineageNode(name=dataset.name, type="dataset")
+            source_model = rm.LineageNode(name=dataset.model, type="model")
+            all_lineage.append(rm.LineageRelation(type="runtime", source=source_model, target=target_dataset))
 
         # Add dashboard nodes to the lineage
         for dashboard in self._dashboards.values():
-            target_dashboard = arm.LineageNode(name=dashboard.dashboard_name, type="dashboard")
+            target_dashboard = rm.LineageNode(name=dashboard.dashboard_name, type="dashboard")
             datasets = set(x.dataset for x in dashboard.config.depends_on)
             for dataset in datasets:
-                source_dataset = arm.LineageNode(name=dataset, type="dataset")
-                all_lineage.append(arm.LineageRelation(type="runtime", source=source_dataset, target=target_dashboard))
+                source_dataset = rm.LineageNode(name=dataset, type="dataset")
+                all_lineage.append(rm.LineageRelation(type="runtime", source=source_dataset, target=target_dashboard))
 
         return all_lineage
 
-    async def get_all_data_lineage(self) -> list[arm.LineageRelation]:
+    async def get_all_data_lineage(self) -> list[rm.LineageRelation]:
         """
         Get all data lineage in the project
 
@@ -480,7 +499,7 @@ class SquirrelsProject:
 
     def _permission_error(self, user: BaseUser | None, data_type: str, data_name: str, scope: str) -> InvalidInputError:
         username = "" if user is None else f" '{user.username}'"
-        return InvalidInputError(25, f"User{username} does not have permission to access {scope} {data_type}: {data_name}")
+        return InvalidInputError(403, f"Unauthorized access to {data_type}", f"User{username} does not have permission to access {scope} {data_type}: {data_name}")
     
     def seed(self, name: str) -> pl.LazyFrame:
         """
@@ -545,7 +564,7 @@ class SquirrelsProject:
         )
     
     async def dashboard(
-        self, name: str, *, selections: dict[str, t.Any] = {}, user: BaseUser | None = None, dashboard_type: t.Type[T] = dash.PngDashboard
+        self, name: str, *, selections: dict[str, t.Any] = {}, user: BaseUser | None = None, dashboard_type: t.Type[T] = d.PngDashboard
     ) -> T:
         """
         Async method to retrieve a dashboard given parameter selections.

squirrels/_py_module.py

@@ -43,11 +43,12 @@ class PyModule:
         return func_or_class
 
 
-def run_pyconfig_main(base_path: str, filename: str, kwargs: dict[str, Any] = {}) -> None:
+def run_pyconfig_main(base_path: str, filename: str, kwargs: dict[str, Any] = {}) -> Any | None:
     """
     Given a python file in the 'pyconfigs' folder, run its main function
     
     Arguments:
+        base_path: The base path of the project
         filename: The name of the file to run main function
         kwargs: Dictionary of the main function arguments
     """
@@ -56,6 +57,6 @@ def run_pyconfig_main(base_path: str, filename: str, kwargs: dict[str, Any] = {}
     main_function = module.get_func_or_class(c.MAIN_FUNC, is_required=False)
     if main_function:
         try:
-            main_function(**kwargs)
+            return main_function(**kwargs)
         except Exception as e:
             raise FileExecutionError(f'Failed to run python file "{filepath}"', e) from e

squirrels/_schemas/auth_models.py

@@ -0,0 +1,144 @@
+from typing import Callable, Any
+from datetime import datetime
+from pydantic import BaseModel, ConfigDict, Field, field_serializer
+
+
+class BaseUser(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    username: str
+    is_admin: bool = False
+    
+    @classmethod
+    def dropped_columns(cls):
+        return []
+    
+    def __hash__(self):
+        return hash(self.username)
+
+
+class ApiKey(BaseModel):
+    model_config = ConfigDict(from_attributes=True)
+    id: str
+    title: str
+    username: str
+    created_at: datetime
+    expires_at: datetime
+    
+    @field_serializer('created_at', 'expires_at')
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+class UserField(BaseModel):
+    name: str
+    type: str
+    nullable: bool
+    enum: list[str] | None
+    default: Any | None
+
+
+class ProviderConfigs(BaseModel):
+    client_id: str
+    client_secret: str
+    server_metadata_url: str
+    client_kwargs: dict = Field(default_factory=dict)
+    get_user: Callable[[dict], BaseUser]
+
+
+class AuthProvider(BaseModel):
+    name: str
+    label: str
+    icon: str
+    provider_configs: ProviderConfigs
+
+
+# OAuth 2.1 Models
+
+class OAuthClientModel(BaseModel):
+    """OAuth client details"""
+    model_config = ConfigDict(from_attributes=True)
+    client_id: str
+    client_name: str
+    redirect_uris: list[str]
+    scope: str
+    grant_types: list[str]
+    response_types: list[str]
+    created_at: datetime
+    is_active: bool
+    
+    @field_serializer('created_at')
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+class ClientRegistrationRequest(BaseModel):
+    """Request model for OAuth client registration"""
+    client_name: str = Field(description="Human-readable name for the OAuth client")
+    redirect_uris: list[str] = Field(description="List of allowed redirect URIs for the client")
+    scope: str = Field(default="read", description="Default scope for the client")
+    grant_types: list[str] = Field(default=["authorization_code", "refresh_token"], description="Allowed grant types")
+    response_types: list[str] = Field(default=["code"], description="Allowed response types")
+
+
+class ClientUpdateRequest(BaseModel):
+    """Request model for OAuth client update"""
+    client_name: str | None = Field(default=None, description="Human-readable name for the OAuth client")
+    redirect_uris: list[str] | None = Field(default=None, description="List of allowed redirect URIs for the client")
+    scope: str | None = Field(default=None, description="Default scope for the client")
+    grant_types: list[str] | None = Field(default=None, description="Allowed grant types")
+    response_types: list[str] | None = Field(default=None, description="Allowed response types")
+    is_active: bool | None = Field(default=None, description="Whether the client is active")
+
+
+class ClientDetailsResponse(BaseModel):
+    """Response model for OAuth client details (without client_secret)"""
+    client_id: str = Field(description="Client ID")
+    client_name: str = Field(description="Client name")
+    redirect_uris: list[str] = Field(description="Registered redirect URIs")
+    scope: str = Field(description="Default scope")
+    grant_types: list[str] = Field(description="Allowed grant types")
+    response_types: list[str] = Field(description="Allowed response types")
+    created_at: datetime = Field(description="Registration timestamp")
+    is_active: bool = Field(description="Whether the client is active")
+    
+    @field_serializer('created_at')
+    def serialize_datetime(self, dt: datetime) -> str:
+        return dt.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
+
+
+class ClientUpdateResponse(ClientDetailsResponse):
+    """Response model for OAuth client update"""
+    registration_access_token: str | None = Field(default=None, description="Token for managing this client registration (store securely)")
+
+
+class ClientRegistrationResponse(ClientUpdateResponse):
+    """Response model for OAuth client registration"""
+    client_secret: str = Field(description="Generated client secret (store securely)")
+    registration_client_uri: str | None = Field(default=None, description="URI for managing this client registration")
+
+
+class TokenResponse(BaseModel):
+    access_token: str
+    token_type: str = "bearer"
+    expires_in: int
+    refresh_token: str | None = None
+
+
+class OAuthServerMetadata(BaseModel):
+    """OAuth 2.1 Authorization Server Metadata (RFC 8414)"""
+    issuer: str = Field(description="Authorization server's issuer identifier URL")
+    authorization_endpoint: str = Field(description="URL of the authorization endpoint")
+    token_endpoint: str = Field(description="URL of the token endpoint")
+    revocation_endpoint: str = Field(description="URL of the token revocation endpoint")
+    registration_endpoint: str = Field(description="URL of the client registration endpoint")
+    scopes_supported: list[str] = Field(description="List of OAuth 2.1 scope values supported")
+    response_types_supported: list[str] = Field(description="List of OAuth 2.1 response_type values supported")
+    grant_types_supported: list[str] = Field(description="List of OAuth 2.1 grant type values supported")
+    token_endpoint_auth_methods_supported: list[str] = Field(
+        default=["client_secret_basic", "client_secret_post"], 
+        description="List of client authentication methods supported by the token endpoint"
+    )
+    code_challenge_methods_supported: list[str] = Field(
+        default=["S256"], 
+        description="List of PKCE code challenge methods supported"
+    )

squirrels/_schemas/query_param_models.py

@@ -0,0 +1,67 @@
+"""
+Query model generation utilities for API routes
+"""
+from typing import Annotated
+from dataclasses import make_dataclass
+from fastapi import Depends
+from pydantic import create_model
+
+from .._parameter_configs import APIParamFieldInfo
+
+
+def _get_query_models_helper(widget_parameters: list[str] | None, predefined_params: list[APIParamFieldInfo], param_fields: dict):
+    """Helper function to generate query models"""
+    if widget_parameters is None:
+        widget_parameters = list(param_fields.keys())
+    
+    QueryModelForGetRaw = make_dataclass("QueryParams", [
+        param_fields[param].as_query_info() for param in widget_parameters
+    ] + [param.as_query_info() for param in predefined_params])
+    QueryModelForGet = Annotated[QueryModelForGetRaw, Depends()]
+
+    field_definitions = {param: param_fields[param].as_body_info() for param in widget_parameters}
+    for param in predefined_params:
+        field_definitions[param.name] = param.as_body_info()
+    QueryModelForPost = create_model("RequestBodyParams", **field_definitions) # type: ignore
+    return QueryModelForGet, QueryModelForPost
+
+
+def get_query_models_for_parameters(widget_parameters: list[str] | None, param_fields: dict):
+    """Generate query models for parameter endpoints"""
+    predefined_params = [
+        APIParamFieldInfo("x_verify_params", bool, default=False, description="If true, the query parameters are verified to be valid for the dataset"),
+        APIParamFieldInfo("x_parent_param", str, description="The parameter name used for parameter updates. If not provided, then all parameters are retrieved"),
+    ]
+    return _get_query_models_helper(widget_parameters, predefined_params, param_fields)
+
+
+def get_query_models_for_dataset(widget_parameters: list[str] | None, param_fields: dict):
+    """Generate query models for dataset endpoints"""
+    predefined_params = [
+        APIParamFieldInfo("x_verify_params", bool, default=False, description="If true, the query parameters are verified to be valid for the dataset"),
+        APIParamFieldInfo("x_orientation", str, default="records", description="The orientation of the data to return, one of: 'records', 'rows', or 'columns'"),
+        APIParamFieldInfo("x_select", list[str], examples=[[]], description="The columns to select from the dataset. All are returned if not specified"), 
+        APIParamFieldInfo("x_offset", int, default=0, description="The number of rows to skip before returning data (applied after data caching)"),
+        APIParamFieldInfo("x_limit", int, default=1000, description="The maximum number of rows to return (applied after data caching and offset)"),
+    ]
+    return _get_query_models_helper(widget_parameters, predefined_params, param_fields)
+
+
+def get_query_models_for_dashboard(widget_parameters: list[str] | None, param_fields: dict):
+    """Generate query models for dashboard endpoints"""
+    predefined_params = [
+        APIParamFieldInfo("x_verify_params", bool, default=False, description="If true, the query parameters are verified to be valid for the dashboard"),
+    ]
+    return _get_query_models_helper(widget_parameters, predefined_params, param_fields)
+
+
+def get_query_models_for_querying_models(param_fields: dict):
+    """Generate query models for querying data models"""
+    predefined_params = [
+        APIParamFieldInfo("x_verify_params", bool, default=False, description="If true, the query parameters are verified to be valid"),
+        APIParamFieldInfo("x_orientation", str, default="records", description="The orientation of the data to return, one of: 'records', 'rows', or 'columns'"),
+        APIParamFieldInfo("x_offset", int, default=0, description="The number of rows to skip before returning data (applied after data caching)"),
+        APIParamFieldInfo("x_limit", int, default=1000, description="The maximum number of rows to return (applied after data caching and offset)"),
+        APIParamFieldInfo("x_sql_query", str, description="The SQL query to execute on the data models"),
+    ]
+    return _get_query_models_helper(None, predefined_params, param_fields) 

squirrels/{_api_response_models.py → _schemas/response_models.py}

@@ -1,16 +1,20 @@
 from typing import Annotated, Literal
 from pydantic import BaseModel, Field
-from datetime import datetime, date
+from datetime import date
 
-from . import _model_configs as mc, _sources as s
+from .. import _model_configs as mc, _sources as s
 
 
-class LoginReponse(BaseModel):
-    access_token: Annotated[str, Field(examples=["encoded_jwt_token"], description="An encoded JSON web token to use subsequent API requests")]
-    token_type: Annotated[str, Field(examples=["bearer"], description='Always "bearer" for Bearer token')]
-    username: Annotated[str, Field(examples=["johndoe"], description='The username authenticated with from the form data')]
-    is_admin: Annotated[bool, Field(examples=[False], description="A boolean for whether the user is an admin")]
-    expiry_time: Annotated[datetime, Field(examples=["2023-08-01T12:00:00.000000Z"], description="The expiry time of the access token in yyyy-MM-dd'T'hh:mm:ss.SSSSSS'Z' format")]
+## Simple Auth Response Models
+
+class ApiKeyResponse(BaseModel):
+    api_key: Annotated[str, Field(examples=["sqrl-12345678"], description="The API key to use subsequent API requests")]
+
+class ProviderResponse(BaseModel):
+    name: Annotated[str, Field(examples=["my_provider"], description="The name of the provider")]
+    label: Annotated[str, Field(examples=["My Provider"], description="The human-friendly display name for the provider")]
+    icon: Annotated[str, Field(examples=["https://example.com/my_provider_icon.png"], description="The URL of the provider's icon")]
+    login_url: Annotated[str, Field(examples=["https://example.com/my_provider_login"], description="The URL to redirect to for provider login")]
 
 
 ## Parameters Response Models

squirrels/_utils.py

@@ -2,10 +2,9 @@ from typing import Sequence, Optional, Union, TypeVar, Callable, Any, Iterable
 from datetime import datetime
 from pathlib import Path
 from functools import lru_cache
-from pydantic import BaseModel
 import os, time, logging, json, duckdb, polars as pl, yaml
 import jinja2 as j2, jinja2.nodes as j2_nodes
-import sqlglot, sqlglot.expressions, asyncio
+import sqlglot, sqlglot.expressions, asyncio, hashlib, inspect, base64
 
 from . import _constants as c
 from ._exceptions import ConfigurationError
@@ -359,3 +358,36 @@ async def asyncio_gather(coroutines: list):
         # Wait for tasks to be cancelled
         await asyncio.gather(*tasks, return_exceptions=True)
         raise
+
+
+def hash_string(input_str: str, salt: str) -> str:
+    """
+    Hashes a string using SHA-256
+    """
+    return hashlib.sha256((input_str + salt).encode()).hexdigest()
+
+
+T = TypeVar('T')
+def call_func(func: Callable[..., T], **kwargs) -> T:
+    """
+    Calls a function with the given arguments if func expects arguments, otherwise calls func without arguments
+    """
+    sig = inspect.signature(func)
+    # Filter kwargs to only include parameters that the function accepts
+    filtered_kwargs = {k: v for k, v in kwargs.items() if k in sig.parameters}
+    return func(**filtered_kwargs)
+
+
+def generate_pkce_challenge(code_verifier: str) -> str:
+    """Generate PKCE code challenge from code verifier"""
+    # Generate SHA256 hash of code_verifier
+    verifier_hash = hashlib.sha256(code_verifier.encode('utf-8')).digest()
+    # Base64 URL encode (without padding)
+    expected_challenge = base64.urlsafe_b64encode(verifier_hash).decode('utf-8').rstrip('=')
+    return expected_challenge
+
+def validate_pkce_challenge(code_verifier: str, code_challenge: str) -> bool:
+    """Validate PKCE code verifier against code challenge"""
+    # Generate expected challenge
+    expected_challenge = generate_pkce_challenge(code_verifier)
+    return expected_challenge == code_challenge

squirrels/arguments.py

@@ -1,2 +1,2 @@
-from ._arguments._init_time_args import ConnectionsArgs, ParametersArgs, BuildModelArgs
-from ._arguments._run_time_args import ContextArgs, ModelArgs, DashboardArgs
+from ._arguments.init_time_args import ConnectionsArgs, AuthProviderArgs, ParametersArgs, BuildModelArgs
+from ._arguments.run_time_args import ContextArgs, ModelArgs, DashboardArgs

squirrels/auth.py

@@ -0,0 +1 @@
+from ._auth import BaseUser, ProviderConfigs, provider

squirrels/dashboards.py

@@ -1 +1 @@
-from ._dashboard_types import PngDashboard, HtmlDashboard
+from ._dashboards import PngDashboard, HtmlDashboard

squirrels/types.py

@@ -4,8 +4,8 @@ from ._parameter_options import ParameterOption
 
 from ._parameters import Parameter, TextValue
 
-from ._auth import BaseUser
-
 from ._dataset_types import DatasetMetadata, DatasetResult
 
-from ._dashboard_types import Dashboard
+from ._dashboards import Dashboard
+
+from ._parameter_configs import ParameterConfigBase

{squirrels-0.5.0b3.dist-info → squirrels-0.5.0b4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squirrels
-Version: 0.5.0b3
+Version: 0.5.0b4
 Summary: Squirrels - API Framework for Data Analytics
 Project-URL: Homepage, https://squirrels-analytics.github.io
 Project-URL: Repository, https://github.com/squirrels-analytics/squirrels
@@ -13,15 +13,18 @@ Classifier: Topic :: Software Development :: Libraries :: Application Frameworks
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Typing :: Typed
 Requires-Python: ~=3.10
+Requires-Dist: authlib<2,>=1.5.2
 Requires-Dist: bcrypt<5,>=4.0.1
 Requires-Dist: cachetools<6,>=5.3.2
 Requires-Dist: duckdb<2,>=1.1.3
 Requires-Dist: fastapi<1,>=0.112.1
 Requires-Dist: gitpython<4,>=3.1.41
 Requires-Dist: inquirer<4,>=3.2.1
+Requires-Dist: itsdangerous<3,>=2.2.0
 Requires-Dist: jinja2<4,>=3.1.3
 Requires-Dist: libpass<2,>=1.9.0
 Requires-Dist: matplotlib<4,>=3.8.3
+Requires-Dist: mcp>=1.9.2
 Requires-Dist: networkx<4,>=3.2.1
 Requires-Dist: pandas<3,>=2.1.4
 Requires-Dist: polars<2,>=1.14.0

{squirrels-0.5.0b3.dist-info → squirrels-0.5.0b4.dist-info}/RECORD

@@ -2,46 +2,54 @@ dateutils/__init__.py,sha256=dq4VSlJ5ztaDPdvYBRAvXSyanT_CZif3I4O0YVmWfa8,277
 dateutils/_enums.py,sha256=WBrnLqta_iMMhGMEn24cCO1Vlr7bST0E8oEfAL3z0P8,373
 dateutils/_implementation.py,sha256=PVJAdNolDdTpCZXwvokKoMIZzTSNpCUvZlVLWpMeSho,15173
 dateutils/types.py,sha256=xcRwBoftQi-uHM1tlVTW5xgN84qdrqCo5tQT7A34S8Y,124
-squirrels/__init__.py,sha256=7n-Wci_BSeE7SEY703WYqsBhJ2Ix49AKIcRq3rXb4QI,267
-squirrels/_api_response_models.py,sha256=fQWjEBGAyy8KbkaY4jjOKvxhEcvQPU1bF2dJRTVTRc4,13601
-squirrels/_api_server.py,sha256=iODEImWZo7NPekubYYRFXtVxMHobry0JACLDMFPTJAk,51208
-squirrels/_auth.py,sha256=u3ISed2yavktOseN9rf5uXcPupfS4pK6rlC60RvyrgI,19305
+squirrels/__init__.py,sha256=O9QBS0WHdmWM7SUCTnEk1VU8ElnJKKrFHGAEd8W5CkM,288
+squirrels/_api_server.py,sha256=y-GW7e7vKgeZsL50Md9dwsc7WR5Oe3Mu-yAZOK96_wE,14071
+squirrels/_auth.py,sha256=3VWbB4-mMEqUp3YL1-T6R-kOswZ4xx29H0SSSlp2ezM,45592
 squirrels/_command_line.py,sha256=ZB7cTJabWiYEV6tFi1l87M-w468LJ-DV7TNgQ_bqFbY,11151
-squirrels/_connection_set.py,sha256=170NqnDgAisseTY4Iqzw79CZeT3oMIdUNuz3HLHZSGM,4009
-squirrels/_constants.py,sha256=ddKMtnBAzUNuXHT4zT63oo1OpWy9LPXakDeLduikM6Q,3127
-squirrels/_dashboard_types.py,sha256=g27ET5CnM_4IvxdhtGBjaRUM4MeK1kDsIfcp78AIYFE,1950
-squirrels/_dashboards_io.py,sha256=bWgXdqTNV57x3zlptmFnG_RX5s1zO-TV2CvrQpcCTs8,3001
+squirrels/_connection_set.py,sha256=-krmn3RJkPOmh6oP3t8PhGhInyQ2pLu5HulYDi-aUrI,4008
+squirrels/_constants.py,sha256=6sBvx5ijWgLz4KJGZo-VZ8NPZvw1aVROsYxA6ac2pZ8,3337
+squirrels/_dashboards.py,sha256=FF6KG-GXohR5Hp-BMYRwEZ2hUQ_jbkFpcK5epwoD64w,4891
 squirrels/_data_sources.py,sha256=W1aUAHkkjPpBRjZGBrc9RJIxEwICfnzB8HAyknCoZ3E,25988
 squirrels/_dataset_types.py,sha256=wZvvRs4U1Hva_iyoFosAAu76S1yfv1Cd5SX3UMIw2PA,2838
-squirrels/_exceptions.py,sha256=ny_-lS-V-G4ss7XT98cg83kl2KWZfP-K1plkgK2ElSg,2505
+squirrels/_exceptions.py,sha256=-hfDZoV-JhvuNRAERTFg-5NFjr0uNk4i9ogNgJfAyyc,1171
 squirrels/_initializer.py,sha256=bJ0AeFIHYIYVT6o_kw5oWQJ9Qm4-n1RVNk3iYi2qbH0,14270
 squirrels/_manifest.py,sha256=ag902b0SNbra6XrBzkaKizmJGwRgFKPjEjtnkJgfFio,10232
-squirrels/_model_builder.py,sha256=fdoBcbbDpQaSTApV0mHKbq3yFe5xrr-TggdehEx8xE0,5063
+squirrels/_model_builder.py,sha256=5aLL_DxOv_wgJc3ml26q3hZSpmzkbniBC34Dh-f2ML4,5096
 squirrels/_model_configs.py,sha256=eJne5L-QLv42s7uodUOOASMRn1NbzGbiBmwMllkO5C4,3303
-squirrels/_model_queries.py,sha256=mvx3r0nps8rBGjmxP_SaGjDmKsjh5CBWQ6uAWxX1LnU,1088
-squirrels/_models.py,sha256=pP_NuYtBj8pmC--3BpNp6cVTxfkCUkZf19sB2v817Bg,49721
+squirrels/_model_queries.py,sha256=2fl07feHtzddBpiXUWGfNBYeoN_EZ7K5mAz2Jc-vCvs,1087
+squirrels/_models.py,sha256=_oudu_szkcBSAXYloxAd2LV2-gbTY6d8-E1kQuc89c0,50017
 squirrels/_package_loader.py,sha256=xcIur5Z38OWd-OVjsueFstVV567zlkK9UBnLS4NawJY,1158
-squirrels/_parameter_configs.py,sha256=GwKtuZJIMIsGx2d1bWlluqw3FkwIRv7nzekYzMQN4zg,23950
+squirrels/_parameter_configs.py,sha256=wxF51hMOewtf5SZgo6dEHa3vzU81vXN4LNmIK0UK9po,23981
 squirrels/_parameter_options.py,sha256=cWYKNoBUopHq6VfaeBu-nN2V0_IY3OgYpmYhKODNCew,16956
-squirrels/_parameter_sets.py,sha256=K_4HKu2keC1-EvaOSBS9PRDRjooicqfTz_NMk1ZqqRs,9823
-squirrels/_parameters.py,sha256=Bg3MqgkBb-QjtEIgBwA35730cOM3KCvq0_qFz-HZaZw,55942
-squirrels/_project.py,sha256=3RnBZVRJtZasuZ-KqIqCM5vOmBXtQr4_FTqrvFp5n5w,29307
-squirrels/_py_module.py,sha256=LgILTjMx3jyb92o8Y35ezpntuk6u6ezYVGAICKhUSUM,2622
+squirrels/_parameter_sets.py,sha256=xTiwDBT3LONILHlitA12J2b9CS4NU6-S1IQSILT2v8A,10315
+squirrels/_parameters.py,sha256=Ta929_a-b8r1miDKXT_SZtHT_d8jJ2W5ABvkXL7k074,76372
+squirrels/_project.py,sha256=y6r_ppujlSbxboS52zSIKfyzRo1kC1eQ9nkdYcHJc30,30391
+squirrels/_py_module.py,sha256=NW86sv1oYWh8oMqgGh2oIUwuFcLXoq3cwEuKRxPfEwY,2683
 squirrels/_seeds.py,sha256=yyIYp4bn9Sg6lhgvsOYIJQHIpPbvLNsyGHVfswEyVd8,2225
 squirrels/_sources.py,sha256=j5mY_EtA5cxoHwtk8RwTVHO74hleik2lS7mF9gVnG_A,4840
-squirrels/_utils.py,sha256=A2_zBxdKKf-HmwlI6vdsS6VMrefDF1km9TBuwnOG-ME,12279
+squirrels/_utils.py,sha256=yZ7pyWUZxCkAtOZO00QAN9kRM9KNpIUwERnnaiXCpxg,13552
 squirrels/_version.py,sha256=M8aFbJ4vlAi3Sk9b7leRuEfkNBjkkX5S_F9lA4h8GK4,105
-squirrels/arguments.py,sha256=Sg8m5_LYrL4IMb7fzZGmyNceA2vQMD7fiu0cXNir_V4,165
+squirrels/arguments.py,sha256=s8Ud0ahdgyMO9jO_qV9uYzJ3rCApAeRKpNKCz_EfQjI,181
+squirrels/auth.py,sha256=GNalDnQo4I1ONSYUGWwAxhJmgEwLYy688Fby-ksvnHk,54
 squirrels/connections.py,sha256=dpjR00DjLiPfF0iz9HfL9PyjWYtYQq67zk2LyT2bnhg,64
-squirrels/dashboards.py,sha256=hPpuG4xJIZdY7OQFcO_CdO630KCSgLzHdMSsGjlpt5U,57
+squirrels/dashboards.py,sha256=UA-mksRXtL5dyzewoGTnR5bz26KzvrVgKsIpNIPkLe0,52
 squirrels/data_sources.py,sha256=6a4E1m-Zcx-o2SERwKJiz8n6LFsI2CQ5MbmDwKhVq1o,170
 squirrels/parameter_options.py,sha256=TmvoESS1BSPx-73bNzo6W0bSztj7-ye0_vssmii0cBk,205
 squirrels/parameters.py,sha256=7Go5jetD3J7NDrkk2a_7ExxJv0mT4rwo1B9sAkuxPPg,195
-squirrels/types.py,sha256=xhCOlIxXOERG1Th_jTSE6yYJvFMNeATdZbqRFVsEhBg,263
-squirrels/_arguments/_init_time_args.py,sha256=_XfZjsqP9GWhJYppnokRAAFXO1mSqf1mUcKG0KgWk7o,3448
-squirrels/_arguments/_run_time_args.py,sha256=ppakg7XXnhgIkycingldxcaDqXtBkgpfyMpiFhAYK9Y,5017
-squirrels/_package_data/base_project/.env,sha256=3Tuk3SJl7RNMebm8P0jocqB-Ox91aW09Zreq8QjyUJ4,1026
-squirrels/_package_data/base_project/.env.example,sha256=dS5ZO_kyMT3GdZbj6nfiK9PzkvwGfse9-UiYkvrh7ys,1078
+squirrels/types.py,sha256=snP-ZLW_YY1TCCPVQTcDQMQvU6159yMRL-Hou9L7QJU,282
+squirrels/_api_routes/__init__.py,sha256=-oGMDfM5Qo7NDiwpjHt8BKVZNNZ4798-NZCJzYCUdbc,106
+squirrels/_api_routes/auth.py,sha256=BzThmdxugavFDW_RF2LNpPf8Z4fQcxrHL52TLPrsj54,13917
+squirrels/_api_routes/base.py,sha256=7H4SzhBJ-yWtC70kjzZneW_ZkejVzwTSnMlunSBt8ig,7067
+squirrels/_api_routes/dashboards.py,sha256=tasnHUmgkm-ZcpEviRoCiNtR9TgY6xjBZac7SkyEJBg,8097
+squirrels/_api_routes/data_management.py,sha256=Gr6JVFpMaFhlQCUICGxuDNWrz4BGPydrMou0elBg5tU,5347
+squirrels/_api_routes/datasets.py,sha256=Xcf-sTI8Noe06Tc-Nm5tJt4Y94ljl8ZXSxVrTOrN9gw,13592
+squirrels/_api_routes/oauth2.py,sha256=1Q0mgbOw39iOGKy_Wwuuxi_Iw5rRCXhZPKc_CXYsBH4,14855
+squirrels/_api_routes/project.py,sha256=gEtfDa1RyjxGEcUZTnNZSgQbLeIb5wUv2n65fZd6d40,11546
+squirrels/_arguments/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+squirrels/_arguments/init_time_args.py,sha256=Y5gVbrU_yd1r5JtAChcL1xTpfz0i8gwNtZMe5QBT2mc,3511
+squirrels/_arguments/run_time_args.py,sha256=Izh7nxifrzEmMCY41vzz8TWBJ5cSAHuXkjPRZRx6mHM,5016
+squirrels/_package_data/base_project/.env,sha256=CX13teP-pc3ymHIg9oERWcSGvxvMWRDOylLmI1Oiqpg,1105
+squirrels/_package_data/base_project/.env.example,sha256=eN9fIwZF0CbK5mz0zJ4xsZ2I2MwY7Tj6f1ZsudfJKkA,1157
 squirrels/_package_data/base_project/connections.yml,sha256=qZxh7OuI2xqf2cFKwpMo5TONrJXGVzQ7YfcWh4Go7Oo,1011
 squirrels/_package_data/base_project/duckdb_init.sql,sha256=iwKDoHbKhOEMe-Pu_sX5a9OauCgqxfZLD70S7RduBrE,196
 squirrels/_package_data/base_project/gitignore,sha256=B9OEkQ_j9fZGA2IAyVUvXeylxpya-AUwzLzqzMN4Bfc,155
@@ -66,15 +74,21 @@ squirrels/_package_data/base_project/models/federates/federate_example.sql,sha25
 squirrels/_package_data/base_project/models/federates/federate_example.yml,sha256=FpSVZV7xNSH5iUAXMkyd_jynFxWryutz5Izlgsq3aP0,2279
 squirrels/_package_data/base_project/pyconfigs/connections.py,sha256=IRL9D2HG9pdwp12S896b0Q-hKnFfVck8we1q5sifX10,601
 squirrels/_package_data/base_project/pyconfigs/context.py,sha256=8zsQ0tf0EhfeRDPwK7ANNaJWAubT3AYVCzcdaOz0xwY,3670
-squirrels/_package_data/base_project/pyconfigs/parameters.py,sha256=B3AdnzJzpK5BC_fADl7og_hsmejAYNqgjpQO-4eFYXk,5355
-squirrels/_package_data/base_project/pyconfigs/user.py,sha256=qP0dpptza-xBBZKxN3-KBfaDwaD5ZUGhUBqU8WqBNXk,855
+squirrels/_package_data/base_project/pyconfigs/parameters.py,sha256=VEHGP8UsoV7KQQAQB-K_6ciTOLZwO6h7OgW2Q4QJk5I,4496
+squirrels/_package_data/base_project/pyconfigs/user.py,sha256=5gRP_I5C2-z-gTaNt0F9yqk0yLzu6xrS0pdGvb8ZET4,2030
 squirrels/_package_data/base_project/seeds/seed_categories.csv,sha256=jppjf1nOIxy7-bi5lJn5CVqmnLfJHHq0ABgp6UqbXnw,104
 squirrels/_package_data/base_project/seeds/seed_categories.yml,sha256=NZ4BVvYYCEq6OnjRLrE_WOMhYsW0BQhRPWOgUchzdp4,435
 squirrels/_package_data/base_project/seeds/seed_subcategories.csv,sha256=Tta1oIgnc2nukNMDlUkIErRKNH_8YT5EPp1A2kQKcow,327
 squirrels/_package_data/base_project/seeds/seed_subcategories.yml,sha256=QTgw8Eld-p6Kntf53FyXyn7-7vKYI7IOJVu-Lr-FHCY,583
 squirrels/_package_data/base_project/tmp/.gitignore,sha256=XImoqcWvJY0C0L_TWCx1ljvqU7qh9fUTJmK4ACCmNFI,13
-squirrels-0.5.0b3.dist-info/METADATA,sha256=PIrRC6cNC2UbwcUSK7eVbiiK9LM8l43_zX9qI5M66n4,4399
-squirrels-0.5.0b3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-squirrels-0.5.0b3.dist-info/entry_points.txt,sha256=i6vgjhJ3o_cdSFYofFcNY9DFMPr4MIcuwnkskSTXfJc,95
-squirrels-0.5.0b3.dist-info/licenses/LICENSE,sha256=qqERuumQtQVsMrEXvJHuecJvV2sLxbleEubd_Zk8dY8,11338
-squirrels-0.5.0b3.dist-info/RECORD,,
+squirrels/_package_data/templates/dataset_results.html,sha256=Y-1xtw4ZzHcoW1vfWR1amnFJqFUMvwJDY3eeY7bfKJw,2793
+squirrels/_package_data/templates/oauth_login.html,sha256=LmR7zbjFUYxWIhB9nhIkoGDmqUgEtSXCqo0pKrWqwXw,7108
+squirrels/_schemas/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+squirrels/_schemas/auth_models.py,sha256=3EpMtGip5iPfA4ixWBa5ipOy9LrQafC047nc1Mhjz3w,5625
+squirrels/_schemas/query_param_models.py,sha256=zPfvr2kHEhGqbFDDs4oGsy8zYt-acwO0mfq1ELIpEI8,4094
+squirrels/_schemas/response_models.py,sha256=lvz37EPPDkj6ZNb8ZprnCgpmFHrZA4Xg-04MVxBqfLg,13616
+squirrels-0.5.0b4.dist-info/METADATA,sha256=QCKmfVXmjXUPl2qya_8KIyolw072cgjrWt61LYOXZYc,4496
+squirrels-0.5.0b4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+squirrels-0.5.0b4.dist-info/entry_points.txt,sha256=i6vgjhJ3o_cdSFYofFcNY9DFMPr4MIcuwnkskSTXfJc,95
+squirrels-0.5.0b4.dist-info/licenses/LICENSE,sha256=qqERuumQtQVsMrEXvJHuecJvV2sLxbleEubd_Zk8dY8,11338
+squirrels-0.5.0b4.dist-info/RECORD,,