FastAPI-fastkit 1.1.0__tar.gz → 1.1.2__tar.gz

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: FastAPI-fastkit
-Version: 1.1.0
+Version: 1.1.2
 Summary: Fast, easy-to-use starter kit for new users of Python and FastAPI
 Author-Email: bnbong <bbbong9@gmail.com>
 License: MIT

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/pyproject.toml

@@ -11,7 +11,7 @@ dependencies = [
 ]
 requires-python = ">=3.12"
 readme = "README.md"
-version = "1.1.0"
+version = "1.1.2"
 
 [project.license]
 text = "MIT"

fastapi_fastkit-1.1.2/src/fastapi_fastkit/__init__.py

@@ -0,0 +1 @@
+__version__ = 'v1.1.2'

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/src/fastapi_fastkit/backend/inspector.py

@@ -31,7 +31,9 @@ import yaml  # type: ignore
 from fastapi_fastkit.backend.main import (
     create_venv,
     find_template_core_modules,
+    inject_project_metadata,
     install_dependencies,
+    install_dependencies_with_manager,
 )
 from fastapi_fastkit.backend.transducer import copy_and_convert_template
 from fastapi_fastkit.core.settings import settings
@@ -61,6 +63,10 @@ class TemplateInspector:
         try:
             os.makedirs(self.temp_dir, exist_ok=True)
             copy_and_convert_template(str(self.template_path), self.temp_dir)
+
+            # Inject dummy metadata for inspection
+            self._inject_dummy_metadata()
+
             self._cleanup_needed = True
             self.template_config = self._load_template_config()
             debug_log(f"Created temporary directory at {self.temp_dir}", "debug")
@@ -112,6 +118,43 @@ class TemplateInspector:
             debug_log(f"Failed to load template configuration: {e}", "warning")
             return None
 
+    def _inject_dummy_metadata(self) -> None:
+        """Inject dummy metadata for template inspection."""
+        try:
+            # Use dummy metadata for inspection
+            dummy_metadata = {
+                "project_name": "test-template",
+                "author": "Template Inspector",
+                "author_email": "inspector@fastapi-fastkit.dev",
+                "description": "Test project for template inspection",
+            }
+
+            inject_project_metadata(
+                self.temp_dir,
+                dummy_metadata["project_name"],
+                dummy_metadata["author"],
+                dummy_metadata["author_email"],
+                dummy_metadata["description"],
+            )
+            debug_log("Injected dummy metadata for template inspection", "info")
+
+        except Exception as e:
+            debug_log(f"Failed to inject dummy metadata: {e}", "warning")
+            self.warnings.append(f"Failed to inject metadata: {str(e)}")
+
+    def _detect_package_manager(self) -> str:
+        """Detect the appropriate package manager for the template."""
+        # Check for pyproject.toml (modern Python packaging)
+        if os.path.exists(os.path.join(self.temp_dir, "pyproject.toml")):
+            return "uv"  # Use UV for pyproject.toml based projects
+
+        # Check for requirements.txt (traditional pip)
+        if os.path.exists(os.path.join(self.temp_dir, "requirements.txt")):
+            return "pip"
+
+        # Default to pip if no dependency file found
+        return "pip"
+
     def _check_docker_available(self) -> bool:
         """Check if Docker and Docker Compose are available."""
         try:
@@ -393,7 +436,21 @@ class TemplateInspector:
         try:
             # Create virtual environment for testing
             venv_path = create_venv(self.temp_dir)
-            install_dependencies(self.temp_dir, venv_path)
+
+            # Detect and use appropriate package manager
+            package_manager = self._detect_package_manager()
+            debug_log(f"Using package manager: {package_manager}", "info")
+
+            try:
+                install_dependencies_with_manager(
+                    self.temp_dir, venv_path, package_manager
+                )
+            except Exception as dep_error:
+                # Capture detailed dependency installation error
+                error_msg = f"Failed to install dependencies: {str(dep_error)}"
+                debug_log(f"Dependency installation failed: {dep_error}", "error")
+                self.errors.append(error_msg)
+                return False
 
             # Check if scripts/test.sh exists
             test_script_path = os.path.join(self.temp_dir, "scripts", "test.sh")
@@ -557,7 +614,21 @@ class TemplateInspector:
         try:
             # Create virtual environment for testing
             venv_path = create_venv(self.temp_dir)
-            install_dependencies(self.temp_dir, venv_path)
+
+            # Detect and use appropriate package manager
+            package_manager = self._detect_package_manager()
+            debug_log(f"Using package manager: {package_manager}", "info")
+
+            try:
+                install_dependencies_with_manager(
+                    self.temp_dir, venv_path, package_manager
+                )
+            except Exception as dep_error:
+                # Capture detailed dependency installation error
+                error_msg = f"Failed to install dependencies: {str(dep_error)}"
+                debug_log(f"Dependency installation failed: {dep_error}", "error")
+                self.errors.append(error_msg)
+                return False
 
             # Set up fallback environment (e.g., SQLite database)
             fallback_config = self.template_config["fallback_testing"]
@@ -683,6 +754,14 @@ class TemplateInspector:
                     # Check if all services are running
                     all_running = True
                     for service in services:
+                        # Ensure service is a dictionary before calling .get()
+                        if not isinstance(service, dict):
+                            debug_log(
+                                f"Service info is not a dictionary: {service}",
+                                "warning",
+                            )
+                            continue
+
                         if service.get("State") != "running":
                             all_running = False
                             debug_log(
@@ -738,6 +817,11 @@ class TemplateInspector:
             app_running = False
 
             for service in services:
+                # Ensure service is a dictionary before calling .get()
+                if not isinstance(service, dict):
+                    debug_log(f"Service info is not a dictionary: {service}", "warning")
+                    continue
+
                 service_name = service.get("Name", "")
                 service_state = service.get("State", "")
 

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/src/fastapi_fastkit/backend/main.py

@@ -7,10 +7,15 @@ import os
 import re
 from typing import Dict, List
 
+import click
+
 from fastapi_fastkit import console
 from fastapi_fastkit.backend.package_managers import PackageManagerFactory
-from fastapi_fastkit.backend.transducer import copy_and_convert_template_file
-from fastapi_fastkit.core.exceptions import BackendExceptions, TemplateExceptions
+from fastapi_fastkit.backend.transducer import (
+    copy_and_convert_template,
+    copy_and_convert_template_file,
+)
+from fastapi_fastkit.core.exceptions import BackendExceptions
 from fastapi_fastkit.core.settings import settings
 from fastapi_fastkit.utils.logging import debug_log, get_logger
 from fastapi_fastkit.utils.main import (
@@ -32,12 +37,12 @@ logger = get_logger(__name__)
 def find_template_core_modules(project_dir: str) -> Dict[str, str]:
     """
     Find core module files in the template project structure.
-    Returns a dictionary with paths to main.py, setup.py, and config files.
+    Returns a dictionary with paths to main.py, setup.py, pyproject.toml and config files.
 
     :param project_dir: Path to the project directory
     :return: Dictionary with paths to core modules
     """
-    core_modules = {"main": "", "setup": "", "config": ""}
+    core_modules = {"main": "", "setup": "", "pyproject": "", "config": ""}
     template_paths = settings.TEMPLATE_PATHS
 
     # Find main.py
@@ -54,6 +59,13 @@ def find_template_core_modules(project_dir: str) -> Dict[str, str]:
             core_modules["setup"] = full_path
             break
 
+    # Find pyproject.toml
+    for pyproject_path in template_paths["pyproject"]:
+        full_path = os.path.join(project_dir, pyproject_path)
+        if os.path.exists(full_path):
+            core_modules["pyproject"] = full_path
+            break
+
     # Find config file
     config_info = template_paths["config"]
     if isinstance(config_info, dict):
@@ -166,6 +178,13 @@ def inject_project_metadata(
             author_email,
             description,
         )
+        _process_pyproject_file(
+            core_modules.get("pyproject", ""),
+            project_name,
+            author,
+            author_email,
+            description,
+        )
         _process_config_file(core_modules.get("config", ""), project_name)
 
         print_success("Project metadata injected successfully")
@@ -245,6 +264,51 @@ def _process_config_file(config_py: str, project_name: str) -> None:
         raise BackendExceptions(f"Failed to process config file: {e}")
 
 
+def _process_pyproject_file(
+    pyproject_toml: str,
+    project_name: str,
+    author: str,
+    author_email: str,
+    description: str,
+) -> None:
+    """
+    Process pyproject.toml file and inject metadata.
+
+    :param pyproject_toml: Path to pyproject.toml file
+    :param project_name: Project name
+    :param author: Author name
+    :param author_email: Author email
+    :param description: Project description
+    """
+    if not pyproject_toml or not os.path.exists(pyproject_toml):
+        return
+
+    try:
+        with open(pyproject_toml, "r", encoding="utf-8") as f:
+            content = f.read()
+
+        # Replace placeholders
+        replacements = {
+            "<project_name>": project_name,
+            "<author>": author,
+            "<author_email>": author_email,
+            "<description>": description,
+        }
+
+        for placeholder, value in replacements.items():
+            content = content.replace(placeholder, value)
+
+        with open(pyproject_toml, "w", encoding="utf-8") as f:
+            f.write(content)
+
+        debug_log("Injected metadata into pyproject.toml", "info")
+        print_info("Injected metadata into pyproject.toml")
+
+    except (OSError, UnicodeDecodeError) as e:
+        debug_log(f"Error processing pyproject.toml: {e}", "error")
+        raise BackendExceptions(f"Failed to process pyproject.toml: {e}")
+
+
 def create_venv_with_manager(project_dir: str, manager_type: str = "pip") -> str:
     """
     Create a virtual environment using the specified package manager.
@@ -638,3 +702,68 @@ def add_new_route(project_dir: str, route_name: str) -> None:
         debug_log(f"Unexpected error while adding route {route_name}: {e}", "error")
         handle_exception(e, f"Error adding new route: {str(e)}")
         raise BackendExceptions(f"Failed to add new route: {str(e)}")
+
+
+# ------------------------------------------------------------
+# Create Project Folder Functions
+# ------------------------------------------------------------
+
+
+def ask_create_project_folder(project_name: str) -> bool:
+    """
+    Ask user whether to create a new project folder.
+
+    :param project_name: Name of the project
+    :return: True if user wants to create a folder, False otherwise
+    """
+    return click.confirm(
+        f"\nCreate a new project folder named '{project_name}'?\n"
+        f"Yes: Templates will be placed in './{project_name}/'\n"
+        f"No: Templates will be placed in current directory",
+        default=True,
+    )
+
+
+def deploy_template_with_folder_option(
+    target_template: str, user_local: str, project_name: str, create_folder: bool
+) -> tuple[str, str]:
+    """
+    Deploy template based on folder creation option.
+
+    :param target_template: Path to template directory
+    :param user_local: User's workspace directory
+    :param project_name: Name of the project
+    :param create_folder: Whether to create a new folder
+    :return: Tuple of (project_dir, deployment_message)
+    """
+    if create_folder:
+        project_dir = os.path.join(user_local, project_name)
+        deployment_message = f"FastAPI template project will deploy at '{user_local}' in folder '{project_name}'"
+        copy_and_convert_template(target_template, user_local, project_name)
+    else:
+        project_dir = user_local
+        deployment_message = (
+            f"FastAPI template project will deploy directly at '{user_local}'"
+        )
+        copy_and_convert_template(target_template, user_local, "")
+
+    click.echo(deployment_message)
+    return project_dir, deployment_message
+
+
+def get_deployment_success_message(
+    template: str, project_name: str, user_local: str, create_folder: bool
+) -> str:
+    """
+    Get appropriate success message based on deployment option.
+
+    :param template: Template name used
+    :param project_name: Name of the project
+    :param user_local: User's workspace directory
+    :param create_folder: Whether folder was created
+    :return: Success message string
+    """
+    if create_folder:
+        return f"FastAPI project '{project_name}' from '{template}' has been created and saved to {user_local}!"
+    else:
+        return f"FastAPI project '{project_name}' from '{template}' has been deployed directly to {user_local}!"

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/src/fastapi_fastkit/backend/package_managers/uv_manager.py

@@ -93,16 +93,27 @@ class UvManager(BasePackageManager):
                 print_error(f"pyproject.toml file not found at {pyproject_path}")
                 raise BackendExceptions("pyproject.toml file not found")
 
-            # Install dependencies using UV sync
+            # Install dependencies using UV sync (including dev dependencies)
+            cmd = ["uv", "sync", "--group", "dev"]
+            debug_log(
+                f"Running UV command: {' '.join(cmd)} in {self.project_dir}", "info"
+            )
+
             with console.status("[bold green]Installing dependencies with UV..."):
-                subprocess.run(
-                    ["uv", "sync"],
+                result = subprocess.run(
+                    cmd,
                     cwd=str(self.project_dir),
                     check=True,
                     capture_output=True,
                     text=True,
                 )
 
+                # Log UV output for debugging
+                if result.stdout:
+                    debug_log(f"UV stdout: {result.stdout}", "debug")
+                if result.stderr:
+                    debug_log(f"UV stderr: {result.stderr}", "debug")
+
             debug_log("Dependencies installed successfully with UV", "info")
             print_success("Dependencies installed successfully with UV")
 

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/src/fastapi_fastkit/cli.py

@@ -1,3 +1,4 @@
+# TODO : add a feature to automatically fix appropriate fastkit output console size
 # --------------------------------------------------------------------------
 # The Module defines main and core CLI operations for FastAPI-fastkit.
 #
@@ -17,14 +18,16 @@ from rich.panel import Panel
 
 from fastapi_fastkit.backend.main import (
     add_new_route,
+    ask_create_project_folder,
     create_venv_with_manager,
+    deploy_template_with_folder_option,
     find_template_core_modules,
     generate_dependency_file_with_manager,
+    get_deployment_success_message,
     inject_project_metadata,
     install_dependencies_with_manager,
     read_template_stack,
 )
-from fastapi_fastkit.backend.transducer import copy_and_convert_template
 from fastapi_fastkit.core.exceptions import CLIExceptions
 from fastapi_fastkit.core.settings import FastkitConfig
 from fastapi_fastkit.utils.logging import get_logger, setup_logging
@@ -191,6 +194,7 @@ def startdemo(
     """
     Create a new FastAPI project from templates and inject metadata.
     """
+    # TODO : add --template-name option to specify the template name
     settings = ctx.obj["settings"]
 
     template_dir = settings.FASTKIT_TEMPLATE_ROOT
@@ -258,25 +262,27 @@ def startdemo(
         print_error("Project creation aborted!")
         return
 
+    # Ask user whether to create a new project folder
+    create_project_folder = ask_create_project_folder(project_name)
+
     try:
         user_local = settings.USER_WORKSPACE
-        project_dir = os.path.join(user_local, project_name)
-
-        click.echo(f"FastAPI template project will deploy at '{user_local}'")
 
-        copy_and_convert_template(target_template, user_local, project_name)
+        project_dir, _ = deploy_template_with_folder_option(
+            target_template, user_local, project_name, create_project_folder
+        )
 
         inject_project_metadata(
             project_dir, project_name, author, author_email, description
         )
 
-        # Create virtual environment and install dependencies with selected package manager
         venv_path = create_venv_with_manager(project_dir, package_manager)
         install_dependencies_with_manager(project_dir, venv_path, package_manager)
 
-        print_success(
-            f"FastAPI project '{project_name}' from '{template}' has been created and saved to {user_local}!"
+        success_message = get_deployment_success_message(
+            template, project_name, user_local, create_project_folder
         )
+        print_success(success_message)
 
     except Exception as e:
         if settings.DEBUG_MODE:
@@ -323,8 +329,11 @@ def init(
 ) -> None:
     """
     Start a empty FastAPI project setup.
+
     This command will automatically create a new FastAPI project directory and a python virtual environment.
+
     Dependencies will be automatically installed based on the selected stack at venv.
+
     Project metadata will be injected to the project files.
     """
     settings = ctx.obj["settings"]
@@ -402,13 +411,15 @@ def init(
         print_error("Project creation aborted!")
         return
 
+    # Ask user whether to create a new project folder
+    create_project_folder = ask_create_project_folder(project_name)
+
     try:
         user_local = settings.USER_WORKSPACE
-        project_dir = os.path.join(user_local, project_name)
-
-        click.echo(f"FastAPI project will deploy at '{user_local}'")
 
-        copy_and_convert_template(target_template, user_local, project_name)
+        project_dir, _ = deploy_template_with_folder_option(
+            target_template, user_local, project_name, create_project_folder
+        )
 
         inject_project_metadata(
             project_dir, project_name, author, author_email, description
@@ -439,9 +450,10 @@ def init(
         venv_path = create_venv_with_manager(project_dir, package_manager)
         install_dependencies_with_manager(project_dir, venv_path, package_manager)
 
-        print_success(
-            f"FastAPI project '{project_name}' has been created successfully and saved to {user_local}!"
+        success_message = get_deployment_success_message(
+            template, project_name, user_local, create_project_folder
         )
+        print_success(success_message)
 
         print_info(
             "To start your project, run 'fastkit runserver' at newly created FastAPI project directory"
@@ -457,25 +469,43 @@ def init(
 
 
 @fastkit_cli.command()
-@click.argument("project_name")
 @click.argument("route_name")
+@click.argument("project_dir", default=".")
 @click.pass_context
-def addroute(ctx: Context, project_name: str, route_name: str) -> None:
+def addroute(ctx: Context, route_name: str, project_dir: str) -> None:
     """
     Add a new route to the FastAPI project.
+
+    Examples:\n
+        fastkit addroute user .          # Add 'user' route to current directory
+        fastkit addroute user my_project # Add 'user' route to 'my_project' in workspace
     """
     settings = ctx.obj["settings"]
-    user_local = settings.USER_WORKSPACE
-    project_dir = os.path.join(user_local, project_name)
+
+    if project_dir == ".":
+        actual_project_dir = os.getcwd()
+        project_name = os.path.basename(actual_project_dir)
+    else:
+        user_local = settings.USER_WORKSPACE
+        actual_project_dir = os.path.join(user_local, project_dir)
+        project_name = project_dir
 
     # Check if project exists
-    if not os.path.exists(project_dir):
-        print_error(f"Project '{project_name}' does not exist in '{user_local}'.")
+    if not os.path.exists(actual_project_dir):
+        if project_dir == ".":
+            print_error("Current directory is not a valid project directory.")
+        else:
+            print_error(
+                f"Project '{project_dir}' does not exist in '{settings.USER_WORKSPACE}'."
+            )
         return
 
     # Verify it's a fastkit project
-    if not is_fastkit_project(project_dir):
-        print_error(f"'{project_name}' is not a FastAPI-fastkit project.")
+    if not is_fastkit_project(actual_project_dir):
+        if project_dir == ".":
+            print_error("Current directory is not a FastAPI-fastkit project.")
+        else:
+            print_error(f"'{project_dir}' is not a FastAPI-fastkit project.")
         return
 
     # Validate route name
@@ -499,26 +529,34 @@ def addroute(ctx: Context, project_name: str, route_name: str) -> None:
             {
                 "Project": project_name,
                 "Route Name": route_name,
-                "Target Directory": project_dir,
+                "Target Directory": actual_project_dir,
             },
         )
         console.print(table)
 
-        # Confirm before proceeding
-        confirm = click.confirm(
-            f"\nDo you want to add route '{route_name}' to project '{project_name}'?",
-            default=True,
-        )
+        if project_dir == ".":
+            confirm_message = (
+                f"\nDo you want to add route '{route_name}' to the current project?"
+            )
+        else:
+            confirm_message = f"\nDo you want to add route '{route_name}' to project '{project_name}'?"
+
+        confirm = click.confirm(confirm_message, default=True)
         if not confirm:
             print_error("Operation cancelled!")
             return
 
         # Add the new route
-        add_new_route(project_dir, route_name)
+        add_new_route(actual_project_dir, route_name)
 
-        print_success(
-            f"Successfully added new route '{route_name}' to project `{project_name}`"
-        )
+        if project_dir == ".":
+            print_success(
+                f"Successfully added new route '{route_name}' to the current project!"
+            )
+        else:
+            print_success(
+                f"Successfully added new route '{route_name}' to project '{project_name}'!"
+            )
 
     except Exception as e:
         logger = get_logger()

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/src/fastapi_fastkit/core/settings.py

@@ -30,6 +30,9 @@ class FastkitConfig:
             "setup.py",
             "src/setup.py",
         ],
+        "pyproject": [
+            "pyproject.toml",
+        ],
         "config": {
             "files": ["settings.py", "config.py"],
             "paths": [

fastapi_fastkit-1.1.2/src/fastapi_fastkit/fastapi_project_template/fastapi-async-crud/pyproject.toml-tpl

@@ -0,0 +1,85 @@
+[project]
+name = "<project_name>"
+version = "0.1.0"
+description = "<description>"
+authors = [
+    {name = "<author>", email = "<author_email>"},
+]
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+dependencies = [
+    "fastapi>=0.115.8",
+    "uvicorn[standard]>=0.34.0",
+    "pydantic>=2.10.6",
+    "pydantic-settings>=2.7.1",
+    "SQLAlchemy>=2.0.38",
+    "python-dotenv>=1.0.1",
+    "aiofiles>=24.1.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=8.3.4",
+    "pytest-asyncio>=0.25.3",
+    "httpx>=0.28.1",
+    "black>=25.1.0",
+    "isort>=6.0.0",
+    "mypy>=1.15.0",
+    "PyYAML>=6.0.2",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8.3.4",
+    "pytest-asyncio>=0.25.3",
+    "httpx>=0.28.1",
+    "black>=25.1.0",
+    "isort>=6.0.0",
+    "mypy>=1.15.0",
+    "PyYAML>=6.0.2",
+]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+[tool.black]
+line-length = 88
+target-version = ["py39"]
+include = '\.pyi?$'
+exclude = '''
+/(
+    \.git
+  | \.venv
+  | \.mypy_cache
+  | \.pytest_cache
+  | __pycache__
+  | build
+  | dist
+)/
+'''
+
+[tool.isort]
+profile = "black"
+multi_line_output = 3
+line_length = 88
+known_first_party = ["src"]
+
+[tool.mypy]
+python_version = "3.9"
+strict = true
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]
+addopts = "-v --tb=short"
+asyncio_mode = "auto"

{fastapi_fastkit-1.1.0 → fastapi_fastkit-1.1.2}/src/fastapi_fastkit/fastapi_project_template/fastapi-async-crud/requirements.txt-tpl

@@ -33,4 +33,4 @@ uvicorn==0.34.0
 uvloop==0.21.0
 watchfiles==1.0.4
 websockets==15.0
-aiofiles>=23.2.1
+aiofiles>=24.1.0