flask-commands 0.1.0__py3-none-any.whl

flask_commands/__init__.py

@@ -0,0 +1 @@
+from flask_commands.cli import cli

flask_commands/cli.py

@@ -0,0 +1,12 @@
+import click
+from flask_commands.commands.new import new
+from flask_commands.commands.view import make_view
+
+@click.group()
+def cli() -> None:
+    """Flask command line tools that will help you build a flask application with blueprints quickly."""
+    pass # pragma: no cover
+
+# Add commands to the CLI
+cli.add_command(new)
+cli.add_command(make_view)

flask_commands/commands/new.py

@@ -0,0 +1,60 @@
+import os
+import click
+import shutil
+from flask_commands.utils.venv import create_venv
+from flask_commands.utils.files import copy_templates
+from flask_commands.utils.css import install_tailwind
+from flask_commands.utils.databases import install_sqlitedb
+
+@click.command()
+@click.argument("project_name")
+@click.option("--db/--no-db", default=None, help="Include a database with your project")
+def new(project_name, db):
+    """Create a new Flask project"""
+    project_path = os.path.abspath(project_name)
+    project_started = False
+    if os.path.exists(project_path):
+        click.secho(f"💣 Error: Folder Already Exists.", fg="red", bold=True)
+        click.secho(f"    - Folder '{project_name}' already exists in this directory", fg="red")
+        click.secho(f"    - Please choose a different project name or change to a new directory", fg="red")
+        return
+    try:
+        project_started = True
+        include_db = db if db is not None else click.confirm("Include a Sqlite Database?", default=True)
+        os.makedirs(project_path)
+
+        # Create a Virtual Enviroment and install dependancies and
+        # generate a requirments file
+        packages = ["Flask", "python-dotenv"]
+        if include_db:
+            packages.extend(["Flask-Login", "Flask-Migrate", "Flask-SQLAlchemy"])
+        create_venv(
+            project_path,
+            packages=packages,
+            freeze_requirements=True)
+
+        copy_templates(
+            project_path,
+            include_db=include_db,
+            replacements={"project_name": project_name, "project_path": project_path})
+
+        # Make run.sh executable
+        os.chmod(os.path.join(project_path, "run.sh"), 0o755)
+
+        install_tailwind(project_path)
+
+        if include_db:
+            install_sqlitedb(project_path)
+
+        click.secho(
+            f"{project_name.title()} is ready!!! Run the following:",
+            bold=True, underline=True)
+
+
+        click.secho(f"cd {project_name}", fg="cyan")
+        click.secho("./run.sh", fg="cyan")
+    except Exception as exception:
+        if project_started and os.path.exists(project_name):
+            shutil.rmtree(project_name, ignore_errors=True)
+        click.secho("💣 Error: Project Creation Failed 😤", bold=True, fg="red")
+        raise click.ClickException(f"exception:\n{exception}") from exception

flask_commands/commands/view.py

@@ -0,0 +1,171 @@
+import os
+import click
+
+from flask_commands.utils.controllers import (
+    controller_add_method,
+    controller_infer_name_from,
+    controller_make_file
+)
+from flask_commands.utils.models import (
+    model_infer_name_from,
+    model_make_file
+)
+from flask_commands.utils.naming import camel_to_snake
+from flask_commands.utils.routes import (
+    route_add_method,
+    route_infer_name_from,
+    route_make_directory_and_register_blueprint,
+    generate_route_folder_path_and_blueprint_name
+)
+
+from flask_commands.utils.scaffold import split_dotted_path
+
+from flask_commands.utils.views import view_make_file
+
+
+@click.command(name="make:view")
+@click.argument("dotted_path_with_name")
+@click.option("--controller", "controller_name", default=None,
+              help="Optional controller class name (example PostController).")
+@click.option("-c", "--generate-controller", is_flag=True,
+              help="Optional controller flag to generate an inferred controller from the dotted path name.")
+@click.option("--route", "route_name", default=None,
+              help="Optional route class name (example /posts).")
+@click.option("-r", "--generate-route", is_flag=True,
+              help="Optional route flag to generate an inferred route from the dotted path name.")
+@click.option("--model", "model_name", default=None,
+              help="Optional model name (example Post which makes the database table 'posts').")
+@click.option("-m", "--generate-model", is_flag=True,
+              help="Optional model flag to generate an inferred model from the dotted path name.")
+def make_view(
+    dotted_path_with_name: str,
+    controller_name: str | None,
+    generate_controller: bool,
+    route_name: str | None,
+    generate_route: bool,
+    model_name: str | None,
+    generate_model: bool) -> None:
+    """
+    \b
+    Create a template view file under app/templates/<folder>/<name>.html.
+    You can also optionally connect this view to a controller, route, and model.
+    \b
+    ─── Understanding DOTTED_PATH_WITH_NAME ───
+    The dotted path defines the folder and file name:
+        <folder>.<name> → app/templates/<folder>/<name>.html
+        Example: posts.index → app/templates/posts/index.html
+    \b
+    You can also nest folders for relationships:
+        admin.users.index → app/templates/admin/users/index.html
+        posts.images.index → app/templates/posts/images/index.html
+    \b
+    ─── Simple Component Views ───
+    For standalone components like a button:
+        flask make:view button
+    \b
+    ─── CRUD Views ───
+    For RESTful actions (index, show, create, store, edit, update, destroy/delete):
+    Initial CRUD setup (controller, route, and model):
+        flask make:view posts.index -crm
+        flask make:view posts.index --controller PostController --route /posts --model Post
+    \b
+    Additional CRUD actions (e.g., show):
+        flask make:view posts.show -cr
+        flask make:view posts.show --controller PostController --route /posts/<int:post_id>
+    \b
+    ─── Flags ───
+    Optional flags can be combined as seen above:
+        -c / --generate-controller    generate inferred controller
+        -r / --generate-route         generate inferred route
+        -m / --generate-model         generate inferred model
+    \b
+    If you prefer explicit control:
+        --controller CONTROLLER_NAME  set a specific controller
+        --route ROUTE_NAME            set a specific route
+        --model MODEL_NAME            set a specific model
+    """
+    relative_path, action = split_dotted_path(dotted_path_with_name)
+
+    # Infer controller name if not provided
+    if generate_controller and controller_name is None:
+        if relative_path != '':
+            controller_name = controller_infer_name_from(relative_path)
+            click.secho(f"💡 Info: Inferred controller name as {click.style(controller_name, bold=True)}", fg="cyan")
+        else:
+            click.secho(f"⚠️  Warning: Could not infer the controller name "
+                       f"from {dotted_path_with_name}", fg="yellow", bold=True)
+
+    # Infer route name if not provided
+    if generate_route and route_name is None:
+        route_name = route_infer_name_from(dotted_path_with_name)
+        click.secho("💡 Info: Inferred route name as "
+                   f"{click.style(route_name, bold=True)}", fg="cyan")
+
+    # Infer model name if not provided
+    if generate_model and model_name is None:
+        model_name = model_infer_name_from(relative_path, dotted_path_with_name)
+        click.secho(f"💡 Info: Inferred model name as "
+                   f"{click.style(model_name, bold=True)}", fg="cyan")
+
+    click.echo("\n")
+
+    relative_view_file_path = os.path.join(relative_path, f"{action}.html")
+    destination_file_path = \
+        os.path.join("app", "templates", relative_view_file_path)
+
+    is_successful, message = view_make_file(destination_file_path)
+    click.echo(message)
+
+    # If a controller_name was provided or inferred
+    if controller_name:
+        controller_file_path = \
+            os.path.join(
+                "app",
+                "controllers",
+                f"{camel_to_snake(controller_name)}.py")
+
+        # if controller exist just add the method
+        if os.path.exists(controller_file_path):
+            is_successful, message = controller_add_method(
+                controller_name, action, relative_view_file_path, route_name)
+        # else create the controller and the method
+        else:
+            is_successful, message = controller_make_file(
+                controller_name, action, relative_view_file_path, route_name)
+        click.echo(message)
+
+    # If a controller_name was provided or inferred
+    if route_name:
+        route_folder_path, blueprint_name = \
+            generate_route_folder_path_and_blueprint_name(
+                dotted_path_with_name, relative_path)
+        try:
+            if os.path.exists(route_folder_path):
+                is_successful, message = \
+                    route_add_method(
+                        relative_path,      # this is everything before the last part of dotted_path_with_name replacing . with /
+                        action,             # in CRUD this is index, create, update, show... else this is just the last part of dotted_path_with_name
+                        route_folder_path,  # this is app/routes/{relative_path} or app/routes/main if relative path is ''
+                        blueprint_name,     # posts or mains or posts_comments
+                        route_name,         # this is the url path like /posts/<int:post_id> or /admin/posts/comments
+                        controller_name)    # contoller_name is like post_controller
+            else:
+                is_successful, message = \
+                    route_make_directory_and_register_blueprint(
+                        # relative_path,      # this is everything before the last part of dotted_path_with_name replacing . with /
+                        action,             # in CRUD this is index, create, update, show... else this is just the last part of dotted_path_with_name
+                        route_folder_path,  # this is app/routes/{relative_path} or app/routes/main if relative path is ''
+                        blueprint_name,     # posts or mains or posts_comments
+                        route_name,         # this is the url path like /posts/<int:post_id> or /admin/posts/comments
+                        controller_name)    # contoller_name is like post_controller
+            click.echo(message)
+        except Exception as exception:
+            click.secho(f"💣 Error:\n {exception}", fg="red")
+
+    # If a model_name was provided or inferred
+    if model_name:
+        model_init_path = os.path.join("app", "models", "__init__.py")
+        model_file_path = os.path.join("app", "models", f"{model_name.lower()}.py")
+        is_successful, message = model_make_file(
+            model_name, model_init_path, model_file_path)
+        click.echo(message)

flask_commands/project/.env

@@ -0,0 +1,6 @@
+SECRET_KEY=PUT_SOMETHING_SECRET_HERE
+FLASK_APP=run.py
+FLASK_CONFIG=development
+APP_NAME=project_name
+SQLALCHEMY_DEVELOPMENT_DATABASE_URI=sqlite:///project_name_dev.db
+SQLALCHEMY_PRODUCTION_DATABASE_URI=mysql+pymysql://username:password@localhost:3306/project_name_prod

flask_commands/project/.env.example

@@ -0,0 +1,6 @@
+SECRET_KEY=
+FLASK_APP=
+FLASK_CONFIG=
+APP_NAME=
+SQLALCHEMY_DEVELOPMENT_DATABASE_URI=
+SQLALCHEMY_PRODUCTION_DATABASE_URI=

flask_commands/project/app/__init__.py

@@ -0,0 +1,31 @@
+from config import config
+from flask import Flask
+from flask_login import LoginManager
+from flask_migrate import Migrate
+from flask_sqlalchemy import SQLAlchemy
+
+# Logging a user's authentication state handler
+login_manager = LoginManager()
+
+# ORM Database handler
+db = SQLAlchemy()
+migrate = Migrate()
+
+def create_app(config_name) -> Flask:
+    """Creates a Flask application Instance."""
+    app = Flask(__name__)
+
+    # apply configuration
+    app.config.from_object(config[config_name])
+
+    # initialize extensions: order matters
+    login_manager.init_app(app)
+    db.init_app(app)
+    migrate.init_app(app, db)
+
+    from app import models
+
+    from app.routes.mains import bp as mains_blueprint
+    app.register_blueprint(mains_blueprint)
+
+    return app

flask_commands/project/app/controllers/__init__.py

@@ -0,0 +1 @@
+from .main_controller import MainController

flask_commands/project/app/controllers/main_controller.py

@@ -0,0 +1,6 @@
+from flask import render_template
+
+class MainController(object):
+    @staticmethod
+    def index() -> str:
+        return render_template('mains/index.html')

flask_commands/project/app/models/__init__.py

@@ -0,0 +1 @@
+from .user import User

flask_commands/project/app/models/user.py

@@ -0,0 +1,51 @@
+from app import db, login_manager
+from flask_login import UserMixin
+from werkzeug.security import generate_password_hash, check_password_hash
+from datetime import datetime, timezone
+
+class User(UserMixin, db.Model):
+    __tablename__ = 'users'
+    # Columns
+    id = db.Column(db.Integer, primary_key=True)
+    username = db.Column(db.String(64), index=True,
+                         unique=True, nullable=False)
+    password_hash = db.Column(db.String(256), nullable=True)
+    created_at = db.Column(db.DateTime(timezone=True),
+                           index=True,
+                           default=lambda: datetime.now(timezone.utc))
+    updated_at = db.Column(db.DateTime(timezone=True),
+                           default=lambda: datetime.now(timezone.utc),
+                           onupdate=lambda: datetime.now(timezone.utc))
+
+    @property
+    def password(self):
+        """Throw an error when trying to access password attribute"""
+        raise AttributeError('password is not a readable attribute')
+
+    @password.setter
+    def password(self, password):
+        """Hash and set password"""
+        self.password_hash = generate_password_hash(password)
+
+    def verify_password(self, password):
+        """Returns true or false by verifing a given password"""
+        return check_password_hash(self.password_hash, password)
+
+    def store_in_database(self):
+        db.session.add(self)
+        db.session.commit()
+
+    def delete_from_database(self):
+        db.session.delete(self)
+        db.session.commit()
+
+    def __repr__(self):
+        """Model representation for code debugging"""
+        return f'<User id:{self.id} username:{self.username}>'
+
+
+@login_manager.user_loader
+def load_user(user_id):
+    """Load the user from the database, given the id stored
+    in the session"""
+    return User.query.get(int(user_id))

flask_commands/project/app/routes/mains/__init__.py

@@ -0,0 +1,5 @@
+from flask import Blueprint
+
+bp = Blueprint('mains', __name__)
+
+from app.routes.mains import routes

flask_commands/project/app/routes/mains/routes.py

@@ -0,0 +1,6 @@
+from app.controllers import MainController
+from app.routes.mains import bp
+
+@bp.route('/', methods=['GET'])
+def index():
+    return MainController.index()

flask_commands/project/app/static/src/input.css

@@ -0,0 +1 @@
+@import 'tailwindcss';

flask_commands/project/app/templates/mains/index.html

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Document</title>
+    {%- block styles %}
+        <link rel="stylesheet" href="{{ url_for('static', filename='tailwind.min.css', v=time.time()) }}">
+    {%- endblock styles %}
+</head>
+<body>
+    Hello World
+</body>
+</html>

flask_commands/project/config/__init__.py

@@ -0,0 +1,8 @@
+from .base_config import BaseConfig
+from .development_config import DevelopmentConfig
+from .production_config import ProductionConfig
+
+config = {
+    'development': DevelopmentConfig,
+    'production': ProductionConfig
+}

flask_commands/project/config/base_config.py

@@ -0,0 +1,12 @@
+import os
+from datetime import timedelta
+from dotenv import load_dotenv
+
+# Import Environment variables
+
+load_dotenv()  # reads variables from a .env file and sets them in os.environ
+
+class BaseConfig():
+    FLASK_CONFIG = os.environ.get('FLASK_CONFIG')
+    SECRET_KEY = os.environ.get('SECRET_KEY')
+    APP_NAME = os.environ.get('APP_NAME')

flask_commands/project/config/development_config.py

@@ -0,0 +1,8 @@
+import os
+from .base_config import BaseConfig
+
+
+class DevelopmentConfig(BaseConfig):
+    # MySQL DataBase Configuration
+    SQLALCHEMY_RECORD_QUERIES = True
+    SQLALCHEMY_DATABASE_URI = os.environ.get('SQLALCHEMY_DEVELOPMENT_DATABASE_URI')

flask_commands/project/config/production_config.py

@@ -0,0 +1,7 @@
+import os
+from .base_config import BaseConfig
+
+
+class ProductionConfig(BaseConfig):
+    # MySQL DataBase Configuration
+    SQLALCHEMY_DATABASE_URI = os.environ.get('SQLALCHEMY_PRODUCTION_DATABASE_URI')

flask_commands/project/run.py

@@ -0,0 +1,62 @@
+import os
+import time
+import logging
+from logging.handlers import SMTPHandler, RotatingFileHandler
+from app import create_app
+
+app = create_app(os.getenv('FLASK_CONFIG') or 'development')
+
+# These are global variable for your jinja2 templates
+@app.context_processor
+def inject_globals():
+    return {
+        'time': time}
+
+with app.app_context():
+    if not os.path.exists('logs'):
+        os.makedirs('logs', exist_ok=True)
+
+    max_bytes = 10 * 1024 * 1024 # 10 MB
+    backup_count = 10 # this will create 10 files .log.1 .log.2 .log.3 ...
+
+    # Logging levels to: NOTSET, DEBUG, INFO, WARNING, ERROR, CRITICAL
+
+    file_handler = RotatingFileHandler(
+        f"logs/{app.config['APP_NAME']}-{app.config['FLASK_CONFIG']}.log",
+        maxBytes=max_bytes,
+        backupCount=backup_count)
+    file_handler.setFormatter(logging.Formatter(
+        '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
+    if file_handler not in app.logger.handlers:
+        app.logger.addHandler(file_handler)
+
+    # SQL log file (separate from app logs)
+    sql_file_handler = RotatingFileHandler(
+        f"logs/sql-{app.config['FLASK_CONFIG']}.log",
+        maxBytes=max_bytes,
+        backupCount=backup_count)
+    sql_file_handler.setFormatter(logging.Formatter(
+        '%(asctime)s %(levelname)s: %(message)s [in %(pathname)s:%(lineno)d]'))
+    sqlalchemy_logger = logging.getLogger('sqlalchemy.engine')
+    sqlalchemy_logger.propagate = False
+    if sql_file_handler not in sqlalchemy_logger.handlers:
+        sqlalchemy_logger.addHandler(sql_file_handler)
+
+    if app.config['FLASK_CONFIG'] == 'development':
+        # this sets what the application will emit defaults to WARNING
+        app.logger.setLevel(logging.DEBUG)
+        sqlalchemy_logger.setLevel(logging.INFO)
+
+        # this sets what is writting to the logs
+        file_handler.setLevel(logging.DEBUG)
+        sql_file_handler.setLevel(logging.INFO)
+
+
+    if app.config['FLASK_CONFIG'] == 'production':
+        app.logger.setLevel(logging.INFO)
+        sqlalchemy_logger.setLevel(logging.WARNING)
+
+        file_handler.setLevel(logging.INFO)
+        sql_file_handler.setLevel(logging.WARNING)
+
+    app.logger.info(f"{app.config['APP_NAME']} started up in {app.config['FLASK_CONFIG']} mode")

flask_commands/project/run.sh

@@ -0,0 +1,64 @@
+# The main Terminal will eventually run the Hot Reloading
+
+# Start Up Shell
+osascript -e 'tell application "System Events" to tell process "Terminal" to keystroke "t" using command down'
+osascript -e 'tell application "Terminal" to do script "cd project_path && source venv/bin/activate" in front window'
+osascript -e 'tell application "Terminal" to do script "flask shell" in front window'
+
+# Start Up Flask Server
+osascript -e 'tell application "System Events" to tell process "Terminal" to keystroke "t" using command down'
+osascript -e 'tell application "Terminal" to do script "cd project_path && source venv/bin/activate" in front window'
+osascript -e 'tell application "Terminal" to do script "flask run --debug" in front window'
+
+# Building your tailwind.css file
+osascript -e 'tell application "System Events" to tell process "Terminal" to keystroke "t" using command down'
+osascript -e 'tell application "Terminal" to do script "cd project_path && npm run watch:css" in front window'
+
+# Building your tailwind.min.css file
+osascript -e 'tell application "System Events" to tell process "Terminal" to keystroke "t" using command down'
+osascript -e 'tell application "Terminal" to do script "cd project_path && npm run build:css" in front window'
+
+# Open up VS code Text
+osascript -e 'tell application "System Events" to tell process "Terminal" to keystroke "t" using command down'
+osascript -e 'tell application "Terminal" to do script "cd project_path && code ." in front window'
+
+sleep 5
+
+# Open Safari and navigate to http://127.0.0.1:5000
+open -a "Safari" "http://127.0.0.1:5000"
+
+
+#!/bin/bash
+
+# Define the folder to watch
+WATCH_FOLDER_TEMPLATES="$(pwd)/app/templates"
+WATCH_FOLDER_CONTROLLER="$(pwd)/app/controllers"
+WATCH_FOLDER_FORMS="$(pwd)/app/forms"
+WATCH_FOLDER_MODELS="$(pwd)/app/models"
+WATCH_FOLDER_ROUTES="$(pwd)/app/routes"
+
+# Function to refresh Chrome
+refresh_safari() {
+    osascript <<EOF
+tell application "Safari"
+    repeat with w in windows
+        repeat with t in tabs of w
+            if (URL of t contains "http://127.0.0.1:5000/") then
+                tell t to do JavaScript "window.location.reload();"
+            end if
+        end repeat
+    end repeat
+end tell
+EOF
+}
+
+
+# Watch for file changes in the folder and its subfolders
+fswatch -0 "$WATCH_FOLDER_TEMPLATES" "$WATCH_FOLDER_CONTROLLER" "$WATCH_FOLDER_FORMS" "$WATCH_FOLDER_MODELS" "$WATCH_FOLDER_ROUTES" | while read -d "" event
+
+do
+    echo "Change detected: $event"
+
+    # Call the function to refresh Chrome
+    refresh_safari
+done

flask_commands/utils/__init__.py

@@ -0,0 +1 @@
+# intentionally empty