ascender-framework 2.0.2__tar.gz → 2.0.4__tar.gz

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: ascender-framework
-Version: 2.0.2
+Version: 2.0.4
 Summary: The Ascender Framework is a sophisticated and structured FastAPI-based framework, inspired by the principles of NestJS. It stands out for its modular and organized architecture, offering developers a streamlined and efficient way to build web applications
 Author: AscenderTeam
 Requires-Python: >=3.11,<3.14

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/clis/generator/generator_app.py

@@ -43,7 +43,7 @@ class GeneratorCLI(GenericCLI):
     def generate_service(
         self,
         name: str,
-        module: str | None = Parameter(names=["-m", "--module"], description="Module to generate the service in"),
+        module: str | None = Parameter(default=None, names=["-m", "--module"], description="Module to generate the service in"),
     ):
         module_update, file_info = self.create_generator_service.generate_service(name, module)
         rprint(f"[green]{file_info['schematic_type']}[/green] {file_info['file_path']} [cyan]({file_info['write_size']} bytes)[/cyan]")
@@ -54,7 +54,7 @@ class GeneratorCLI(GenericCLI):
     def generate_module(
         self,
         name: str,
-        module: str | None = Parameter(names=["-m", "--module"], description="Module to generate the module in"),
+        module: str | None = Parameter(default=None, names=["-m", "--module"], description="Module to generate the module in"),
     ):
         module_update, file_info = self.create_generator_service.generate_module(name, module)
         rprint(f"[green]{file_info['schematic_type']}[/green] {file_info['file_path']} [cyan]({file_info['write_size']} bytes)[/cyan]")
@@ -68,7 +68,7 @@ class GeneratorCLI(GenericCLI):
         name: str,
         entities: tuple[str] | None = Parameter(None, names=["-e", "--entities"], description="List of entities to include in the repository", nargs="*"),
         orm_mode: str = Parameter("default", names=["--orm-mode"], description="ORM mode to use for the repository"),
-        module: str | None = Parameter(names=["-m", "--module"], description="Module to generate the repository in", default=None)
+        module: str | None = Parameter(default=None, names=["-m", "--module"], description="Module to generate the repository in")
     ):
         repository = self.create_generator_service.generate_repository(
             name, 
@@ -89,7 +89,7 @@ class GeneratorCLI(GenericCLI):
         self,
         name: str,
         guard_type: Literal["single", "parametrized"] = Parameter("single", names=["--type"], description="Type of guard to generate"),
-        module: str | None = Parameter(names=["-m", "--module"], description="Module to generate the guard in", default=None),
+        module: str | None = Parameter(default=None, names=["-m", "--module"], description="Module to generate the guard in"),
         guards: tuple[str] | None = Parameter(None, names=["--guards"], description="List of guards to include", nargs="+", action="extend")
     ):
         guard_update, file_info = self.create_generator_service.generate_guard(

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/clis/run/run_app.py

@@ -23,7 +23,11 @@ class RunCLI(BasicCLI):
         
         if "relax" in self.extra: return self.get_cow()
         source = _AscenderConfig().config.paths.source
-        return subprocess.call(f"poetry run python {source}/main.py {' '.join(self.extra)}", shell=True)
+        try:
+            return subprocess.call(f"poetry run python {source}/main.py {' '.join(self.extra)}", shell=True)
+        except KeyboardInterrupt:
+            rprint("\n[yellow]Exiting ascender run mode...[/yellow]")
+            rprint("\n[cyan]Gracefully shutting down the Ascender application...[/cyan]")
 
     def get_cow(self):
         relax_replicas = [

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/common/http/__init__.py

@@ -1,3 +1,5 @@
+from .types.file import FileData
+from .types.formdata import FormData
 from .client import HTTPClient
 from .provider import provideHTTPClient
 from .types.http_options import HTTPOptions, HeaderTypes
@@ -12,5 +14,7 @@ __all__ = [
     "_await",
     "Interceptor",
     "InterceptorFn",
-    "InterceptorIn"
+    "InterceptorIn",
+    "FormData",
+    "FileData"
 ]

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/common/http/_transport.py

@@ -58,7 +58,7 @@ class AscHTTPTransport(AsyncBaseTransport):
         modified_request = request
         # Handle class interceptors based on dependency injection
         class_interceptors: list[Interceptor] | Interceptor = RootInjector().get(
-            "HTTP_INTERCEPTOR", not_found_value=[], options={"optional": True})
+            "HTTP_INTERCEPTOR", not_found_value=[], options={"optional": True}) # type: ignore
 
         modified_request = await self.request_class_interceptors(modified_request, class_interceptors)
 

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/common/http/client.py

@@ -1,10 +1,13 @@
-from contextlib import _GeneratorContextManager
-from threading import Thread
-from typing import Any, Literal, TypeVar, cast
-from httpx import AsyncClient, Response, stream
+import asyncio
+import json
+from contextlib import _AsyncGeneratorContextManager
+from typing import Any, Literal, TypeVar, cast, overload
+from httpx import AsyncClient, Response
 from pydantic import BaseModel
 from reactivex import create, Observer, abc, Observable
 
+from ascender.common.http.types.formdata import FormData
+
 from ._transport import AscHTTPTransport
 from .types.http_options import HTTPOptions
 
@@ -54,7 +57,7 @@ class HTTPClient:
         _resp: type[T] | T = dict,
         *,
         url: str,
-        content: Any | BaseModel | None,
+        content: Any | BaseModel | FormData | None,
         options: HTTPOptions | None = None
     ) -> T:
         """Send a POST request to a desired endpoint.
@@ -83,7 +86,7 @@ class HTTPClient:
         _resp: type[T] | T = dict,
         *,
         url: str,
-        content: Any | BaseModel | None,
+        content: Any | BaseModel | FormData | None,
         options: HTTPOptions | None = None
     ) -> T:
         """Send a PUT request to a desired endpoint.
@@ -112,7 +115,7 @@ class HTTPClient:
         _resp: type[T] | T = dict,
         *,
         url: str,
-        content: Any | BaseModel | None,
+        content: Any | BaseModel | FormData | None,
         options: HTTPOptions | None = None
     ) -> T:
         """Send a PATCH request to a desired endpoint.
@@ -163,15 +166,42 @@ class HTTPClient:
 
         return cast(T, self.__handle_response(_resp, response=response))
 
+    @overload
     def stream(
         self,
         _resp: type[T] | T = dict,
         *,
         method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"],
         url: str,
-        content: Any | BaseModel | None = None,
-        options: HTTPOptions | None = None
+        content: Any | BaseModel | FormData | None = None,
+        options: HTTPOptions | None = None,
+        as_observable: Literal[True] = True,
     ) -> Observable[T]:
+        ...
+
+    @overload
+    def stream(
+        self,
+        _resp: type[T] | T = dict,
+        *,
+        method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"],
+        url: str,
+        content: Any | BaseModel | FormData | None = None,
+        options: HTTPOptions | None = None,
+        as_observable: Literal[False],
+    ) -> _AsyncGeneratorContextManager[Response]:
+        ...
+
+    def stream(
+        self,
+        _resp: type[T] | T = dict,
+        *,
+        method: Literal["GET", "POST", "PUT", "DELETE", "PATCH"],
+        url: str,
+        content: Any | BaseModel | FormData | None = None,
+        options: HTTPOptions | None = None,
+        as_observable: bool = True,
+    ) -> Observable[T] | _AsyncGeneratorContextManager[Response]:
         """Send a streaming request to a desired endpoint.
 
         Args:
@@ -180,9 +210,10 @@ class HTTPClient:
             url (str): The URL to send the request to.
             content (Any | BaseModel | None, optional): The content to include in the request body (supports pydantic models). Defaults to None.
             options (HTTPOptions | None, optional): Additional options for the request. Defaults to None.
+            as_observable (bool, optional): When True (default), returns an Observable; when False, returns an async context manager for manual streaming.
 
         Returns:
-            Observable[T]: An observable that emits the response from the server.
+            Observable[T] | _AsyncGeneratorContextManager[Response]: Stream subscription helper or the raw streaming context manager.
 
         Raises:
             httpx.HTTPError: If an error occurs during the HTTP request.
@@ -190,9 +221,12 @@ class HTTPClient:
         payload_options = {} if not options else options
         request_payload = self.__prepare_request_body(content)
 
-        resposne = stream(method, url, **request_payload, **cast(HTTPOptions, payload_options)) # type: ignore
+        response_ctx = self.client.stream(method, url, **request_payload, **cast(HTTPOptions, payload_options)) # type: ignore
         
-        return create(cast(abc.Subscription[T], self.__handle_streaming(_resp, response=resposne)))
+        if not as_observable:
+            return response_ctx
+
+        return create(cast(abc.Subscription[T], self.__handle_streaming(_resp, response=response_ctx)))
 
     def __prepare_request_body(
         self,
@@ -203,26 +237,53 @@ class HTTPClient:
 
         if isinstance(content, BaseModel):
             return {"json": cast(BaseModel, content).model_dump(mode="json")}
-
+        
+        if isinstance(content, FormData):
+            return content._construct()
+        
         return {"json": content}
 
     def __handle_streaming(
         self,
         _resp: type[T] | T = dict,
         *,
-        response: _GeneratorContextManager[Response]
+        response: _AsyncGeneratorContextManager[Response]
     ):
         def observable_response(observer: Observer[T], _):
-            def handle_request():
-                with response as item:
-                    for line in item.iter_text():
-                        observer.on_next(cast(T, line))
-                    
+            async def handle_request():
+                try:
+                    async with response as item:
+                        async for line in item.aiter_text():
+                            parsed = self.__parse_stream_chunk(_resp, line)
+                            observer.on_next(parsed)
+
                     observer.on_completed()
+                except Exception as exc:
+                    observer.on_error(exc)
 
-            Thread(target=handle_request).start()
+            asyncio.create_task(handle_request())
         return observable_response
 
+    def __parse_stream_chunk(self, _resp: type[T] | T, chunk: str) -> T:
+        if isinstance(_resp, BaseModel):
+            return cast(T, type(_resp).model_validate_json(chunk))
+
+        if isinstance(_resp, type) and issubclass(_resp, BaseModel):
+            return cast(T, cast(type[BaseModel], _resp).model_validate_json(chunk))
+
+        try:
+            data = json.loads(chunk)
+        except Exception:
+            return cast(T, chunk)
+
+        if isinstance(_resp, type):
+            try:
+                return cast(T, _resp(data))  # type: ignore[arg-type]
+            except Exception:
+                return cast(T, data)
+
+        return cast(T, data)
+
     def __handle_response(
         self,
         _resp: type[T] | T = dict,

ascender_framework-2.0.4/ascender/common/http/types/file.py

@@ -0,0 +1,15 @@
+from io import BytesIO
+
+
+class FileData:
+    def __init__(self, filename: str, content: bytes | BytesIO, content_type: str) -> None:
+        self.filename = filename
+        self.content = content
+        self.content_type = content_type
+    
+    def seek(self, position: int) -> None:
+        if isinstance(self.content, BytesIO):
+            self.content.seek(position)
+    
+    def construct(self) -> tuple[str, bytes | BytesIO, str]:
+        return (self.filename, self.content, self.content_type)

ascender_framework-2.0.4/ascender/common/http/types/formdata.py

@@ -0,0 +1,87 @@
+from io import BytesIO
+from typing import Any, Iterable
+
+from fastapi import UploadFile
+from pydantic import BaseModel
+
+from ascender.common.http.types.file import FileData
+
+
+class FormData:
+    """A form data container for HTTP multipart/form-data requests.
+    
+    This class provides an interface similar to the JavaScript FormData API for building
+    multipart form data. It supports string values and file uploads via FileData.
+    
+    Note:
+        UploadFile values cannot be passed directly to the constructor. They must be added
+        using the append() or set() methods, which handle the conversion to FileData internally.
+    """
+    
+    def __init__(self, **entries: str | FileData) -> None:
+        """Initialize FormData with key-value pairs.
+        
+        Args:
+            **entries: Key-value pairs where values can be strings or FileData objects.
+                Note: UploadFile values are not accepted here. Use append() or set() instead.
+        """
+        self.fields = entries
+    
+    def append_from_dto(self, data: BaseModel) -> None:
+        self.fields.update(data.model_dump(mode="json"))
+    
+    def append(self, name: str, value: str | FileData | UploadFile) -> None:
+        if isinstance(value, UploadFile):
+            if not value.content_type or not value.filename:
+                raise ValueError("UploadFile must have content_type and filename")
+
+            file_content = value.file.read()
+            file_data = FileData(
+                filename=value.filename,
+                content_type=value.content_type,
+                content=BytesIO(file_content)
+            )
+            self.fields[name] = file_data
+            return
+        
+        self.fields[name] = value
+    
+    def entries(self) -> Iterable[tuple[str, Any]]:
+        return iter(self.fields.items())
+    
+    def get(self, name: str) -> str | FileData | None:
+        return self.fields.get(name)
+    
+    def get_all(self) -> dict[str, str | FileData]:
+        return self.fields.copy()
+    
+    def has(self, name: str) -> bool:
+        return name in self.fields
+    
+    def keys(self) -> Iterable[str]:
+        return self.fields.keys()
+    
+    def set(self, name: str, value: str | FileData | UploadFile) -> None:
+        self.append(name, value)
+    
+    def values(self) -> Iterable[Any]:
+        return self.fields.values()
+    
+    def delete(self, name: str) -> None:
+        if name in self.fields:
+            del self.fields[name]
+    
+    def _construct(self):
+        files: dict[str, Any] = {}
+        data: dict[str, Any] = {}
+        
+        for key, value in self.fields.items():
+            if isinstance(value, FileData):
+                files[key] = value.construct()
+            else:
+                data[key] = str(value)
+        
+        return {
+            "data": data,
+            "files": files
+        }

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/common/http/types/interceptors.py

@@ -3,7 +3,7 @@ from typing import Awaitable, Callable
 from httpx import Request, Response
 
 InterceptorIn = Request
-InterceptorFn = Awaitable[Callable[[Request], Request]]
+InterceptorFn = Callable[[Request], Awaitable[Request]]
 
 
 class Interceptor(ABC):
@@ -13,4 +13,4 @@ class Interceptor(ABC):
         raise NotImplementedError("Handle request is not implemented")
     
     async def handle_response(self, response: Response):
-        return response
+        return response

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/core/_config/interface/runtime.py

@@ -19,9 +19,9 @@ class LoggingConfig(BaseModel):
     level: Literal["debug", "info", "warn", "error", "critical"] = Field("info", description="Logging level.")
     file: Optional[str] = Field(None, description="Path to the log file.")
     console: bool = Field(True, description="Whether to enable console logging.")
-    rotation: Optional[LoggingRotationConfig] = Field(
-        None, description="Log rotation settings."
-    )
+    console_format: Literal["rich", "json"] = Field("rich", description="Console log format.")
+    file_format: Literal["rich", "json"] = Field("json", description="File log format.")
+    rotation: Optional[LoggingRotationConfig] = Field(None, description="Log rotation settings.")
 
 
 class BuildConfig(BaseModel):
@@ -49,7 +49,7 @@ class DependencyInjectionConfig(BaseModel):
         "warn", description="Action to take when circular dependencies are detected."
     )
     overrides: OverrideConfig = Field(
-        OverrideConfig(enabled=False, injector="ascender.core.di.injector.AscenderInjector"), 
+        OverrideConfig(enabled=False, injector="ascender.core.di.injector.AscenderInjector"),
         description="Dependency injection settings for this environment."
     )
 
@@ -59,4 +59,3 @@ class FeaturesConfig(BaseModel):
     runtimeMonitoring: bool = Field(True, description="Whether to enable runtime monitoring.")
     autoMigrations: bool = Field(False, description="Whether to enable automatic migrations.")
     staticFileServing: bool = Field(True, description="Whether to enable serving of static files.")
-

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/core/_config/stub.json

@@ -1,7 +1,7 @@
 {
     "project": {
         "name": "Ascender Framework",
-        "version": "1.3.0-b6",
+        "version": "2.0.4",
         "description": "A backend project powered by Ascender Framework"
     },
     "paths": {

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/core/cli_engine/engine.py

@@ -152,15 +152,12 @@ class CLIEngine:
             subcommand_args = {k: v for k, v in arguments.items() if k in handler_info.parameters}
             
             method = getattr(command_instance, handler_info._functionname)
-            if iscoroutinefunction(method):
-                return asyncio.run(call_parsed_method(method, subcommand_args))
 
             return call_parsed_method(method, subcommand_args)
         
         else:
             raise TypeError(f"Unknown command type: {type(command_instance)}")
 
-
     def parse_and_execute(self, argv: list[str] | None = None) -> Any:
         """
         Parse command line arguments and execute the appropriate command.

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/core/di/overrider.py

@@ -9,7 +9,7 @@ class InjectionOverriderContext:
         self.token: Token[Provider | None] | None = None
         self.providers = providers
     
-    def __aenter__(self) -> Self:
+    def __enter__(self) -> Self:
         self.token = StaticOverrider.override(self.providers)
         return self
     
@@ -31,8 +31,8 @@ class InjectionOverriderContext:
         
         StaticOverrider.reset(self.token)
         self.token = StaticOverrider.override(self.providers)
-    
-    def __aexit__(self, exc_type, exc_val, exc_tb) -> Literal[False]:
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> Literal[False]:
         StaticOverrider.reset(self.token)
         return False
 

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/core/logger/_logger.py

@@ -1,44 +1,48 @@
-from logging import Logger, getLogger
-from rich.logging import RichHandler
 import logging
 import os
+from logging import getLogger
+
+from rich.logging import RichHandler
 
 from ascender.core._config.asc_config import _AscenderConfig
-from ascender.core._config.interface.environment import EnvironmentConfig
-from ascender.core._config.interface.runtime import LoggingConfig, ServerConfig
-from ascender.core.logger.formatter import AscenderFormatter
+from ascender.core._config.interface.runtime import LoggingConfig
+from ascender.core.logger.formatter import (AscenderFormatter,
+                                            JsonAscenderFormatter)
 
 from .rotation import configure_file_logging
 
 
 def configure_logger(config: LoggingConfig):
-    """
-    Configures a logger with the AscenderFormatter.
-    """
-    # Disable root logger's bad stuff
     root_logger = getLogger()
     root_logger.setLevel(logging.WARNING)
     root_logger.propagate = False
 
-    # Create logger
     logger = getLogger("Ascender Framework")
-
     logger.setLevel(config.level.upper())
-    logger.propagate = False  # Avoid duplicate logs if root logger is configured
-
-    rich_formatter = AscenderFormatter()
+    logger.propagate = False
 
-    # Create stream handler for console output
+    # Console handler
     if config.console:
-        rich_handler = RichHandler(rich_tracebacks=True, markup=True)
-        rich_handler.setFormatter(rich_formatter)
-        logger.addHandler(rich_handler)
+        if config.console_format == "json":
+            console_handler = logging.StreamHandler()
+            console_handler.setFormatter(JsonAscenderFormatter())
+            logger.addHandler(console_handler)
+        else:
+            rich_handler = RichHandler(rich_tracebacks=True, markup=True)
+            rich_handler.setFormatter(AscenderFormatter())
+            logger.addHandler(rich_handler)
 
-    # Optional: Create file handler for logging to a file
+    # File handler
     if config.file:
         rotation_config = config.rotation
         logs_path = _AscenderConfig().config.paths.logs
-        file_handler = configure_file_logging(os.path.abspath(os.path.join(logs_path, config.file)), rotation_config)
+        file_handler = configure_file_logging(
+            os.path.abspath(os.path.join(logs_path, config.file)), rotation_config
+        )
+        if config.file_format == "json":
+            file_handler.setFormatter(JsonAscenderFormatter())
+        else:
+            file_handler.setFormatter(AscenderFormatter())
         logger.addHandler(file_handler)
 
     return logger
@@ -63,5 +67,5 @@ def configure_logger(config: LoggingConfig):
 #     #     rotation_config = config.rotation
 #     #     file_handler = configure_file_logging(os.path.abspath(config.file), rotation_config)
 #     #     uvicorn_access.addHandler(file_handler)
-    
+
 #     return uvicorn_access

ascender_framework-2.0.4/ascender/core/logger/formatter.py

@@ -0,0 +1,56 @@
+import json
+import logging
+from datetime import datetime
+
+from rich.console import Console
+
+
+class AscenderFormatter(logging.Formatter):
+    def format(self, record: logging.LogRecord) -> str:
+        console = Console()
+
+        # Extract log details
+        timestamp = self.formatTime(record, "%H:%M:%S")
+        level = record.levelname
+        logger_name = record.name
+        message = record.getMessage()
+
+        # Color-code log levels
+        level_markup = {
+            "DEBUG": "[cyan]DEBUG[/cyan]",
+            "INFO": "[green]INFO[/green]",
+            "WARNING": "[yellow]WARNING[/yellow]",
+            "ERROR": "[red]ERROR[/red]",
+            "CRITICAL": "[bold red]CRITICAL[/bold red]",
+        }
+
+        # Format log message
+        markup_message = (
+            f"[dim]{timestamp}[/dim] ┆ "
+            f"{level_markup.get(level, level)} ┆ "
+            f"[magenta]{logger_name}[/magenta] ┆ "
+            f"{message}"
+        )  # Message content
+
+        return markup_message
+
+
+class JsonAscenderFormatter(logging.Formatter):
+    def __init__(self, service: str | None = None):
+        super().__init__()
+        self.service = service
+
+    def format(self, record: logging.LogRecord) -> str:
+        log_obj = {
+            "ts": datetime.utcfromtimestamp(record.created).isoformat() + "Z",
+            "severity": record.levelname,
+            "service": self.service or record.name,
+            "message": record.getMessage(),
+        }
+
+        reserved = set(vars(logging.LogRecord("", 0, "", 0, "", (), None)))
+        for key, value in record.__dict__.items():
+            if key not in reserved and key not in log_obj:
+                log_obj[key] = value
+
+        return json.dumps(log_obj)

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/guards/guard.py

@@ -15,7 +15,6 @@ class Guard(ABC):
     __di_module__: AscModuleRef | None = None
     __declaration_type__: str = "guard"
 
-    @abstractmethod
     def __init__(self):
         """
         For Guard configurations and parameters

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/guards/paramguard.py

@@ -1,4 +1,3 @@
-from abc import abstractmethod
 from functools import wraps
 from typing import final
 from typing import Any, Callable
@@ -11,33 +10,31 @@ from ascender.core.utils.module import load_module
 
 
 class ParamGuard:
-    __di_module__: AscModuleRef = None
+    __di_module__: AscModuleRef | None = None
     __declaration_type__: str = "guard"
     
-    @abstractmethod
     def __init__(self):
         ...
     
-    @abstractmethod
     def __post_init__(self):
         ...
 
     @final
     def handle_di(self):
         if not self.__di_module__:
-            RootInjector().injector.inject_factory_def(self.__post_init__)()
+            RootInjector().injector.inject_factory_def(self.__post_init__)() # type: ignore
             return
         
         di_module = self.__di_module__
         
         # Load module or if it's already loaded then just use it and ignore `RuntimeError: module is already loaded`
         try:
-            di_module = load_module(di_module)
+            di_module = load_module(di_module) # type: ignore
         except RuntimeError:
             pass
         
         # Execute `self.__post_init__` method
-        self.__di_module__._injector.inject_factory_def(self.__post_init__)()
+        self.__di_module__._injector.inject_factory_def(self.__post_init__)() # type: ignore
 
     def _define_dependencies(self, executable: Callable[..., None]):
         """
@@ -78,6 +75,6 @@ class ParamGuard:
 
         @wraps(executable)
         async def wrapper(*args, **kwargs):
-            return await _updatedfunc(*args, **kwargs)
+            return await _updatedfunc(*args, **kwargs) # type: ignore
 
         return wrapper

{ascender_framework-2.0.2 → ascender_framework-2.0.4}/ascender/schematics/project/files/ascender.json.asctpl

@@ -13,6 +13,8 @@
     "logging": {
         "level": "debug",
         "file": "logs/ascender.log",
+        "console_format": "rich",
+        "file_format": "rich",
         "console": true,
         "rotation": {
             "enabled": true,