flask-commands 0.1.0__tar.gz

flask_commands-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Drew Butcher
+
+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.

flask_commands-0.1.0/PKG-INFO

@@ -0,0 +1,80 @@
+Metadata-Version: 2.4
+Name: flask-commands
+Version: 0.1.0
+Summary: A set of command line tools that help you scaffold out your flask application quickly.
+License: MIT
+License-File: LICENSE
+Author: Drew Butcher
+Author-email: drewlbutcher@gmail.com
+Requires-Python: >=3.10
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: click (>=8.3.1,<9.0.0)
+Description-Content-Type: text/markdown
+
+# flask-commands
+
+Local-first CLI that scaffolds a Flask project (venv, dotenv, Tailwind build scripts, blueprints, optional SQLite) and can keep generating views, routes, controllers, and models for you.
+
+## Install
+- Python 3.10+
+- Optional: `npm` if you want Tailwind auto-installed; the tool will skip Tailwind if `npm` is missing.
+- `pip install Flask-Commands`
+
+> The published console script is currently `flask`. If you have a clash with Flask’s own CLI, run with `python -m flask_commands.cli ...` or rename the script to `flask-commands` in `pyproject.toml`.
+
+## Commands at a glance
+- `flask new <project_name> [--db/--no-db]` — bootstrap a new project in a sibling folder, create a venv, install deps, copy the template, wire Tailwind, and optionally initialize SQLite + migrations.
+- `flask make:view <dotted_path_with_name> [options]` — create a view under `app/templates/` and optionally add a controller method, route/blueprint, and model.
+
+## Creating a project: `flask new`
+What happens:
+- Creates `<project_name>/` and a virtual environment under `venv/`.
+- Installs Python deps: always `Flask` + `python-dotenv`; adds `Flask-Login`, `Flask-Migrate`, and `Flask-SQLAlchemy` when `--db` (or when you accept the prompt).
+- Freezes `requirements.txt` from the venv.
+- Copies the starter app from `flask_commands/project` (blueprint-based app with configs, sample controller/route, Tailwind input.css, `.env` files, `run.py`, and `run.sh`), and marks `run.sh` executable.
+- Installs Tailwind via npm and adds `watch:css` / `build:css` scripts (skipped with a warning if npm is absent).
+- If `--db` is enabled, runs `flask db init/migrate/upgrade` using the new venv to seed SQLite.
+
+Quickstart:
+```bash
+flask new myproject        # use --no-db to skip SQLite setup
+cd myproject
+source venv/bin/activate
+flask run --debug          # or ./run.sh on macOS to open terminals + Safari and tailwind watchers
+```
+`run.sh` uses `osascript`/`fswatch`, so it is macOS-only.
+
+## Generating views/routes/controllers/models: `flask make:view`
+Usage:
+```
+flask make:view <dotted_path_with_name> [--controller NAME|-c] [--route PATH|-r] [--model NAME|-m]
+```
+- `dotted_path_with_name` maps folders + filename under `app/templates/`: `posts.index` → `app/templates/posts/index.html`. Nest as needed: `admin.users.show` → `app/templates/admin/users/show.html`.
+- Without flags you get just the view file (a small HTML snippet with a random Python quote).
+- `-c/--generate-controller` infers a controller class from the path (e.g., `PostController` from `posts.index`) and adds the action method; `--controller` lets you set it explicitly.
+- `-r/--generate-route` infers a RESTful route path (CRUD actions get GET/POST as appropriate, nested resources pick up parent IDs if a matching model import exists in `app/models/__init__.py`); `--route` lets you set a path yourself. If the route folder exists, it appends a function; otherwise it creates a blueprint folder and registers it in `app/__init__.py`.
+- `-m/--generate-model` infers a singular class name and creates a basic SQLAlchemy model file and import stub; `--model` lets you name it explicitly.
+
+Examples:
+- Minimal view component: `flask make:view button`
+- CRUD start with inferred pieces: `flask make:view posts.index -crm`
+- Nested resource with route params: `flask make:view admin.posts.comments.show -cr`
+- Explicit wiring: `flask make:view posts.show --controller PostController --route /posts/<int:post_id> --model Post`
+
+## Project template (copied by `flask new`)
+- Application entrypoints: `run.py`, `run.sh`
+- App package: `app/__init__.py` with blueprint registration + extensions (`LoginManager`, `SQLAlchemy`, `Migrate`)
+- Default blueprint: `app/routes/mains` → `app/controllers/main_controller.py` → `app/templates/mains/index.html`
+- Configs: `config/{base,development,production}_config.py`
+- Static/Tailwind: `app/static/src/input.css` (Tailwind CLI builds `tailwind.css` / `tailwind.min.css`)
+- Environment files: `.env`, `.env.example`
+
+## Contributing
+PRs and issues welcome. License: MIT.
+

flask_commands-0.1.0/README.md

@@ -0,0 +1,60 @@
+# flask-commands
+
+Local-first CLI that scaffolds a Flask project (venv, dotenv, Tailwind build scripts, blueprints, optional SQLite) and can keep generating views, routes, controllers, and models for you.
+
+## Install
+- Python 3.10+
+- Optional: `npm` if you want Tailwind auto-installed; the tool will skip Tailwind if `npm` is missing.
+- `pip install Flask-Commands`
+
+> The published console script is currently `flask`. If you have a clash with Flask’s own CLI, run with `python -m flask_commands.cli ...` or rename the script to `flask-commands` in `pyproject.toml`.
+
+## Commands at a glance
+- `flask new <project_name> [--db/--no-db]` — bootstrap a new project in a sibling folder, create a venv, install deps, copy the template, wire Tailwind, and optionally initialize SQLite + migrations.
+- `flask make:view <dotted_path_with_name> [options]` — create a view under `app/templates/` and optionally add a controller method, route/blueprint, and model.
+
+## Creating a project: `flask new`
+What happens:
+- Creates `<project_name>/` and a virtual environment under `venv/`.
+- Installs Python deps: always `Flask` + `python-dotenv`; adds `Flask-Login`, `Flask-Migrate`, and `Flask-SQLAlchemy` when `--db` (or when you accept the prompt).
+- Freezes `requirements.txt` from the venv.
+- Copies the starter app from `flask_commands/project` (blueprint-based app with configs, sample controller/route, Tailwind input.css, `.env` files, `run.py`, and `run.sh`), and marks `run.sh` executable.
+- Installs Tailwind via npm and adds `watch:css` / `build:css` scripts (skipped with a warning if npm is absent).
+- If `--db` is enabled, runs `flask db init/migrate/upgrade` using the new venv to seed SQLite.
+
+Quickstart:
+```bash
+flask new myproject        # use --no-db to skip SQLite setup
+cd myproject
+source venv/bin/activate
+flask run --debug          # or ./run.sh on macOS to open terminals + Safari and tailwind watchers
+```
+`run.sh` uses `osascript`/`fswatch`, so it is macOS-only.
+
+## Generating views/routes/controllers/models: `flask make:view`
+Usage:
+```
+flask make:view <dotted_path_with_name> [--controller NAME|-c] [--route PATH|-r] [--model NAME|-m]
+```
+- `dotted_path_with_name` maps folders + filename under `app/templates/`: `posts.index` → `app/templates/posts/index.html`. Nest as needed: `admin.users.show` → `app/templates/admin/users/show.html`.
+- Without flags you get just the view file (a small HTML snippet with a random Python quote).
+- `-c/--generate-controller` infers a controller class from the path (e.g., `PostController` from `posts.index`) and adds the action method; `--controller` lets you set it explicitly.
+- `-r/--generate-route` infers a RESTful route path (CRUD actions get GET/POST as appropriate, nested resources pick up parent IDs if a matching model import exists in `app/models/__init__.py`); `--route` lets you set a path yourself. If the route folder exists, it appends a function; otherwise it creates a blueprint folder and registers it in `app/__init__.py`.
+- `-m/--generate-model` infers a singular class name and creates a basic SQLAlchemy model file and import stub; `--model` lets you name it explicitly.
+
+Examples:
+- Minimal view component: `flask make:view button`
+- CRUD start with inferred pieces: `flask make:view posts.index -crm`
+- Nested resource with route params: `flask make:view admin.posts.comments.show -cr`
+- Explicit wiring: `flask make:view posts.show --controller PostController --route /posts/<int:post_id> --model Post`
+
+## Project template (copied by `flask new`)
+- Application entrypoints: `run.py`, `run.sh`
+- App package: `app/__init__.py` with blueprint registration + extensions (`LoginManager`, `SQLAlchemy`, `Migrate`)
+- Default blueprint: `app/routes/mains` → `app/controllers/main_controller.py` → `app/templates/mains/index.html`
+- Configs: `config/{base,development,production}_config.py`
+- Static/Tailwind: `app/static/src/input.css` (Tailwind CLI builds `tailwind.css` / `tailwind.min.css`)
+- Environment files: `.env`, `.env.example`
+
+## Contributing
+PRs and issues welcome. License: MIT.

flask_commands-0.1.0/flask_commands/__init__.py

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

flask_commands-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/flask_commands/project/app/controllers/__init__.py

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

flask_commands-0.1.0/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-0.1.0/flask_commands/project/app/models/__init__.py

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

flask_commands-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/flask_commands/project/app/static/src/input.css

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

flask_commands-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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-0.1.0/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')