astris 0.1.0__tar.gz

astris-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Astris contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

astris-0.1.0/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: astris
+Version: 0.1.0
+Summary: Minimal Python framework for building static websites with component-style APIs.
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.129.0
+Requires-Dist: uvicorn>=0.41.0
+Dynamic: license-file
+
+# Astris
+
+[![Tests](https://github.com/fmanzano/pystro/actions/workflows/tests.yml/badge.svg)](https://github.com/fmanzano/pystro/actions/workflows/tests.yml)
+
+Astris is a minimal Python framework for building static websites using component-style APIs.
+
+## Installation
+
+```bash
+pip install astris
+```
+
+## Quick start with CLI
+
+Create a new project scaffold:
+
+```bash
+astris new my_site
+cd my_site
+uv run python main.py
+```
+
+Build static files:
+
+```bash
+uv run python main.py build
+```
+
+## Basic usage
+
+```python
+from astris import AstrisApp
+from astris.lib import Body, H1, Html
+
+app = AstrisApp()
+
+
+@app.page("/")
+def home():
+	return Html(children=[
+		Body(children=[
+			H1(children=["Hello from Astris"]),
+		])
+	])
+
+
+if __name__ == "__main__":
+	app.run_dev()
+```
+
+## Development
+
+```bash
+uv sync --group dev
+uv pip install -e .
+uv run --group dev pytest
+```
+
+## Continuous Integration
+
+GitHub Actions runs tests on push and pull request events targeting main using Python 3.11, 3.12, and 3.13.
+The workflow is defined in `.github/workflows/tests.yml`.
+
+## Release checklist
+
+```bash
+make release-check
+```
+
+Equivalent manual commands:
+
+```bash
+uv sync --group dev
+uv run --group dev pytest
+uv run --group dev python -m build
+uv run --group dev twine check dist/*.whl dist/*.tar.gz
+```
+
+`example.py` in this repository is an internal framework demo and not the standard end-user workflow.

astris-0.1.0/README.md

@@ -0,0 +1,79 @@
+# Astris
+
+[![Tests](https://github.com/fmanzano/pystro/actions/workflows/tests.yml/badge.svg)](https://github.com/fmanzano/pystro/actions/workflows/tests.yml)
+
+Astris is a minimal Python framework for building static websites using component-style APIs.
+
+## Installation
+
+```bash
+pip install astris
+```
+
+## Quick start with CLI
+
+Create a new project scaffold:
+
+```bash
+astris new my_site
+cd my_site
+uv run python main.py
+```
+
+Build static files:
+
+```bash
+uv run python main.py build
+```
+
+## Basic usage
+
+```python
+from astris import AstrisApp
+from astris.lib import Body, H1, Html
+
+app = AstrisApp()
+
+
+@app.page("/")
+def home():
+	return Html(children=[
+		Body(children=[
+			H1(children=["Hello from Astris"]),
+		])
+	])
+
+
+if __name__ == "__main__":
+	app.run_dev()
+```
+
+## Development
+
+```bash
+uv sync --group dev
+uv pip install -e .
+uv run --group dev pytest
+```
+
+## Continuous Integration
+
+GitHub Actions runs tests on push and pull request events targeting main using Python 3.11, 3.12, and 3.13.
+The workflow is defined in `.github/workflows/tests.yml`.
+
+## Release checklist
+
+```bash
+make release-check
+```
+
+Equivalent manual commands:
+
+```bash
+uv sync --group dev
+uv run --group dev pytest
+uv run --group dev python -m build
+uv run --group dev twine check dist/*.whl dist/*.tar.gz
+```
+
+`example.py` in this repository is an internal framework demo and not the standard end-user workflow.

astris-0.1.0/astris/__init__.py

@@ -0,0 +1,4 @@
+from .app import AstrisApp
+from .component import Component, Element, Text
+
+__all__ = ["AstrisApp", "Component", "Element", "Text"]

astris-0.1.0/astris/app.py

@@ -0,0 +1,136 @@
+import os
+import re
+import sys
+from pathlib import Path
+from typing import Dict
+from urllib.parse import urlsplit, urlunsplit
+
+import uvicorn
+from fastapi import FastAPI
+from fastapi.responses import HTMLResponse
+
+from .component import Component
+
+
+class AstrisApp:
+    def __init__(self):
+        self.routes: Dict[str, Component] = {}
+        self._fastapi_app = FastAPI()
+
+    def page(self, path: str):
+        """Decorator to register a page (route)."""
+
+        def decorator(func):
+            component_tree = func()
+            self.routes[path] = component_tree
+
+            @self._fastapi_app.get(path, response_class=HTMLResponse)
+            async def serve_page():
+                return f"<!DOCTYPE html>{component_tree.render()}"
+
+            return func
+
+        return decorator
+
+    def _infer_import_string(self) -> str | None:
+        main_module = sys.modules.get("__main__")
+        main_file = getattr(main_module, "__file__", None)
+        if not main_file:
+            return None
+
+        module_name = Path(main_file).stem
+        return f"{module_name}:app._fastapi_app"
+
+    def run_dev(self, port=8000, reload=True):
+        """Start the development server."""
+        print(f"🚀 Dev server running at http://localhost:{port}")
+
+        if reload:
+            import_string = self._infer_import_string()
+            if import_string:
+                uvicorn.run(
+                    import_string,
+                    host="0.0.0.0",
+                    port=port,
+                    reload=True,
+                    reload_dirs=[os.getcwd()],
+                )
+                return
+
+            print("⚠️ Could not infer the main module, starting without hot reload.")
+
+        uvicorn.run(self._fastapi_app, host="0.0.0.0", port=port)
+
+    def _route_to_filename(self, route: str) -> str:
+        normalized = route if route.startswith("/") else f"/{route}"
+        if normalized == "/":
+            return "index.html"
+        return f"{normalized.strip('/')}.html"
+
+    def _resolve_route(self, path: str) -> str | None:
+        if path in self.routes:
+            return path
+
+        without_slash = path.rstrip("/")
+        if without_slash and without_slash in self.routes:
+            return without_slash
+
+        with_slash = f"{without_slash}/"
+        if with_slash in self.routes:
+            return with_slash
+
+        return None
+
+    def _rewrite_static_links(self, current_route: str, html: str) -> str:
+        current_file = self._route_to_filename(current_route)
+        current_dir = os.path.dirname(current_file) or "."
+
+        def replace_href(match: re.Match[str]) -> str:
+            quote = match.group("quote")
+            href_value = match.group("href")
+
+            split = urlsplit(href_value)
+            if split.scheme or split.netloc or split.path.startswith("//"):
+                return match.group(0)
+
+            resolved_route = self._resolve_route(split.path)
+            if not resolved_route:
+                return match.group(0)
+
+            target_file = self._route_to_filename(resolved_route)
+            relative_target = os.path.relpath(target_file, start=current_dir).replace(
+                os.sep, "/"
+            )
+            rebuilt_href = urlunsplit(
+                ("", "", relative_target, split.query, split.fragment)
+            )
+
+            return f"href={quote}{rebuilt_href}{quote}"
+
+        return re.sub(
+            r'href=(?P<quote>["\'])(?P<href>.*?)(?P=quote)',
+            replace_href,
+            html,
+        )
+
+    def build(self, output_dir="dist"):
+        """Generate static HTML files."""
+        print(f"📦 Building site into ./{output_dir}...")
+
+        if not os.path.exists(output_dir):
+            os.makedirs(output_dir)
+
+        for path, component in self.routes.items():
+            filename = self._route_to_filename(path)
+            filepath = os.path.join(output_dir, filename)
+            os.makedirs(os.path.dirname(filepath), exist_ok=True)
+
+            rendered_html = self._rewrite_static_links(path, component.render())
+
+            with open(filepath, "w", encoding="utf-8") as f:
+                f.write("<!DOCTYPE html>\n")
+                f.write(rendered_html)
+
+            print(f"  ✅ Generated: {filepath}")
+
+        print("✨ Build completed successfully.")

astris-0.1.0/astris/cli.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import argparse
+import re
+import sys
+from pathlib import Path
+
+MAIN_TEMPLATE = """import sys
+
+from astris import AstrisApp
+from astris.lib import Body, H1, Html
+
+app = AstrisApp()
+
+
+@app.page("/")
+def home():
+    return Html(children=[
+        Body(children=[
+            H1(children=["Hello, world from Astris!"]),
+        ])
+    ])
+
+
+if __name__ == "__main__":
+    if len(sys.argv) > 1 and sys.argv[1] == "build":
+        app.build()
+    else:
+        app.run_dev()
+"""
+
+README_TEMPLATE = """# {project_name}
+
+Project generated with `astris new`.
+
+## Run in development
+
+```bash
+uv run python main.py
+```
+
+## Build static site
+
+```bash
+uv run python main.py build
+```
+"""
+
+GITIGNORE_TEMPLATE = """__pycache__/
+*.pyc
+.venv/
+dist/
+"""
+
+REQUIREMENTS_TEMPLATE = "astris\n"
+
+
+class CliError(ValueError):
+    """CLI usage error for project generation."""
+
+
+def validate_project_name(project_name: str) -> None:
+    """Validate that the provided project name is filesystem friendly."""
+    pattern = r"^[A-Za-z][A-Za-z0-9_-]*$"
+    if not re.match(pattern, project_name):
+        raise CliError(
+            "Invalid project name. Use letters, numbers, '_' or '-', and start with a letter."
+        )
+
+
+def create_project(project_name: str, base_path: Path | None = None) -> Path:
+    """Create a minimal Astris project scaffold."""
+    validate_project_name(project_name)
+
+    root = (base_path or Path.cwd()) / project_name
+    if root.exists():
+        raise CliError(f"Target directory already exists: {root}")
+
+    root.mkdir(parents=True, exist_ok=False)
+
+    (root / "main.py").write_text(MAIN_TEMPLATE, encoding="utf-8")
+    (root / "README.md").write_text(
+        README_TEMPLATE.format(project_name=project_name), encoding="utf-8"
+    )
+    (root / ".gitignore").write_text(GITIGNORE_TEMPLATE, encoding="utf-8")
+    (root / "requirements.txt").write_text(REQUIREMENTS_TEMPLATE, encoding="utf-8")
+
+    return root
+
+
+def build_parser() -> argparse.ArgumentParser:
+    """Build the top-level Astris CLI parser."""
+    parser = argparse.ArgumentParser(
+        prog="astris",
+        description="Astris CLI",
+    )
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    new_parser = subparsers.add_parser("new", help="Create a new Astris project")
+    new_parser.add_argument("project_name", help="Name of the project directory")
+
+    return parser
+
+
+def main(argv: list[str] | None = None) -> int:
+    """CLI entrypoint."""
+    parser = build_parser()
+    args = parser.parse_args(argv)
+
+    if args.command == "new":
+        try:
+            created = create_project(args.project_name)
+        except CliError as error:
+            print(f"Error: {error}", file=sys.stderr)
+            return 2
+
+        print(f"Created Astris project at {created}")
+        print("Next steps:")
+        print(f"  cd {args.project_name}")
+        print("  uv run python main.py")
+        return 0
+
+    parser.print_help()
+    return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

astris-0.1.0/astris/component.py

@@ -0,0 +1,58 @@
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Union
+
+
+class Component(ABC):
+    """Base class for all UI elements (widgets)."""
+
+    @abstractmethod
+    def render(self) -> str:
+        pass
+
+    def __str__(self):
+        return self.render()
+
+
+class Text(Component):
+    """Render plain text without tags."""
+
+    def __init__(self, content: str):
+        self.content = content
+
+    def render(self) -> str:
+        return str(self.content)
+
+
+class Element(Component):
+    """
+    Represents a generic HTML tag.
+    Works like a Flutter-style container that accepts children.
+    """
+
+    tag: str = "div"
+
+    def __init__(
+        self, children: Optional[List[Union[Component, str]]] = None, **attributes
+    ):
+        self.children = children or []
+        self.attributes = self._process_attributes(attributes)
+
+    def _process_attributes(self, attrs: Dict) -> Dict:
+        processed = {}
+        for key, value in attrs.items():
+            normalized_key = key.replace("class_name", "class").replace("_", "-")
+            processed[normalized_key] = value
+        return processed
+
+    def render(self) -> str:
+        attrs_str = " ".join([f'{k}="{v}"' for k, v in self.attributes.items()])
+        attrs_str = f" {attrs_str}" if attrs_str else ""
+
+        children_html = ""
+        for child in self.children:
+            if isinstance(child, Component):
+                children_html += child.render()
+            else:
+                children_html += str(child)
+
+        return f"<{self.tag}{attrs_str}>{children_html}</{self.tag}>"

astris-0.1.0/astris/lib.py

@@ -0,0 +1,71 @@
+from .component import Element
+
+
+class Html(Element):
+    tag = "html"
+
+
+class Head(Element):
+    tag = "head"
+
+
+class Body(Element):
+    tag = "body"
+
+
+class Div(Element):
+    tag = "div"
+
+
+class Span(Element):
+    tag = "span"
+
+
+class H1(Element):
+    tag = "h1"
+
+
+class H2(Element):
+    tag = "h2"
+
+
+class P(Element):
+    tag = "p"
+
+
+class A(Element):
+    tag = "a"
+
+
+class Ul(Element):
+    tag = "ul"
+
+
+class Li(Element):
+    tag = "li"
+
+
+class Button(Element):
+    tag = "button"
+
+
+class Title(Element):
+    tag = "title"
+
+
+class Container(Div):
+    pass
+
+
+class Column(Div):
+    def __init__(self, children=None, **kwargs):
+        super().__init__(
+            children, style="display: flex; flex-direction: column;", **kwargs
+        )
+
+
+class Row(Div):
+    def __init__(self, children=None, **kwargs):
+        super().__init__(
+            children, style="display: flex; flex-direction: row;", **kwargs
+        )

astris-0.1.0/astris.egg-info/PKG-INFO

@@ -0,0 +1,99 @@
+Metadata-Version: 2.4
+Name: astris
+Version: 0.1.0
+Summary: Minimal Python framework for building static websites with component-style APIs.
+License-Expression: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastapi>=0.129.0
+Requires-Dist: uvicorn>=0.41.0
+Dynamic: license-file
+
+# Astris
+
+[![Tests](https://github.com/fmanzano/pystro/actions/workflows/tests.yml/badge.svg)](https://github.com/fmanzano/pystro/actions/workflows/tests.yml)
+
+Astris is a minimal Python framework for building static websites using component-style APIs.
+
+## Installation
+
+```bash
+pip install astris
+```
+
+## Quick start with CLI
+
+Create a new project scaffold:
+
+```bash
+astris new my_site
+cd my_site
+uv run python main.py
+```
+
+Build static files:
+
+```bash
+uv run python main.py build
+```
+
+## Basic usage
+
+```python
+from astris import AstrisApp
+from astris.lib import Body, H1, Html
+
+app = AstrisApp()
+
+
+@app.page("/")
+def home():
+	return Html(children=[
+		Body(children=[
+			H1(children=["Hello from Astris"]),
+		])
+	])
+
+
+if __name__ == "__main__":
+	app.run_dev()
+```
+
+## Development
+
+```bash
+uv sync --group dev
+uv pip install -e .
+uv run --group dev pytest
+```
+
+## Continuous Integration
+
+GitHub Actions runs tests on push and pull request events targeting main using Python 3.11, 3.12, and 3.13.
+The workflow is defined in `.github/workflows/tests.yml`.
+
+## Release checklist
+
+```bash
+make release-check
+```
+
+Equivalent manual commands:
+
+```bash
+uv sync --group dev
+uv run --group dev pytest
+uv run --group dev python -m build
+uv run --group dev twine check dist/*.whl dist/*.tar.gz
+```
+
+`example.py` in this repository is an internal framework demo and not the standard end-user workflow.

astris-0.1.0/astris.egg-info/SOURCES.txt

@@ -0,0 +1,20 @@
+LICENSE
+README.md
+pyproject.toml
+astris/__init__.py
+astris/app.py
+astris/cli.py
+astris/component.py
+astris/lib.py
+astris.egg-info/PKG-INFO
+astris.egg-info/SOURCES.txt
+astris.egg-info/dependency_links.txt
+astris.egg-info/entry_points.txt
+astris.egg-info/requires.txt
+astris.egg-info/top_level.txt
+tests/test_app_core.py
+tests/test_build.py
+tests/test_cli.py
+tests/test_component.py
+tests/test_lib.py
+tests/test_run_dev.py

astris-0.1.0/astris.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

astris-0.1.0/astris.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+astris = astris.cli:main

astris-0.1.0/astris.egg-info/requires.txt

@@ -0,0 +1,2 @@
+fastapi>=0.129.0
+uvicorn>=0.41.0

astris-0.1.0/astris.egg-info/top_level.txt

@@ -0,0 +1 @@
+astris

astris-0.1.0/pyproject.toml

@@ -0,0 +1,44 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "astris"
+version = "0.1.0"
+description = "Minimal Python framework for building static websites with component-style APIs."
+readme = "README.md"
+requires-python = ">=3.11"
+license = "MIT"
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Internet :: WWW/HTTP",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+dependencies = [
+    "fastapi>=0.129.0",
+    "uvicorn>=0.41.0",
+]
+
+[project.scripts]
+astris = "astris.cli:main"
+
+[dependency-groups]
+dev = [
+    "pytest>=8.4.2",
+    "pytest-cov>=7.0.0",
+    "build>=1.2.2.post1",
+    "twine>=6.2.0",
+]
+
+[tool.setuptools.packages.find]
+include = ["astris*"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+addopts = "-q"

astris-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

astris-0.1.0/tests/test_app_core.py

@@ -0,0 +1,36 @@
+import types
+
+from astris import AstrisApp, Text
+from astris.lib import Div
+
+
+def test_page_decorator_registers_route() -> None:
+    app = AstrisApp()
+
+    @app.page("/")
+    def home():
+        return Div(children=[Text("home")])
+
+    assert "/" in app.routes
+    assert app.routes["/"].render() == "<div>home</div>"
+
+
+def test_route_helpers() -> None:
+    app = AstrisApp()
+    app.routes = {"/": Div(), "/about": Div(), "/blog/": Div()}
+
+    assert app._route_to_filename("/") == "index.html"
+    assert app._route_to_filename("/about") == "about.html"
+    assert app._route_to_filename("docs/setup") == "docs/setup.html"
+
+    assert app._resolve_route("/about") == "/about"
+    assert app._resolve_route("/blog") == "/blog/"
+    assert app._resolve_route("/missing") is None
+
+
+def test_infer_import_string_from_main_module(monkeypatch) -> None:
+    app = AstrisApp()
+    fake_main = types.SimpleNamespace(__file__="/tmp/example.py")
+    monkeypatch.setitem(__import__("sys").modules, "__main__", fake_main)
+
+    assert app._infer_import_string() == "example:app._fastapi_app"

astris-0.1.0/tests/test_build.py

@@ -0,0 +1,71 @@
+from pathlib import Path
+
+from astris import AstrisApp, Text
+from astris.lib import A, Div
+
+
+def test_build_generates_static_files_and_doctype(tmp_path: Path) -> None:
+    app = AstrisApp()
+
+    @app.page("/")
+    def home():
+        return Div(
+            children=[
+                A(href="/about", children=["About"]),
+                Text(" "),
+                A(href="https://example.com", children=["Externo"]),
+            ]
+        )
+
+    @app.page("/about")
+    def about():
+        return Div(
+            children=[
+                A(href="/", children=["Inicio"]),
+                A(href="/about?tab=team#top", children=["Anchor"]),
+            ]
+        )
+
+    output_dir = tmp_path / "site"
+    app.build(str(output_dir))
+
+    index_file = output_dir / "index.html"
+    about_file = output_dir / "about.html"
+
+    assert index_file.exists()
+    assert about_file.exists()
+
+    index_html = index_file.read_text(encoding="utf-8")
+    about_html = about_file.read_text(encoding="utf-8")
+
+    assert index_html.startswith("<!DOCTYPE html>")
+    assert about_html.startswith("<!DOCTYPE html>")
+    assert 'href="about.html"' in index_html
+    assert 'href="https://example.com"' in index_html
+    assert 'href="index.html"' in about_html
+    assert 'href="about.html?tab=team#top"' in about_html
+
+
+def test_build_rewrites_relative_links_for_nested_routes(tmp_path: Path) -> None:
+    app = AstrisApp()
+
+    @app.page("/about")
+    def about():
+        return Div(children=[Text("About")])
+
+    @app.page("/docs/getting-started")
+    def docs():
+        return Div(
+            children=[
+                A(href="/about", children=["About"]),
+                A(href="/missing", children=["Missing"]),
+            ]
+        )
+
+    output_dir = tmp_path / "site"
+    app.build(str(output_dir))
+
+    docs_html = (output_dir / "docs/getting-started.html").read_text(encoding="utf-8")
+
+    assert 'href="../about.html"' in docs_html
+    assert 'href="/missing"' in docs_html

astris-0.1.0/tests/test_cli.py

@@ -0,0 +1,45 @@
+from pathlib import Path
+
+from astris import cli
+
+
+def test_create_project_generates_expected_files(tmp_path: Path) -> None:
+    project_path = cli.create_project("demo_site", base_path=tmp_path)
+
+    assert project_path == tmp_path / "demo_site"
+    assert (project_path / "main.py").exists()
+    assert (project_path / "README.md").exists()
+    assert (project_path / ".gitignore").exists()
+    assert (project_path / "requirements.txt").exists()
+
+    main_content = (project_path / "main.py").read_text(encoding="utf-8")
+    assert "app = AstrisApp()" in main_content
+    assert '@app.page("/")' in main_content
+
+
+def test_create_project_fails_if_target_exists(tmp_path: Path) -> None:
+    existing = tmp_path / "demo_site"
+    existing.mkdir()
+
+    try:
+        cli.create_project("demo_site", base_path=tmp_path)
+        assert False, "Expected CliError"
+    except cli.CliError as error:
+        assert "already exists" in str(error)
+
+
+def test_create_project_rejects_invalid_name(tmp_path: Path) -> None:
+    try:
+        cli.create_project("123-invalid", base_path=tmp_path)
+        assert False, "Expected CliError"
+    except cli.CliError as error:
+        assert "Invalid project name" in str(error)
+
+
+def test_main_new_command_returns_success(tmp_path: Path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    exit_code = cli.main(["new", "hello_app"])
+
+    assert exit_code == 0
+    assert (tmp_path / "hello_app" / "main.py").exists()

astris-0.1.0/tests/test_component.py

@@ -0,0 +1,25 @@
+from astris.component import Element, Text
+
+
+class Div(Element):
+    tag = "div"
+
+
+def test_text_render_and_str() -> None:
+    text = Text("hola")
+
+    assert text.render() == "hola"
+    assert str(text) == "hola"
+
+
+def test_element_transforms_html_attributes() -> None:
+    element = Div(class_name="hero", data_test_id="banner")
+
+    assert element.attributes["class"] == "hero"
+    assert element.attributes["data-test-id"] == "banner"
+
+
+def test_element_renders_children_components_and_strings() -> None:
+    element = Div(children=[Text("A"), "B", Div(children=["C"])])
+
+    assert element.render() == "<div>A B<div>C</div></div>".replace(" ", "")

astris-0.1.0/tests/test_lib.py

@@ -0,0 +1,24 @@
+from astris.lib import A, Column, Container, Head, Html, Row, Title
+
+
+def test_html_wrappers_render_expected_tags() -> None:
+    page = Html(
+        children=[
+            Head(children=[Title(children=["Demo"])]),
+            Container(children=[A(href="/", children=["Inicio"])]),
+        ]
+    )
+    html = page.render()
+
+    assert "<html>" in html
+    assert "<head>" in html
+    assert "<title>Demo</title>" in html
+    assert '<a href="/">Inicio</a>' in html
+
+
+def test_column_and_row_include_default_flex_style() -> None:
+    column = Column(children=["x"])
+    row = Row(children=["y"])
+
+    assert "flex-direction: column" in column.render()
+    assert "flex-direction: row" in row.render()

astris-0.1.0/tests/test_run_dev.py

@@ -0,0 +1,61 @@
+import os
+
+from astris import AstrisApp
+
+
+def test_run_dev_uses_reload_import_string_when_available(monkeypatch) -> None:
+    app = AstrisApp()
+    calls = []
+
+    monkeypatch.setattr(app, "_infer_import_string", lambda: "example:app._fastapi_app")
+
+    def fake_run(*args, **kwargs):
+        calls.append((args, kwargs))
+
+    monkeypatch.setattr("astris.app.uvicorn.run", fake_run)
+
+    app.run_dev(port=9001, reload=True)
+
+    assert len(calls) == 1
+    args, kwargs = calls[0]
+    assert args[0] == "example:app._fastapi_app"
+    assert kwargs["reload"] is True
+    assert kwargs["port"] == 9001
+    assert kwargs["reload_dirs"] == [os.getcwd()]
+
+
+def test_run_dev_falls_back_when_import_string_is_missing(monkeypatch) -> None:
+    app = AstrisApp()
+    calls = []
+
+    monkeypatch.setattr(app, "_infer_import_string", lambda: None)
+
+    def fake_run(*args, **kwargs):
+        calls.append((args, kwargs))
+
+    monkeypatch.setattr("astris.app.uvicorn.run", fake_run)
+
+    app.run_dev(port=9002, reload=True)
+
+    assert len(calls) == 1
+    args, kwargs = calls[0]
+    assert args[0] is app._fastapi_app
+    assert kwargs["port"] == 9002
+    assert "reload" not in kwargs
+
+
+def test_run_dev_without_reload_uses_fastapi_app(monkeypatch) -> None:
+    app = AstrisApp()
+    calls = []
+
+    def fake_run(*args, **kwargs):
+        calls.append((args, kwargs))
+
+    monkeypatch.setattr("astris.app.uvicorn.run", fake_run)
+
+    app.run_dev(port=9003, reload=False)
+
+    assert len(calls) == 1
+    args, kwargs = calls[0]
+    assert args[0] is app._fastapi_app
+    assert kwargs["port"] == 9003