Use the new-route command to create your first route
See the docs for more information.
30 | {% endblock %} 31 | {% endraw -%} 32 | 33 | 34 | """ 35 | ''' 36 | 37 | TEMPLATE_TEMPLATE = '''\ 38 | {{param_text}} 39 | """ 40 | {% raw %} 41 | {% extends 'index.py' %} 42 | {% block content %} 43 | {% endblock %} 44 | {% endraw %} 45 | """ 46 | ''' 47 | 48 | 49 | @click.group("cli") 50 | @click.pass_context 51 | def cli(ctx): 52 | """Dark Star - a web framework based on Starlette""" 53 | pass 54 | 55 | 56 | @cli.command("create-app") 57 | @click.argument("directory", type=click.Path()) 58 | @click.option("--htmx/--no-htmx", help="Include htmx script in index.py", default=False) 59 | def create_app(directory, htmx): 60 | path = Path(directory) 61 | 62 | routes_dir = path / "routes" 63 | print(f"Creating {routes_dir}") 64 | routes_dir.mkdir(exist_ok=True, parents=True) 65 | 66 | static_dir = path / "static" 67 | print(f"Creating {static_dir}") 68 | static_dir.mkdir(exist_ok=True, parents=True) 69 | 70 | index_path = path / "routes" / "index.py" 71 | if not index_path.exists(): 72 | print(f"Creating {index_path}") 73 | index_path.write_text(Template(INDEX_TEMPLATE).render(htmx=htmx)) 74 | app_file = path / "app.py" 75 | if not app_file.exists(): 76 | print(f"Creating {app_file}") 77 | app_file.write_text(Template(APP_TEMPLATE).render()) 78 | 79 | 80 | @cli.command("new-route") 81 | @click.argument("path", type=click.Path()) 82 | def new_route(path): 83 | 84 | route_path = Path("routes") / path.lstrip("/").rstrip("/") 85 | route_path = route_path.with_suffix(".py") 86 | if not route_path.exists(): 87 | print(f"Adding new route {route_path}") 88 | route_path.parent.mkdir(parents=True, exist_ok=True) 89 | *_, params = compile_path(str(route_path)) 90 | param_text = "\n".join( 91 | f'{key} = request.path_params["{key}"]' for key in params.keys() 92 | ).strip() 93 | route_path.write_text(Template(TEMPLATE_TEMPLATE).render(param_text=param_text)) 94 | 95 | 96 | def main(): 97 | cli(prog_name="cli") 98 | 99 | 100 | if __name__ == "__main__": 101 | main() 102 | -------------------------------------------------------------------------------- /src/darkstar/applications.py: -------------------------------------------------------------------------------- 1 | import ast 2 | from hashlib import md5 3 | from io import BytesIO 4 | from pathlib import Path 5 | import shlex 6 | from tokenize import COMMENT 7 | from tokenize import tokenize 8 | import typing 9 | 10 | from starlette.applications import Starlette 11 | from starlette.middleware import Middleware 12 | from starlette.requests import Request 13 | from starlette.responses import Response 14 | from starlette.routing import BaseRoute 15 | from starlette.routing import Mount 16 | from starlette.routing import Route 17 | from starlette.staticfiles import StaticFiles 18 | 19 | from .templating import Jinja2Templates 20 | 21 | 22 | dark_star_templates = None 23 | 24 | 25 | class FunctionAdder(ast.NodeTransformer): 26 | """Makes our bare files into functions""" 27 | 28 | def __init__(self, template_path, function_name, *args, **kwargs): 29 | super().__init__(*args, **kwargs) 30 | self.function_name = function_name 31 | self.template_path = template_path 32 | self.new_return = ast.parse( 33 | f"""return dark_star_templates.TemplateResponse("{self.template_path}", locals())""" 34 | ) 35 | 36 | def visit_Module(self, node): 37 | super().generic_visit(node) 38 | 39 | wrapper = ast.AsyncFunctionDef( 40 | name=self.function_name, 41 | decorator_list=[], 42 | args=ast.arguments( 43 | posonlyargs=[], 44 | kwonlyargs=[], 45 | defaults=[], 46 | kw_defaults=[], 47 | args=[ast.arg(arg="request")], 48 | ), 49 | ) 50 | wrapper.body = node.body 51 | wrapper.body.extend(self.new_return.body) 52 | node.body = [wrapper] 53 | return node 54 | 55 | 56 | def get_options(code): 57 | tokens = tokenize(BytesIO(code.strip().encode("utf-8")).readline) 58 | for toknum, tokval, (srow, scol), *_ in tokens: 59 | if srow > 1: 60 | return {} 61 | if toknum == COMMENT: 62 | _, *options = shlex.split(tokval) 63 | break 64 | route_options = {} 65 | if options: 66 | for option in options: 67 | key, _, value = option.partition("=") 68 | if key == "methods": 69 | route_options[key] = [x.strip() for x in value.split(",")] 70 | elif key == "name": 71 | route_options[key] = value 72 | return route_options 73 | 74 | 75 | class DarkStar(Starlette): 76 | def __init__( 77 | self, 78 | routes_path: typing.Union[str, Path] = "routes", 79 | debug: bool = False, 80 | routes: typing.Sequence[BaseRoute] = [], 81 | static_directory: str = "static", 82 | middleware: typing.Sequence[Middleware] = None, 83 | exception_handlers: typing.Mapping[ 84 | typing.Any, 85 | typing.Callable[ 86 | [Request, Exception], typing.Union[Response, typing.Awaitable[Response]] 87 | ], 88 | ] = None, 89 | on_startup: typing.Sequence[typing.Callable] = None, 90 | on_shutdown: typing.Sequence[typing.Callable] = None, 91 | lifespan: typing.Callable[["Starlette"], typing.AsyncContextManager] = None, 92 | ) -> None: 93 | 94 | global dark_star_templates 95 | dark_star_templates = Jinja2Templates(routes_path) 96 | 97 | self.template_env = dark_star_templates.env 98 | 99 | path_routes = self._collect_routes(routes_path) 100 | 101 | if not any( 102 | type(route) == Mount and type(route.app) == StaticFiles for route in routes 103 | ): 104 | routes.append(Mount("/static/", StaticFiles(directory=static_directory))) 105 | 106 | super().__init__( 107 | debug, 108 | path_routes + routes, 109 | middleware, 110 | exception_handlers, 111 | on_startup, 112 | on_shutdown, 113 | ) 114 | 115 | def _collect_routes(self, routes_path) -> typing.Sequence[BaseRoute]: 116 | routes = [] 117 | 118 | for path in Path(routes_path).rglob("*.py"): 119 | if path.is_file(): 120 | python = path.read_text() 121 | function_name = f"ds_{md5(str(path).encode()).hexdigest()}" 122 | 123 | modded_function = ast.fix_missing_locations( 124 | FunctionAdder(path.relative_to(routes_path), function_name).visit( 125 | ast.parse(python) 126 | ) 127 | ) 128 | 129 | exec(compile(modded_function, f"{path}", "exec"), globals()) 130 | 131 | route_options = get_options(python) 132 | 133 | if path.relative_to(routes_path) == Path("index.py"): 134 | if "name" not in route_options: 135 | route_options["name"] = "index" 136 | routes.append(Route("/", globals()[function_name], **route_options)) 137 | else: 138 | routes.append( 139 | Route( 140 | f"/{path.relative_to(routes_path).with_suffix('')}/", 141 | globals()[function_name], 142 | **route_options, 143 | ) 144 | ) 145 | 146 | return routes 147 | -------------------------------------------------------------------------------- /src/darkstar/templating.py: -------------------------------------------------------------------------------- 1 | import ast 2 | import os 3 | from os import PathLike 4 | from pathlib import Path 5 | import typing 6 | 7 | import jinja2 8 | from jinja2.environment import Environment 9 | from jinja2.exceptions import TemplateNotFound 10 | from jinja2.loaders import FileSystemLoader as JinjaFileSystemLoader 11 | from jinja2.loaders import split_template_path 12 | from jinja2.utils import open_if_exists 13 | from starlette.templating import Jinja2Templates as StarletteJinja2Templates 14 | 15 | # @contextfunction renamed to @pass_context in Jinja 3.0, to be removed in 3.1 16 | if hasattr(jinja2, "pass_context"): 17 | pass_context = jinja2.pass_context 18 | else: # pragma: nocover 19 | pass_context = jinja2.contextfunction 20 | 21 | 22 | class TemplateExtractor(ast.NodeVisitor): 23 | """Makes our bare files into functions""" 24 | 25 | def visit_Constant(self, node): 26 | super().generic_visit(node) 27 | 28 | self.value = node.value 29 | 30 | 31 | class FileSystemLoader(JinjaFileSystemLoader): 32 | def get_source( 33 | self, environment: Environment, template: str 34 | ) -> typing.Tuple[str, str, typing.Callable[[], bool]]: 35 | 36 | pieces = split_template_path(template) 37 | 38 | for searchpath in self.searchpath: 39 | filename = os.path.join(searchpath, *pieces) 40 | 41 | f = open_if_exists(filename) 42 | 43 | if f is None: 44 | continue 45 | try: 46 | contents = f.read().decode(self.encoding) 47 | finally: 48 | f.close() 49 | 50 | if Path(filename).suffix == ".py": 51 | extractor = TemplateExtractor() 52 | extractor.visit(ast.parse(contents)) 53 | contents = extractor.value 54 | 55 | mtime = os.path.getmtime(filename) 56 | 57 | def uptodate() -> bool: 58 | try: 59 | return os.path.getmtime(filename) == mtime 60 | except OSError: 61 | return False 62 | 63 | return contents, filename, uptodate 64 | raise TemplateNotFound(template) 65 | 66 | 67 | class Jinja2Templates(StarletteJinja2Templates): 68 | def _create_env( 69 | self, directory: typing.Union[str, PathLike], **env_options: typing.Any 70 | ) -> "jinja2.Environment": 71 | @pass_context 72 | def url_for(context: dict, name: str, **path_params: typing.Any) -> str: 73 | request = context["request"] 74 | return request.url_for(name, **path_params) 75 | 76 | loader = FileSystemLoader(directory) 77 | env_options.setdefault("loader", loader) 78 | env_options.setdefault("autoescape", True) 79 | 80 | env = jinja2.Environment(**env_options) 81 | env.globals["url_for"] = url_for 82 | return env 83 | -------------------------------------------------------------------------------- /test_ast.py: -------------------------------------------------------------------------------- 1 | import ast 2 | from io import BytesIO 3 | from shlex import split 4 | from tokenize import COMMENT 5 | from tokenize import tokenize 6 | 7 | from astpretty import pprint 8 | 9 | code1 = """ 10 | print(2) 11 | print(2) 12 | """ 13 | code2 = """ 14 | async def f(request): 15 | print(2) 16 | """ 17 | 18 | 19 | class NumberChanger(ast.NodeTransformer): 20 | """Changes all number literals to 42.""" 21 | 22 | def visit_Module(self, node): 23 | super().generic_visit(node) 24 | 25 | if isinstance(node, ast.Module): 26 | wrapper = ast.AsyncFunctionDef( 27 | name="do_request", 28 | decorator_list=[], 29 | args=ast.arguments( 30 | posonlyargs=[], 31 | kwonlyargs=[], 32 | defaults=[], 33 | kw_defaults=[], 34 | args=[ast.arg(arg="request")], 35 | ), 36 | ) 37 | wrapper.body = node.body 38 | node.body = [wrapper] 39 | return node 40 | if not isinstance(node, ast.Constant) or not isinstance(node.value, int): 41 | return node 42 | 43 | return ast.Constant(value=42) 44 | 45 | 46 | # pprint(ast.parse(code1)) 47 | # pprint(ast.parse(code2)) 48 | # pprint(a) 49 | modded1 = ast.fix_missing_locations(NumberChanger().visit(ast.parse(code1))) 50 | # pprint(modded1) 51 | modded2 = ast.parse(code2) 52 | # pprint(modded2) 53 | # print(modded1 == modded2) 54 | # print("--------------") 55 | # print(ast.unparse(modded1)) 56 | # print(ast.unparse(modded2)) 57 | 58 | # pprint( 59 | # ast.parse( 60 | # """ 61 | # return dark_star_templates.TemplateResponse("{template_path}", locals()) 62 | # """ 63 | # ) 64 | # ) 65 | # code = ''' 66 | # print('') 67 | # """adfa 68 | # fadf 69 | # a 70 | # fadf 71 | # ad 72 | # """ 73 | # ''' 74 | # pprint(ast.parse(code)) 75 | 76 | code = """ 77 | 78 | 79 | # methods="GET, POST" name="this is my name" 80 | 81 | 82 | r = request 83 | """ 84 | g = tokenize(BytesIO(code.strip().encode("utf-8")).readline) 85 | 86 | 87 | for toknum, tokval, (srow, scol), *_ in g: 88 | if toknum == COMMENT: 89 | print(tokval, srow) 90 | for s in split(tokval): 91 | print(s) 92 | 93 | pprint(ast.parse(code)) 94 | --------------------------------------------------------------------------------