lombik 0.1.0__tar.gz

lombik-0.1.0/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 David Plajner
+
+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.

lombik-0.1.0/PKG-INFO

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: lombik
+Version: 0.1.0
+Summary: Flask scaffold engine
+Author: David Plajner
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Flask
+Requires-Dist: Flask-SQLAlchemy
+Requires-Dist: Flask-Migrate
+Requires-Dist: Flask-WTF
+Requires-Dist: Flask-Session
+Requires-Dist: python-dotenv
+Requires-Dist: click
+Requires-Dist: SQLAlchemy
+Requires-Dist: Werkzeug
+Dynamic: license-file
+
+# Lombik
+#### A scaffold engine for Flask, the greatest framework of all times.
+
+This readme will serve perfectly as a self documentation file as I go, and at the end of it I will re-write it with the final details. 
+That means that if you see this, either my company cleersoftware has taken off and you might work with me on enhancing the scaffold for our apps. 
+Another possibility is that lombik took off, and you are reading the early commits. Have fun, there is probably a lot of them.
+Anyways, I'm gonan actually start on explaning / plannign how thigns will work.
+
+> Install lombik
+Run `pip install lombik`
+
+> Create app
+To create an app called *myapp*, run `lombik createapp myapp` then `cd myapp`
+This creates the entire structure of your application in one go and you can run `flask run --debug`
+
+> Create superuser
+Lombik comes with MySQL as a default db. In the generated .env file you'll find the credentials for local development.
+Replace those placeholders with your actual dev credentials and production if you have it already.
+When done, initialize the database by running `flask initdb` and then you can run `flask superuser` to create your owner account.
+With this, you'll be able to log in to your app and start developing from there.
+
+This is a quite simple auth system, in fact it is simple by design and meant to be replaced for production apps with something more robust.
+
+> Features and benefits
+On top of the structural guidance, lombik comes with a few built in goodies.
+
+- User authentication and session handling
+- CSRF / session expiry
+- Error handling
+- Structure
+- Template filters for frontend development
+- Pre-imported libraries
+- General templates for desktop and mobile
+
+

lombik-0.1.0/README.md

@@ -0,0 +1,35 @@
+# Lombik
+#### A scaffold engine for Flask, the greatest framework of all times.
+
+This readme will serve perfectly as a self documentation file as I go, and at the end of it I will re-write it with the final details. 
+That means that if you see this, either my company cleersoftware has taken off and you might work with me on enhancing the scaffold for our apps. 
+Another possibility is that lombik took off, and you are reading the early commits. Have fun, there is probably a lot of them.
+Anyways, I'm gonan actually start on explaning / plannign how thigns will work.
+
+> Install lombik
+Run `pip install lombik`
+
+> Create app
+To create an app called *myapp*, run `lombik createapp myapp` then `cd myapp`
+This creates the entire structure of your application in one go and you can run `flask run --debug`
+
+> Create superuser
+Lombik comes with MySQL as a default db. In the generated .env file you'll find the credentials for local development.
+Replace those placeholders with your actual dev credentials and production if you have it already.
+When done, initialize the database by running `flask initdb` and then you can run `flask superuser` to create your owner account.
+With this, you'll be able to log in to your app and start developing from there.
+
+This is a quite simple auth system, in fact it is simple by design and meant to be replaced for production apps with something more robust.
+
+> Features and benefits
+On top of the structural guidance, lombik comes with a few built in goodies.
+
+- User authentication and session handling
+- CSRF / session expiry
+- Error handling
+- Structure
+- Template filters for frontend development
+- Pre-imported libraries
+- General templates for desktop and mobile
+
+

lombik-0.1.0/lombik/cli.py

@@ -0,0 +1,64 @@
+from getpass import getpass
+from pathlib import Path
+import secrets
+import shutil
+import click
+
+
+BASE_DIR = Path(__file__).parent
+
+STARTUP_TEMPLATE = BASE_DIR / "templates" / "createapp"
+
+
+@click.group()
+def cli():
+    pass
+
+def is_text_file(path: Path) -> bool:
+    try:
+        path.read_text(encoding="utf-8")
+        return True
+    except UnicodeDecodeError:
+        return False
+    except Exception:
+        return False
+
+
+def replace_placeholders(target_dir, replacements):
+
+    for file in Path(target_dir).rglob("*"):
+
+        if not file.is_file():
+            continue
+
+        try:
+            content = file.read_text(encoding="utf-8")
+        except UnicodeDecodeError:
+            continue
+
+        for key, value in replacements.items():
+            content = content.replace(key, value)
+
+        file.write_text(content, encoding="utf-8")
+
+
+@cli.command()
+@click.argument("name")
+def createapp(name):
+
+    target = Path.cwd() / name
+
+    replacements = {
+        "{{SECRET_KEY}}": secrets.token_urlsafe(64),
+        "{{CRKEY}}": secrets.token_urlsafe(64)
+    }
+
+    shutil.copytree(STARTUP_TEMPLATE, target)
+
+    replace_placeholders(target, replacements)
+
+    print(f"Created app: {name}")
+    
+
+if __name__ == "__main__":
+    cli()

lombik-0.1.0/lombik/templates/createapp/app.py

@@ -0,0 +1,240 @@
+from flask import Flask, g, session, render_template, send_from_directory, current_app
+from flask.cli import with_appcontext
+from flask_wtf.csrf import CSRFError
+from flask_wtf import CSRFProtect
+from flask_session import Session
+from dotenv import load_dotenv
+from zoneinfo import ZoneInfo
+import time
+import os
+
+from db import db, migrate
+
+from config import config_dict
+from models import load_models
+
+# import all your bleurpints here
+from blueprints.core.routes import core_bp
+from blueprints.auth.routes import auth_bp
+from blueprints.settings.routes import settings_bp
+
+load_dotenv()
+
+
+def create_app(env="default"):
+    app = Flask(__name__, subdomain_matching=False)
+    
+    load_models()
+    # load models first otherwise fetch will never happen
+    # also, stop trying to make fetch happen
+    _user_management(app)
+
+    _init_config(app, env)
+    _init_extensions(app)
+    _init_session_dir(app)
+    _init_filters(app)
+    _init_blueprints(app)
+    _init_hooks(app)
+    _init_routes(app)
+    _init_error_handlers(app)
+    
+    return app
+
+
+def _init_config(app, env):
+    cfg = config_dict[env]()
+
+    app.config.from_object(cfg)
+    app.config.update(
+        SECRET_KEY=cfg.SECRET_KEY,
+        CACHE_TYPE=cfg.CACHE_TYPE,
+        CACHE_DEFAULT_TIMEOUT=int(cfg.CACHE_DEFAULT_TIMEOUT),
+    )
+
+def _init_extensions(app):
+    Session(app)
+    CSRFProtect(app)
+    db.init_app(app)
+    migrate.init_app(app, db)
+    
+
+def _init_session_dir(app):
+    if app.config.get("SESSION_TYPE") == "filesystem":
+        os.makedirs(app.config["SESSION_FILE_DIR"], exist_ok=True)
+
+
+def _init_blueprints(app):
+    app.register_blueprint(core_bp, url_prefix="/")
+    app.register_blueprint(auth_bp, url_prefix="/auth")
+    app.register_blueprint(settings_bp, url_prefix="/settings")
+
+
+def _init_hooks(app):
+    #app.before_request(load_user)
+    app.before_request(_csrf_lifetime_tracker)
+
+
+def _csrf_lifetime_tracker():
+    if "csrf_last_reset" not in session:
+        session["csrf_last_reset"] = int(time.time())
+
+    session["csrf_last_reset"] = int(time.time())
+
+    g.csrf_time_left = current_app.config.get("WTF_CSRF_TIME_LIMIT", 3600)
+
+
+"""
+These are all the custom templating commands you can use with lombik.
+
+As an example, timestamps in the db are stored as UTC.
+By default, lombik will create the user in the g object with the user's timezone
+
+Now to display the UTC timestamp to the user's local timestamp all you have to do is:
+
+{{ created_at | localtime }}
+
+And it convert UTC to user's local.
+
+You can also do dateonly, which by default converts it to UTC and strips out the date.
+There is more.
+
+"""
+def _init_filters(app):
+    from markdown import markdown
+
+    @app.template_filter("localtimezone")
+    def localtimezone(dt):
+        if not dt:
+            return ""
+
+        tz = "UTC"
+        if hasattr(g, "user") and g.tenant:
+            tz = g.tenant.timezone
+
+        return dt.astimezone(ZoneInfo(tz))
+
+
+    def _fmt(dt, fmt):
+        dt = localtimezone(dt)
+        return dt.strftime(fmt) if dt else ""
+
+
+    @app.template_filter("onlydate")
+    def onlydate(dt):
+        return _fmt(dt, "%Y-%m-%d")
+
+
+    @app.template_filter("onlytime")
+    def onlytime(dt):
+        return _fmt(dt, "%H:%M")
+
+
+    @app.template_filter("localtime")
+    def localtime(dt):
+        return _fmt(dt, "%Y-%m-%d %H:%M")
+
+
+    @app.template_filter("shortdatetime")
+    def shortdatetime(dt):
+        return _fmt(dt, "%b %d %H:%M").lower()
+    
+    
+    @app.template_filter("proper")
+    def proper(s):
+        return s.replace("_", " ").title()
+
+
+def _init_routes(app):
+
+    @app.route("/manifest.json")
+    def manifest():
+        return send_from_directory("static", "manifest.json")
+
+
+def _init_error_handlers(app):
+
+    @app.errorhandler(CSRFError)
+    def csrf_error(e):
+        return render_template("base/csrf_error.html"), 400
+
+
+    @app.errorhandler(404)
+    def not_found(e):
+        return render_template("base/404.html"), 404
+    
+
+def _user_management(app):
+    from blueprints.auth.services import load_user, create_user
+
+    @app.before_request
+    def fetch_user():
+        user_id = session.get("user_id")
+
+        if not user_id:
+            g.user = None
+            return
+
+        user = load_user(user_id)
+
+        if not user:
+            g.user = None
+            return
+
+        g.user = user
+
+    @app.cli.command("initdb")
+    @with_appcontext
+    def initdb():
+        import subprocess
+
+        required = [
+            "DEV_MYSQL_USERNAME",
+            "DEV_MYSQL_PASS",
+            "DEV_MYSQL_HOST",
+            "DEV_MYSQL_NAME"
+        ]
+
+        missing = [x for x in required if not os.getenv(x)]
+        if missing:
+            print(f"Missing env vars: {', '.join(missing)}")
+            return
+        
+        subprocess.run(["flask", "db", "init"])
+        subprocess.run(["flask", "db", "migrate", "-m", "auto init"])
+        subprocess.run(["flask", "db", "upgrade"])
+        print("Database initialized.")
+
+    @app.cli.command("superuser")
+    @with_appcontext
+    def superuser():
+        from getpass import getpass
+        import os
+
+        print("Starting application...")
+
+        load_models()
+
+        email = input("Email: ").lower().strip()
+        username = input("Username: ").lower().strip()
+
+        while True:
+            password = getpass("Password: ")
+            password_confirm = getpass("Again: ")
+
+            if password == password_confirm:
+                break
+            print("Passwords do not match")
+
+        res = create_user(
+            username=username,
+            email=email,
+            role="owner",
+            password=password
+        )
+
+        if not res.success:
+            print(f"Error: {res.message}")
+            return
+
+        print("\nSuperuser created successfully.")
+        print("Run: flask run --debug")

lombik-0.1.0/lombik/templates/createapp/blueprints/auth/models.py

@@ -0,0 +1,71 @@
+from datetime import datetime, timezone
+from db import db
+import uuid
+
+def utc_now():
+    return datetime.now(timezone.utc)
+
+class User(db.Model):
+    __tablename__ = "users"
+
+    user_id = db.Column(
+        db.String(36),
+        primary_key=True,
+        default=lambda: str(uuid.uuid4())
+    )
+
+    username = db.Column(
+        db.String(100),
+        unique=True,
+        nullable=False
+    )
+
+    role = db.Column(
+        db.String(50),
+        nullable=False,
+        default="user"
+    )
+
+    status = db.Column(
+        db.String(50),
+        nullable=False,
+        default="active"
+    )
+
+    password_hash = db.Column(
+        db.Text,
+        nullable=False
+    )
+
+    email = db.Column(
+        db.String(255),
+        unique=True,
+        nullable=False
+    )
+
+    created_at = db.Column(
+        db.DateTime(timezone=True),
+        default=utc_now
+    )
+
+    last_seen = db.Column(
+        db.DateTime(timezone=True), 
+        default=utc_now
+    )
+
+    failed_login_attempts = db.Column(
+        db.Integer, 
+        default=0
+    )
+
+    locked_until = db.Column(
+        db.DateTime(timezone=True)
+    )
+
+    deactivated_at = db.Column(
+        db.DateTime(timezone=True)
+    )
+
+    deleted_at = db.Column(
+        db.DateTime(timezone=True)
+    )

lombik-0.1.0/lombik/templates/createapp/blueprints/auth/roles.py

@@ -0,0 +1,4 @@
+def roles():
+    return [
+        "user", "admin", "owner", "system"
+    ]

lombik-0.1.0/lombik/templates/createapp/blueprints/auth/routes.py

@@ -0,0 +1,41 @@
+from flask import render_template, redirect, url_for, request, Blueprint, flash, session
+from tools import genflash
+
+
+auth_bp = Blueprint(
+    "auth_bp", 
+    __name__, 
+    template_folder="templates",
+    static_folder="static"
+)
+
+@auth_bp.route("/login", methods=["GET", "POST"])
+def login():
+    
+    if request.method == 'POST':
+        from blueprints.auth.services import authenticate_user
+
+        res = authenticate_user(
+            email=request.form.get("email", "").strip().lower(),
+            password=request.form.get("password", "")
+        )
+
+        if not res.success:
+            msg, cat = genflash(res.message, "error")
+            flash(msg ,cat)
+            return redirect(url_for("auth_bp.login"))
+        
+        session["user_id"] = res.data["user_id"]
+        msg, cat = genflash("Welcome", "chat")
+        flash(msg, cat)
+        return redirect(url_for("core_bp.home"))
+
+    return render_template("auth/login.html")
+
+
+@auth_bp.post("/logout")
+def logout():
+    session.clear()
+    msg, cat = genflash("Bye bye!", "chat")
+    flash(msg, cat)
+    return redirect(url_for("auth_bp.login"))

lombik-0.1.0/lombik/templates/createapp/blueprints/auth/services.py

@@ -0,0 +1,162 @@
+from werkzeug.security import generate_password_hash, check_password_hash
+from blueprints.core.error_logging import log_error
+from datetime import datetime, timezone, timedelta
+from blueprints.auth.roles import roles
+from dataclasses import dataclass
+from typing import Optional, Any
+from models import User
+from flask import g
+from db import db
+import uuid
+import re
+
+
+@dataclass
+class Result:
+    success: bool
+    data: Optional[Any] = None
+    message: str = ""
+
+
+def utc_now():
+    return datetime.now(timezone.utc)
+
+
+def valid_email_pattern(email: str) -> bool:
+    pattern = r"^[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+$"
+    return bool(re.match(pattern, email))
+
+
+def validate_password_strength(password: str) -> Result:
+    if len(password) < 8:
+        return Result(False, message="Password must be at least 8 characters long.")
+
+    if not re.search(r"[A-Z]", password):
+        return Result(False, message="Password must contain at least one uppercase letter.")
+
+    if not re.search(r"[a-z]", password):
+        return Result(False, message="Password must contain at least one lowercase letter.")
+
+    if not re.search(r"[^A-Za-z0-9]", password):
+        return Result(False, message="Password must contain at least one special character.")
+
+    return Result(True)
+
+def username_exists(username: str) -> bool:
+    return User.query.filter_by(username=username).first() is not None
+
+def validate_role(role: str) -> bool:
+    return role.strip().lower() in {r.lower() for r in roles()}
+
+
+def email_exists(email: str) -> bool:
+    return User.query.filter_by(email=email).first() is not None
+
+
+def validate_user_creation(username: str, email: str, role: str, password: str) -> Result:
+
+    if username_exists(username):
+        return Result(False, message="Username already taken")
+    
+    if not validate_role(role=role):
+        return Result(False, message="Invalid role")
+
+    if not valid_email_pattern(email):
+        return Result(False, message="Invalid email address")
+
+    if email_exists(email):
+        return Result(False, message="Email already registered")
+
+    password_check = validate_password_strength(password)
+    if not password_check.success:
+        return password_check
+
+    return Result(True)
+
+
+def create_user(username: str, email: str, role: str, password: str) -> Result:
+
+    validation = validate_user_creation(username, email, role,  password)
+    if not validation.success:
+        return validation
+
+    user = User(
+        user_id=str(uuid.uuid4()),
+        username=username,
+        email=email,
+        role=role,
+        password_hash=generate_password_hash(password),
+        created_at=utc_now()
+    )
+    try:
+        db.session.add(user)
+        db.session.commit()
+        
+        return Result(True, message="User created successfully")
+    
+    except Exception as e:
+        log_error(
+            user_id=getattr(g, "user_id", None),
+            function="create_user",
+            action="Creating user",
+            exception=e
+        )
+
+        return Result(False, message="An error occurred when creating the user")
+    
+
+def authenticate_user(email, password):
+    user = User.query.filter_by(email=email).first()
+
+    if not user:
+        return Result(False, message="invalid credentials")
+    
+    now = datetime.now(timezone.utc)
+
+    if user.status == "deleted":
+        delete_at = user.deactivated_at + timedelta(days=30)
+        if delete_at < now:
+            message = "This account and all its data was deleted permanently. Please create a new one"
+        else:
+            message = f"This account will be permanently deleted on {delete_at.strftime('%Y-%m-%d %H:%M UTC')}."
+        return Result(False, message=message)
+    
+    now = datetime.now(timezone.utc)
+
+    if user.locked_until and user.locked_until > now:
+        return Result(False, message="Too many attempts. Try again later.")
+    
+    if not check_password_hash(user.password_hash, password):
+        user.failed_login_attempts = (user.failed_login_attempts or 0) + 1
+        
+        if user.failed_login_attempts >= 5:
+            user.locked_until = now + timedelta(minutes=10)
+        
+        db.session.commit()
+
+        return Result(False, message="Invalid credentials")
+    
+    user.failed_login_attempts = 0
+    user.locked_until = None
+    db.session.commit()
+
+    return Result(
+        True, 
+        data={"user_id": user.user_id},
+        message="User authenticated successfully"
+    )
+
+    
+def load_user(user_id):
+    user = db.session.query(
+        User.user_id,
+        User.username,
+        User.email,
+        User.role,
+        User.status,
+        User.created_at
+    ).filter_by(user_id=user_id).first()
+    if not user:
+        return None
+
+    return user

lombik-0.1.0/lombik/templates/createapp/blueprints/core/error_logging.py

@@ -0,0 +1,27 @@
+from db import db
+from blueprints.core.models import Error
+from sqlalchemy.exc import SQLAlchemyError
+from flask import g
+import traceback
+
+
+def log_error(
+    user_id: str,
+    function: str,
+    action: str,
+    exception: Exception
+):
+    try:
+        db.session.add(
+            Error(
+                user_id=user_id,
+                function=function,
+                action=action,
+                error_message=str(exception),
+                traceback=traceback.format_exc()
+            )
+        )
+        db.session.commit()
+
+    except SQLAlchemyError:
+        db.session.rollback()

lombik-0.1.0/lombik/templates/createapp/blueprints/core/models.py

@@ -0,0 +1,21 @@
+from datetime import datetime, timezone
+from db import db
+import uuid
+
+
+def utc_now():
+    return datetime.now(timezone.utc)
+
+
+class Error(db.Model):
+    __tablename__="errors"
+
+    error_id = db.Column(db.String(36), primary_key=True, default=lambda: str(uuid.uuid4()))
+    user_id = db.Column(db.String(36), db.ForeignKey("users.user_id"))
+    function = db.Column(db.String(100))
+    action = db.Column(db.String(100))
+    error = db.Column(db.Text)
+    traceback = db.Column(db.Text)
+    created_at = db.Column(db.DateTime(timezone=True), default=utc_now, index=True)
+
+    user = db.relationship("User")

lombik-0.1.0/lombik/templates/createapp/blueprints/core/routes.py

@@ -0,0 +1,19 @@
+from flask import render_template, redirect, url_for, Blueprint, g
+from wrappers import login_required
+
+core_bp = Blueprint(
+    "core_bp", 
+    __name__, 
+    template_folder="templates",
+    static_folder="static"
+)
+
+@core_bp.route("/")
+@login_required
+def home():
+
+    context = {
+        "selected": "home",
+        "user": g.user
+    }
+    return render_template("/core/home.html", **context)

lombik-0.1.0/lombik/templates/createapp/blueprints/settings/routes.py

@@ -0,0 +1,19 @@
+from flask import render_template, redirect, url_for, Blueprint, g
+from wrappers import login_required
+
+settings_bp = Blueprint(
+    "settings_bp", 
+    __name__, 
+    template_folder="templates",
+    static_folder="static"
+)
+
+@settings_bp.route("/settings")
+@login_required
+def settings():
+    context = {
+        "selected": "settings",
+        "user": g.user,
+
+    }
+    return render_template("/settings/general.html", **context)

lombik-0.1.0/lombik/templates/createapp/config.py

@@ -0,0 +1,53 @@
+from datetime import timedelta
+import os
+
+class BaseConfig:
+    SECRET_KEY = os.getenv("SECRET_KEY")
+
+    # Fail fast instead of silently breaking later
+    if not SECRET_KEY:
+        raise ValueError("SECRET_KEY is missing")
+
+    CRKEY = os.getenv("CRKEY")
+
+    PERMANENT_SESSION_LIFETIME = timedelta(days=365)
+    SESSION_TYPE = "filesystem"
+    SESSION_USE_SIGNER = True
+    SESSION_FILE_DIR = os.path.join(os.getcwd(), "flask_session")
+
+    CACHE_TYPE = "SimpleCache"
+    CACHE_DEFAULT_TIMEOUT = 300
+
+    WTF_CSRF_TIME_LIMIT = 3 * 60 * 60
+
+    SQLALCHEMY_TRACK_MODIFICATIONS = False
+
+
+class ConfigProd(BaseConfig):
+    SESSION_COOKIE_SECURE = True
+
+    SQLALCHEMY_DATABASE_URI = (
+        f"mysql+pymysql://{os.getenv('PROD_MYSQL_USERNAME')}:"
+        f"{os.getenv('PROD_MYSQL_PASS')}@"
+        f"{os.getenv('PROD_MYSQL_HOST')}/"
+        f"{os.getenv('PROD_MYSQL_NAME')}"
+    )
+
+
+class ConfigTest(BaseConfig):
+    SESSION_COOKIE_SECURE = False
+    CACHE_DEFAULT_TIMEOUT = 60
+
+    SQLALCHEMY_DATABASE_URI = (
+        f"mysql+pymysql://{os.getenv('DEV_MYSQL_USERNAME')}:"
+        f"{os.getenv('DEV_MYSQL_PASS')}@"
+        f"{os.getenv('DEV_MYSQL_HOST')}/"
+        f"{os.getenv('DEV_MYSQL_NAME')}"
+    )
+
+
+config_dict = {
+    "prod": ConfigProd,
+    "test": ConfigTest,
+    "default": ConfigTest
+}

lombik-0.1.0/lombik/templates/createapp/db.py

@@ -0,0 +1,5 @@
+from flask_sqlalchemy import SQLAlchemy
+from flask_migrate import Migrate
+
+db = SQLAlchemy()
+migrate = Migrate()

lombik-0.1.0/lombik/templates/createapp/models/__init__.py

@@ -0,0 +1,11 @@
+from blueprints.auth.models import User
+from blueprints.core.models import Error
+
+def load_models():
+    """
+    Import all models in here to be supplied in app.py
+    """
+    return [User, Error]
+
+
+__all__ = ["User", "Error"]

lombik-0.1.0/lombik/templates/createapp/tools.py

@@ -0,0 +1,45 @@
+def genflash(message: str, category: str):
+    """
+    Accepted categories:
+    - bug
+    - error
+    - warning
+    - ok
+    - safe
+    - win
+    - timeout
+    - wait
+    - announce
+    - upload
+    - save
+    - delete
+    - thumbsup
+    - thumbsdown
+    - chat
+    """    
+
+    cats = {
+    'bug':     {'icon': 'bug-outline', 'class': 'text-amber-400'},
+    'error':   {'icon': 'alert-circle-outline', 'class': 'text-red-400'},
+    'warning': {'icon': 'warning-outline', 'class': 'text-amber-400'},
+    'ok':      {'icon': 'checkmark-circle-outline', 'class': 'text-green-400'},
+    'safe':    {'icon': 'shield-checkmark-outline', 'class': 'text-teal-400'},
+    'win':     {'icon': 'medal-outline', 'class': 'text-sky-400'},
+    'timeout':     {'icon': 'alarm-outline', 'class': 'text-amber-400'},
+    'wait':     {'icon': 'hourglass-outline', 'class': 'text-amber-400'},
+    'announce':     {'icon': 'megaphone-outline', 'class': 'text-teal-400'},
+    'upload':     {'icon': 'cloud-upload-outline', 'class': 'text-white'},
+    'save':     {'icon': 'save-outline', 'class': 'text-sky-400'},
+    'delete':     {'icon': 'trash-outline', 'class': 'text-red-400'},
+    'thumbsup':     {'icon': 'thumbs-up-outline', 'class': 'text-green-400'},
+    'thumbsdown':     {'icon': 'thumbs-down-outline', 'class': 'text-red-400'},
+    'chat':     {'icon': 'chatbubble-ellipses-outline', 'class': 'text-sky-400'},
+}
+    if category not in cats:
+        raise ValueError("Invalid category")
+
+    return {
+        "text": message,
+        "icon": cats[category]['icon'],
+        "icon_class": cats[category]['class'],
+    }, category

lombik-0.1.0/lombik/templates/createapp/wrappers.py

@@ -0,0 +1,13 @@
+from flask import session, redirect, url_for, flash, g
+from functools import wraps
+from tools import genflash
+
+def login_required(f):
+    @wraps(f)
+    def decorated_function(*args, **kwargs):
+        if 'user_id' not in session or not g.user:
+            msg, cat = genflash("You must log in to visit this page", "error")
+            flash(msg, cat)
+            return redirect(url_for('auth_bp.login'))
+        return f(*args, **kwargs)
+    return decorated_function

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

@@ -0,0 +1,53 @@
+Metadata-Version: 2.4
+Name: lombik
+Version: 0.1.0
+Summary: Flask scaffold engine
+Author: David Plajner
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: Flask
+Requires-Dist: Flask-SQLAlchemy
+Requires-Dist: Flask-Migrate
+Requires-Dist: Flask-WTF
+Requires-Dist: Flask-Session
+Requires-Dist: python-dotenv
+Requires-Dist: click
+Requires-Dist: SQLAlchemy
+Requires-Dist: Werkzeug
+Dynamic: license-file
+
+# Lombik
+#### A scaffold engine for Flask, the greatest framework of all times.
+
+This readme will serve perfectly as a self documentation file as I go, and at the end of it I will re-write it with the final details. 
+That means that if you see this, either my company cleersoftware has taken off and you might work with me on enhancing the scaffold for our apps. 
+Another possibility is that lombik took off, and you are reading the early commits. Have fun, there is probably a lot of them.
+Anyways, I'm gonan actually start on explaning / plannign how thigns will work.
+
+> Install lombik
+Run `pip install lombik`
+
+> Create app
+To create an app called *myapp*, run `lombik createapp myapp` then `cd myapp`
+This creates the entire structure of your application in one go and you can run `flask run --debug`
+
+> Create superuser
+Lombik comes with MySQL as a default db. In the generated .env file you'll find the credentials for local development.
+Replace those placeholders with your actual dev credentials and production if you have it already.
+When done, initialize the database by running `flask initdb` and then you can run `flask superuser` to create your owner account.
+With this, you'll be able to log in to your app and start developing from there.
+
+This is a quite simple auth system, in fact it is simple by design and meant to be replaced for production apps with something more robust.
+
+> Features and benefits
+On top of the structural guidance, lombik comes with a few built in goodies.
+
+- User authentication and session handling
+- CSRF / session expiry
+- Error handling
+- Structure
+- Template filters for frontend development
+- Pre-imported libraries
+- General templates for desktop and mobile
+
+

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

@@ -0,0 +1,28 @@
+LICENSE
+README.md
+pyproject.toml
+lombik/__init__.py
+lombik/cli.py
+lombik.egg-info/PKG-INFO
+lombik.egg-info/SOURCES.txt
+lombik.egg-info/dependency_links.txt
+lombik.egg-info/entry_points.txt
+lombik.egg-info/requires.txt
+lombik.egg-info/top_level.txt
+lombik/templates/__init__.py
+lombik/templates/createapp/app.py
+lombik/templates/createapp/config.py
+lombik/templates/createapp/db.py
+lombik/templates/createapp/tools.py
+lombik/templates/createapp/wrappers.py
+lombik/templates/createapp/blueprints/auth/models.py
+lombik/templates/createapp/blueprints/auth/roles.py
+lombik/templates/createapp/blueprints/auth/routes.py
+lombik/templates/createapp/blueprints/auth/services.py
+lombik/templates/createapp/blueprints/core/error_logging.py
+lombik/templates/createapp/blueprints/core/models.py
+lombik/templates/createapp/blueprints/core/routes.py
+lombik/templates/createapp/blueprints/settings/modesl.py
+lombik/templates/createapp/blueprints/settings/routes.py
+lombik/templates/createapp/blueprints/settings/services.py
+lombik/templates/createapp/models/__init__.py

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

@@ -0,0 +1 @@
+

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

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

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

@@ -0,0 +1,9 @@
+Flask
+Flask-SQLAlchemy
+Flask-Migrate
+Flask-WTF
+Flask-Session
+python-dotenv
+click
+SQLAlchemy
+Werkzeug

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

@@ -0,0 +1 @@
+lombik

lombik-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lombik"
+version = "0.1.0"
+description = "Flask scaffold engine"
+authors = [
+    { name="David Plajner" }
+]
+readme = "README.md"
+
+dependencies = [
+    "Flask",
+    "Flask-SQLAlchemy",
+    "Flask-Migrate",
+    "Flask-WTF",
+    "Flask-Session",
+    "python-dotenv",
+    "click",
+    "SQLAlchemy",
+    "Werkzeug"
+]
+
+[project.scripts]
+lombik = "lombik.cli:cli"

lombik-0.1.0/setup.cfg

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