reinit

Author: AmaseCocoa

example/helloworld.py

@@ -1,9 +1,12 @@
+import kasumi
 from kasumi import Kasumi
 from starlette.requests import Request
 from starlette.responses import JSONResponse
 
 app = Kasumi()
 
-@app.post("/")
+@app.get("/")
 async def root(request: Request):
-    return JSONResponse({"Hello": "World"})
+    return JSONResponse({"Hello": "World"})
+
+print(kasumi.__version__)

pdm.lock

@@ -1,52 +1,43 @@
 [project]
 name = "Kasumi"
-description = "Starlette-based ASGI Web framework."
+description = "Another ASGI Web framework."
 authors = [
     {name = "AmaseCocoa", email = "[email protected]"},
 ]
 dependencies = [
     "starlette>=0.37.2",
-    "cleo>=2.1.0",
-]
-classifiers = [
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
+    "typer>=0.12.3",
+    "requests>=2.32.3",
+    "tqdm>=4.66.4",
+    "cowsay>=6.1",
 ]
 requires-python = ">=3.10"
 readme = "README.md"
 license = {file = "LICENSE"}
 dynamic = ["version"]
 
-[project.scripts]
-kasumi = "src.kasumi.cli.__main__:main"
-
 [project.optional-dependencies]
 asgi_dev = [
     "uvicorn[standard]>=0.30.1",
 ]
-lint = [
+test = [
+    "pytest>=8.2.2",
     "ruff>=0.4.8",
 ]
 
+[project.scripts]
+kasumi = "kasumi.cli.__core:app"
+
 [project.urls]
 # documentation = "https://kasumi.readthedocs.io/"
 repository = "https://github.com/AmaseCocoa/Kasumi/"
 
-[build-system]
-requires = ["setuptools", "wheel", "setuptools_scm>=8.0"]
-build-backend = "setuptools.build_meta"
-
-[tool.setuptools_scm]
-write_to = "src/kasumi/__version.py"
-version_scheme = "python-simplified-semver"
-local_scheme = "no-local-version"
+[tool.pdm.version]
+source = "scm"
 
-[tool.setuptools]
-package-dir = {"" = "src"}
-
-[tool.setuptools.dynamic]
-version = {attr = "kasumi.__version.__version__"}
+[build-system]
+requires = ["pdm-backend"]
+build-backend = "pdm.backend"
 
 [tool.pdm]
-distribution = true
+distribution = true

pyproject.toml

@@ -1,5 +1,9 @@
+from importlib.metadata import version
+
 from starlette.requests import Request
 
 from . import responses
-from .__version import __version__, __version_tuple__
-from .applications import Kasumi
+from .applications import Kasumi
+from .gear import Gear
+
+__version__ = version("kasumi")

requirements.txt

@@ -1,18 +1,39 @@
 import inspect
+from importlib import import_module
+import os
 from http.client import responses
 
 from starlette.requests import Request
 from starlette.responses import PlainTextResponse
 
-from .exceptions import AlreadyRegistedError
-
+from .exceptions import AlreadyRegistedError, GearException
+from .gear import Gear
 
 class Kasumi:
+    
     def __init__(self) -> None:
         self.__requests = {}
         self.__err = {}
 
     async def __call__(self, scope, receive, send):
+        """
+        This function handles incoming HTTP requests by routing them to the appropriate handler based on
+        the request method and path.
+        
+        :param scope: The `scope` parameter in the `__call__` method represents the metadata of the
+        incoming request. It contains information such as the type of the request (e.g., 'http' for HTTP
+        requests), the path of the request, and other details related to the communication channel. In
+        the provided
+        :param receive: The `receive` parameter in the `__call__` method is a callable that is used to
+        receive messages from the client. It is typically an asynchronous function that receives
+        messages from the client connection. In the context of an HTTP server, the `receive` function is
+        used to receive incoming HTTP requests
+        :param send: The `send` parameter in the `__call__` method is a coroutine function that is used
+        to send messages to the client. It is typically used to send HTTP response messages back to the
+        client. The `send` function takes a single argument, which is a dictionary representing the
+        message to be
+        """
+        
         assert scope['type'] == 'http'
         request = Request(scope, receive)
         if self.__requests.get(scope['path']):
@@ -103,4 +124,33 @@ def decorator(func):
                     raise AlreadyRegistedError(f'The function is already registered in the ErrorCode “{error_code}”.')
             self.__err[error_code] = func
             return func
-        return decorator
+        return decorator
+    
+    def combine_route(self, route: dict, name: str, routeType: str="normal"):
+        if routeType == "normal":
+            self.__requests[name] = route
+        elif routeType == "err":
+            self.__err[name] = route
+    
+    def include_gear(self, module: Gear):
+        route = module._requests
+        for k in route.keys():
+            if self.__requests.get(k):
+                for router in route[k].keys():
+                    if self.__requests[k].get(router):
+                        raise GearException(f"""The Route "{k}" registered in the gear has another function registered""")
+            else:
+                self.combine_route(
+                    route[k], k
+                )
+        del k
+        err = module._err
+        for k in err.keys():
+            if self.__err.get(k):
+                for error in err[k].keys():
+                    if self.__requests[k].get(error):
+                        raise GearException(f"""The Route "{k}" registered in the gear has another function registered""")
+            else:
+                self.combine_route(
+                    err[k], k
+                )

src/kasumi/__init__.py

@@ -0,0 +1,98 @@
+import json
+import os
+import re
+import shutil
+import urllib.parse
+
+import cowsay
+import requests
+import tqdm
+import typer
+from rich.console import Console
+from rich.table import Table
+
+app = typer.Typer(
+    name="Kasumi",
+    no_args_is_help=True
+)
+console = Console()
+
+@app.command(hidden=True, deprecated=True)
+def moo():
+    print(cowsay.get_output_string('cow', 'Hello, World!') + "\n")
+    table = Table("[bold dodger_blue2]Surprised?[/bold dodger_blue2]")
+    table.add_row("This is a temporary addition due to Typer's specifications.")
+    table.add_row("We plan to remove it in the future, so I suggest you enjoy Super Cow Powers while you can :)")
+    table.add_row("")
+    table.add_row("Love from the author❤")
+    console.print(table)
+
+@app.command()
+def init(dir: str=os.getcwd(), template: str=None, external_template: str=None):
+    dir = r"C:\\Users\AmaseCocoa\Desktop\\test"
+    if template is None:
+        while True:
+            table = Table("[bold dodger_blue2]Select Internal Template[/bold dodger_blue2]")
+            table.add_column("ID", justify="right", style="cyan", no_wrap=True)
+            table.add_column("Name", style="magenta")
+            table.add_column("Theme's Description", justify="right", style="green")
+            table.add_row("1", "default", "The most standard and smallest Kasumi template.")
+            table.add_row("2", "with_gear", "Kasumi template using Gear")
+            console.print(table)
+            select = input("select: ")
+            if select == "1":
+                template = "default"
+                break
+            elif select == "2":
+                template = "with_gear"
+                break
+            else:
+                table = Table("[bold red]Error[/bold red]")
+                table.add_row("The specified template does not exist.")
+                console.print(table)
+    if not external_template:
+        template_dir = os.path.join(os.path.join(os.path.dirname(__file__), "__templates"), template)
+        if os.path.isdir(template_dir):
+            with open(os.path.join(template_dir, "manifest.json"), "r") as f:
+                manifest = json.load(f)
+                for file in manifest["files"]:
+                    if isinstance(file, dict):
+                        shutil.copytree(os.path.join(os.path.join(template_dir, file["dir"])), os.path.join(dir, file["dir"]))
+                    else:
+                        path = os.path.join(template_dir, file)
+                        shutil.copy(path, dir)
+        else:
+            table = Table("[bold red]Error[/bold red]")
+            table.add_row("The specified template does not exist.")
+            console.print(table)
+            raise
+    else:
+        pattern = r"https?://[\w/:%#\$&\?\(\)~\.=\+\-]+"
+        if re.match(pattern, external_template):
+            if not external_template.endswith("manifest.json"):
+                manifest = urllib.parse.urljoin(external_template, "manifest.json")
+            else:
+                raise ValueError
+            manifest = requests.get(external_template)
+            manifest_jsonized = manifest.json()
+            for file in manifest_jsonized["files"]:
+                with open(os.path.join(dir, file), 'wb') as fp:
+                    url = urllib.parse.urljoin(external_template, file)
+                    with requests.get(url, stream=True) as req:
+                        req.raise_for_status()
+                        total = int(req.headers.get('content-length', 0))
+                        with tqdm.tqdm(**{'desc': url,'total': total,'miniters': 1,'unit': 'B','unit_scale': True,'unit_divisor': 1024,}) as pb:
+                            for chunk in req.iter_content(chunk_size=8192):
+                                pb.update(len(chunk))
+                                fp.write(chunk)
+        else:
+            with open(os.path.join(external_template, "manifest.json"), "r") as f:
+                manifest = json.load(f)
+                for file in manifest["files"]:
+                    if isinstance(file, dict):
+                        os.mkdir(os.path.join(dir, file["dir"]))
+                        for filed in file["files"]:
+                            shutil.copy(os.path.join(os.path.join(os.path.join(external_template, file["dir"]), filed), os.path.join(dir, file["dir"])))
+                    else:
+                        shutil.copy(os.path.join(external_template, file), dir)
+    console.print("[bold green]Project initialization succeeded![/bold green]")

src/kasumi/__version.py

@@ -0,0 +1 @@
+

src/kasumi/applications.py

@@ -0,0 +1,10 @@
+import kasumi
+from kasumi import Kasumi
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+app = Kasumi()
+
+@app.get("/")
+async def root(request: Request):
+    return JSONResponse({"Hello": "World"})

src/kasumi/cli/__core.py

@@ -0,0 +1,4 @@
+{
+    "files": ["main.py", "requirements.txt"],
+    "zip_path": null
+}

src/kasumi/cli/__init__.py

@@ -0,0 +1 @@
+kasumi

src/kasumi/cli/__templates/default/main.py

@@ -0,0 +1,13 @@
+import kasumi
+from kasumi import Kasumi
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+from src.sub import router
+
+app = Kasumi()
+app.include_gear(router)
+
+@app.get("/")
+async def root(request: Request):
+    return JSONResponse({"Hello": "World"})

src/kasumi/cli/__templates/default/manifest.json

@@ -0,0 +1,4 @@
+{
+    "files": ["main.py", "requirements.txt", {"dir": "src", "files": ["sub.py"]}],
+    "zip_path": null
+}

src/kasumi/cli/__templates/default/requirements.txt

@@ -0,0 +1 @@
+kasumi

src/kasumi/cli/__templates/with_gear/main.py

@@ -0,0 +1,6 @@
+import kasumi
+from kasumi import Gear
+from starlette.requests import Request
+from starlette.responses import JSONResponse
+
+router = Gear(prefix="/")

src/kasumi/cli/__templates/with_gear/manifest.json

@@ -1,2 +1,5 @@
 class AlreadyRegistedError(Exception):
+    pass
+
+class GearException(Exception):
     pass