ascender-framework 2.1.0__tar.gz → 2.1.0a2__tar.gz

{ascender_framework-2.1.0 → ascender_framework-2.1.0a2}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.3
 Name: ascender-framework
-Version: 2.1.0
+Version: 2.1.0a2
 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
+Requires-Python: >=3.11,<3.15
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
@@ -11,7 +11,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: aerich (>=0.7.2,<0.8.0)
 Requires-Dist: chardet (>=5.2.0,<6.0.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
-Requires-Dist: fastapi (>=0.115)
+Requires-Dist: fastapi (>=0.115,<0.135.3)
 Requires-Dist: httpx (>=0.28.1,<0.29.0)
 Requires-Dist: inflection (>=0.5.1,<0.6.0)
 Requires-Dist: jinja2 (>=3.1.4,<4.0.0)
@@ -20,7 +20,6 @@ Requires-Dist: pydantic[email] (>=2.7.4)
 Requires-Dist: pyinstaller (>=6.11.1,<7.0.0)
 Requires-Dist: pytest (>=8.4.2,<9.0.0)
 Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
-Requires-Dist: python-minifier (>=2.11.3,<3.0.0)
 Requires-Dist: reactivex (>=4.0.4)
 Requires-Dist: readchar (>=4.0.5,<5.0.0)
 Requires-Dist: requests (>=2.31.0)

{ascender_framework-2.1.0 → ascender_framework-2.1.0a2}/ascender/clis/builder/build_service.py

@@ -1,12 +1,13 @@
 import os
+
+from rich import print as rprint
+
 from ascender.clis.builder.build_message_service import BuildMessageService
-from ascender.core import Service
 from ascender.common import Injectable
+from ascender.core import Service
 from ascender.core._builder.file_builder import build_file_manager
-from ascender.core._builder.minifier import minify_project
 from ascender.core._builder.obfuscator import obfuscate_project
 from ascender.core._config.asc_config import _AscenderConfig
-from rich import print as rprint
 
 
 @Injectable(provided_in="root")
@@ -24,50 +25,49 @@ class BuildService(Service):
         build_configs = configs.build
 
         # display start message using rich print
-        rprint(f"[green]INFO[/green] Building {configs.project['name']} - Ascender Framework Project")
+        rprint(
+            f"[green]INFO[/green] Building {configs.project['name']} - Ascender Framework Project"
+        )
         rprint("[cyan]Preparing configuration files for build[/cyan]")
 
         if build_configs.obfuscate:
-            rprint("[green]INFO[/] [yellow]`Obfuscation` detected in `ascender.json`[/]")
+            rprint(
+                "[green]INFO[/] [yellow]`Obfuscation` detected in `ascender.json`[/]"
+            )
             rprint("[green]INFO[/] Using [cyan bold]PyInstaller[/] to build project...")
             rprint("[green]INFO[/] Using [cyan bold]PyInstaller[/] to build project...")
             self.build_file_manager(False)
 
             obfuscate_project(
-                configs.project["name"], configs.paths.output, configs.paths.source, configs.build.packages, configs.build.importMetadata
+                configs.project["name"],
+                configs.paths.output,
+                configs.paths.source,
+                configs.build.packages,
+                configs.build.importMetadata,
             )
 
-            rprint("[green]INFO[/] [cyan]Obfuscation finished, build has been completed...[cyan]")
-            rprint(f"[green]INFO[/] [cyan]Build distribution is available in {configs.paths.output}/{configs.project['name']}[cyan]")
+            rprint(
+                "[green]INFO[/] [cyan]Obfuscation finished, build has been completed...[cyan]"
+            )
+            rprint(
+                f"[green]INFO[/] [cyan]Build distribution is available in {configs.paths.output}/{configs.project['name']}[cyan]"
+            )
             # display_obfuscated_instructions had no implementation in the message service, skipping.
             return
 
-        if build_configs.minify:
-            rprint("[green]INFO[/] [yellow]`minify` detected in `ascender.json`[/]")
-            rprint("[green]INFO[/] Using [cyan bold]python-minifier[/] to build project...")
-            rprint("[green]INFO[/] Using [cyan bold]python-minifier[/] to build project...")
-            self.build_file_manager(False)
-            minify_project(
-                configs.project["name"], 
-                configs.paths.output, 
-                configs.paths.source, 
-                build_configs.stripComments
-            )
-            rprint("[green]INFO[/] [cyan]Minification finished, build has been completed...[cyan]")
-            rprint(f"[green]INFO[/] [cyan]Build distribution is available in {configs.paths.output}/{configs.project['name']}[cyan]")
-            return
-        
         self.build_file_manager(True)
-        rprint(f"[yellow]Classic build has been finished, check out {configs.paths.output}/{configs.project['name']}...[/]")
+        rprint(
+            f"[yellow]Classic build has been finished, check out {configs.paths.output}/{configs.project['name']}...[/]"
+        )
 
     def build_file_manager(self, use_source: bool = True):
         configs = self.get_configs()
         build_configs = configs.build
 
         return build_file_manager(
-            configs.project["name"], configs.paths.output, configs.project.get(
-                "version", "0.1.0"
-            ),
+            configs.project["name"],
+            configs.paths.output,
+            configs.project.get("version", "0.1.0"),
             None if not use_source else configs.paths.source,
-            configs.paths.static if build_configs.includeStatic else None
+            configs.paths.static if build_configs.includeStatic else None,
         )

{ascender_framework-2.1.0 → ascender_framework-2.1.0a2}/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.1.0 → ascender_framework-2.1.0a2}/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.1.0 → ascender_framework-2.1.0a2}/ascender/common/http/awaitables/awaitable.py

@@ -6,7 +6,12 @@ def _await(coro: Coroutine):
     """
     Runs any coroutine in sync function, especially of the RxPY's Observable's `on_next` and `on_error` functions
     """
-    loop = asyncio.get_event_loop()
+    try:
+        loop = asyncio.get_event_loop()
+    except RuntimeError:
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+    
     return loop.run_until_complete(coro)
 
 __all__ = ["_await"]

{ascender_framework-2.1.0 → ascender_framework-2.1.0a2}/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.1.0a2/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.1.0a2/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.1.0 → ascender_framework-2.1.0a2}/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.1.0 → ascender_framework-2.1.0a2}/ascender/common/microservices/instances/kafka/rpc.py

@@ -108,7 +108,13 @@ class KafkaRPCTransport(RPCTransport):
 
         Instead it returns Reactivex observable object with 
         """
-        asyncio_scheduler = AsyncIOScheduler(asyncio.get_event_loop())
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+        
+        asyncio_scheduler = AsyncIOScheduler(loop)
         correlation_id = str(uuid4())
 
         data = parse_data(data).encode()

{ascender_framework-2.1.0 → ascender_framework-2.1.0a2}/ascender/common/microservices/instances/redis/rpc.py

@@ -74,7 +74,12 @@ class RedisRPCTransport(RPCTransport):
         return await response
 
     async def send_nack_request(self, pattern, data, timeout):
-        loop = asyncio.get_event_loop()
+        try:
+            loop = asyncio.get_event_loop()
+        except RuntimeError:
+            loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(loop)
+            
         asyncio_scheduler = AsyncIOScheduler(loop)
         correlation_id = str(uuid4())
         payload = {

ascender_framework-2.1.0a2/ascender/core/_config/interface/runtime.py

@@ -0,0 +1,101 @@
+from typing import Literal, Optional
+
+from pydantic import BaseModel, Field
+
+
+class OverrideConfig(BaseModel):
+    enabled: bool = Field(
+        True, description="Whether dependency injection overrides are enabled."
+    )
+    injector: Optional[str] = Field(
+        None,
+        description="Custom injector class to use for dependency injection overrides.",
+    )
+
+
+class LoggingRotationConfig(BaseModel):
+    enabled: bool = Field(True, description="Whether log rotation is enabled.")
+    max_size: str = Field(
+        "10MB", description="Maximum size of a log file before rotation."
+    )
+    backup_count: int = Field(5, ge=1, description="Number of backup files to keep.")
+
+
+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.")
+    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):
+    target: Literal["development", "production", "test"] = Field(
+        ..., description="Build target environment."
+    )
+    minify: bool = Field(True, description="Whether to minify the code.")
+    obfuscate: bool = Field(True, description="Whether to obfuscate the code.")
+    stripComments: bool = Field(
+        True, description="Whether to strip comments from the code."
+    )
+    includeStatic: bool = Field(
+        True, description="Whether to include static files in the build."
+    )
+    includeLogs: bool = Field(True, description="Whether to include logs in the build.")
+    maxBuildSizeMB: int = Field(
+        50, ge=1, description="Maximum allowed build size in MB."
+    )
+    packages: list[str] = Field(
+        [], description="Additional packages and imports will be included during build"
+    )
+    importMetadata: list[str] = Field(
+        [], description="Additional import metadatas will be included during build"
+    )
+
+
+class ServerConfig(BaseModel):
+    workers: int = Field(4, ge=1, description="Number of worker processes.")
+    reload: bool = Field(
+        True, description="Whether to enable hot-reload for development."
+    )
+    timeout: int = Field(60, ge=1, description="Request timeout in seconds.")
+    requestLogging: bool = Field(
+        True, description="Whether to enable detailed request logging."
+    )
+
+
+class DependencyInjectionConfig(BaseModel):
+    strictMode: bool = Field(
+        True, description="Whether to enforce strict mode for dependency injection."
+    )
+    circularDependencyHandling: Literal["warn", "error"] = Field(
+        "warn", description="Action to take when circular dependencies are detected."
+    )
+    overrides: OverrideConfig = Field(
+        OverrideConfig(
+            enabled=False, injector="ascender.core.di.injector.AscenderInjector"
+        ),
+        description="Dependency injection settings for this environment.",
+    )
+
+
+class FeaturesConfig(BaseModel):
+    dependencyInjection: DependencyInjectionConfig = Field(
+        ..., description="Dependency injection settings."
+    )
+    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.1.0 → ascender_framework-2.1.0a2}/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.1.0 → ascender_framework-2.1.0a2}/ascender/core/applications/_create_internal.py

@@ -1,8 +1,10 @@
 from __future__ import annotations
+
 import os
 from typing import TYPE_CHECKING
 
 from ascender.clis.tests.tests_app import TestRunnerCLI
+from ascender.workspaces.provider import provideWorkspaces
 
 from .root_injector import RootInjector
 
@@ -13,21 +15,19 @@ if TYPE_CHECKING:
 def createInternalApplication():
     """
     Runs application in CLI mode
-    
+
     Args:
         config: An optional list of providers for root-level configuration.
-        
+
     Returns:
         An initialized Application instance.
     """
+    from ascender.clis.generator.generator_app import GeneratorCLI
     from ascender.clis.new.new_app import NewCLI
     from ascender.clis.run.run_app import RunCLI
     from ascender.clis.version.version_app import VersionCLI
-    from ascender.clis.generator.generator_app import GeneratorCLI
-    
     from ascender.core.cli_engine import CLIEngine, useCLI
-    
-    
+
     os.environ["ASC_MODE"] = "cli"
     # Initialize the root injector
     root_injector = RootInjector()
@@ -38,15 +38,20 @@ def createInternalApplication():
         useCLI(NewCLI),
         useCLI(RunCLI),
         useCLI(VersionCLI),
+        provideWorkspaces(),
         useCLI(TestRunnerCLI),
         {
             "provide": CLIEngine,
-            "use_factory": lambda commands: CLIEngine(commands, usage="ascender <command> [options]", description="🚀 Ascender Framework - Modern Python Web Framework"),
-            "deps": ["ASC_CLI_COMMAND"]
+            "use_factory": lambda commands: CLIEngine(
+                commands,
+                usage="ascender <command> [options]",
+                description="🚀 Ascender Framework - Modern Python Web Framework",
+            ),
+            "deps": ["ASC_CLI_COMMAND"],
         },
     ]
 
     # Configuration-based application creation
     root_injector.create(internal_providers)
 
-    return root_injector.get(CLIEngine) # type: ignore
+    return root_injector.get(CLIEngine)  # type: ignore