jdm-electron-flask 1.0.0__tar.gz

jdm_electron_flask-1.0.0/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: jdm-electron-flask
+Version: 1.0.0
+Summary: The Python backbone for jdm-electron-flask desktop apps
+Author-email: JDM-Github <jdmaster888@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/JDM-Github/jdm-electron-flask
+Project-URL: Repository, https://github.com/JDM-Github/jdm-electron-flask
+Project-URL: Issues, https://github.com/JDM-Github/jdm-electron-flask/issues
+Keywords: flask,electron,desktop,socketio,jdm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: flask>=3.0.0
+Requires-Dist: flask-cors>=4.0.0
+Requires-Dist: flask-socketio>=5.3.0
+Requires-Dist: simple-websocket>=1.0.0
+
+# jdm-electron-flask (Python)
+
+> The Python backbone for [`jdm-electron-flask`](https://github.com/JDM-Github/jdm-electron-flask) desktop apps.
+
+This package ships inside every project scaffolded by the `jdm-cli electron-flask` plugin. It provides the app factory, dynamic API registration, SocketIO setup, and environment-aware logging — so you build features, not boilerplate.
+
+---
+
+## Installation
+
+You don't install this manually. It's included in the scaffolded `requirements.txt`:
+
+```
+jdm-electron-flask==1.0.0
+```
+
+If you need it standalone:
+
+```bash
+pip install jdm-electron-flask
+```
+
+---
+
+## What it provides
+
+### `create_app`
+The Flask app factory. Handles config loading, SocketIO init, blueprint auto-discovery, and the React SPA catch-all route.
+
+```python
+# run.py
+from jdm_electron_flask import create_app, get_socketio
+
+app = create_app()
+socketio = get_socketio()
+
+if __name__ == "__main__":
+    socketio.run(app, host="0.0.0.0", port=5000, debug=True)
+```
+
+### `JDMBlueprint`
+Extended Blueprint with built-in response helpers.
+
+```python
+from jdm_electron_flask import JDMBlueprint
+
+health_bp = JDMBlueprint("health", __name__)
+
+@health_bp.route("/health")
+def health():
+    return health_bp.success({"status": "ok"})
+```
+
+### `JDMEvents`
+Base class for organizing socket event handlers.
+
+```python
+from jdm_electron_flask import JDMEvents
+
+class ConnectEvents(JDMEvents):
+    def register(self):
+        @self.socketio.on("connect")
+        def on_connect():
+            self.on_connect()
+
+        @self.socketio.on("ping_server")
+        def on_ping(data):
+            self.emit("pong_client", {"echo": data})
+
+ConnectEvents().register()
+```
+
+### `Printer`
+Environment-aware logger. Prints in development, writes to `logs/<date>.log` in production/deployed.
+
+```python
+from jdm_electron_flask import Printer
+
+Printer.success("Blueprint registered")
+Printer.warn("Something is off")
+Printer.error("Something broke")
+Printer.info("Just FYI")
+```
+
+### Response helpers
+
+```python
+from jdm_electron_flask import success, error, paginate
+
+return success({"user": "JDM"})
+return error("Not found", status=404)
+return paginate(items, total=100, page=1, per_page=10)
+```
+
+### Validators
+
+```python
+from jdm_electron_flask import validate_fields
+
+valid, msg, data = validate_fields(["name", "email"])
+if not valid:
+    return error(msg)
+```
+
+---
+
+## Dynamic API registration
+
+Routes are controlled by `config/api.json`:
+
+```json
+{
+    "health": {
+        "link": "/api",
+        "masterEnabled": true
+    },
+    "users": {
+        "link": "/api/users",
+        "masterEnabled": true,
+        "disabledOnProduction": false,
+        "disabledOnDeployed": false
+    }
+}
+```
+
+Adding a new route:
+1. Add entry to `config/api.json`
+2. Create `app/api/users.py` with a `users_bp` blueprint
+
+That's it. No touching `__init__.py` ever again.
+
+---
+
+## Environment modes
+
+| `FLASK_ENV` | Behavior |
+|---|---|
+| `development` | Debug on, console logging, all routes enabled |
+| `production` | Debug off, file logging, respects `disabledOnProduction` |
+| `deployed` | Debug off, file logging, respects `disabledOnDeployed` |
+
+---
+
+## Companion
+
+This package is the Python half of the `jdm-electron-flask` ecosystem:
+
+| Package | Role |
+|---|---|
+| [`jdm-electron-flask`](https://www.npmjs.com/package/jdm-electron-flask) (npm) | CLI plugin — scaffold, build, compile |
+| `jdm-electron-flask` (PyPI) | Backend library — app factory, blueprints, sockets |
+
+---
+
+## License
+
+MIT © [JDM-Github](https://github.com/JDM-Github)

jdm_electron_flask-1.0.0/README.md

@@ -0,0 +1,157 @@
+# jdm-electron-flask (Python)
+
+> The Python backbone for [`jdm-electron-flask`](https://github.com/JDM-Github/jdm-electron-flask) desktop apps.
+
+This package ships inside every project scaffolded by the `jdm-cli electron-flask` plugin. It provides the app factory, dynamic API registration, SocketIO setup, and environment-aware logging — so you build features, not boilerplate.
+
+---
+
+## Installation
+
+You don't install this manually. It's included in the scaffolded `requirements.txt`:
+
+```
+jdm-electron-flask==1.0.0
+```
+
+If you need it standalone:
+
+```bash
+pip install jdm-electron-flask
+```
+
+---
+
+## What it provides
+
+### `create_app`
+The Flask app factory. Handles config loading, SocketIO init, blueprint auto-discovery, and the React SPA catch-all route.
+
+```python
+# run.py
+from jdm_electron_flask import create_app, get_socketio
+
+app = create_app()
+socketio = get_socketio()
+
+if __name__ == "__main__":
+    socketio.run(app, host="0.0.0.0", port=5000, debug=True)
+```
+
+### `JDMBlueprint`
+Extended Blueprint with built-in response helpers.
+
+```python
+from jdm_electron_flask import JDMBlueprint
+
+health_bp = JDMBlueprint("health", __name__)
+
+@health_bp.route("/health")
+def health():
+    return health_bp.success({"status": "ok"})
+```
+
+### `JDMEvents`
+Base class for organizing socket event handlers.
+
+```python
+from jdm_electron_flask import JDMEvents
+
+class ConnectEvents(JDMEvents):
+    def register(self):
+        @self.socketio.on("connect")
+        def on_connect():
+            self.on_connect()
+
+        @self.socketio.on("ping_server")
+        def on_ping(data):
+            self.emit("pong_client", {"echo": data})
+
+ConnectEvents().register()
+```
+
+### `Printer`
+Environment-aware logger. Prints in development, writes to `logs/<date>.log` in production/deployed.
+
+```python
+from jdm_electron_flask import Printer
+
+Printer.success("Blueprint registered")
+Printer.warn("Something is off")
+Printer.error("Something broke")
+Printer.info("Just FYI")
+```
+
+### Response helpers
+
+```python
+from jdm_electron_flask import success, error, paginate
+
+return success({"user": "JDM"})
+return error("Not found", status=404)
+return paginate(items, total=100, page=1, per_page=10)
+```
+
+### Validators
+
+```python
+from jdm_electron_flask import validate_fields
+
+valid, msg, data = validate_fields(["name", "email"])
+if not valid:
+    return error(msg)
+```
+
+---
+
+## Dynamic API registration
+
+Routes are controlled by `config/api.json`:
+
+```json
+{
+    "health": {
+        "link": "/api",
+        "masterEnabled": true
+    },
+    "users": {
+        "link": "/api/users",
+        "masterEnabled": true,
+        "disabledOnProduction": false,
+        "disabledOnDeployed": false
+    }
+}
+```
+
+Adding a new route:
+1. Add entry to `config/api.json`
+2. Create `app/api/users.py` with a `users_bp` blueprint
+
+That's it. No touching `__init__.py` ever again.
+
+---
+
+## Environment modes
+
+| `FLASK_ENV` | Behavior |
+|---|---|
+| `development` | Debug on, console logging, all routes enabled |
+| `production` | Debug off, file logging, respects `disabledOnProduction` |
+| `deployed` | Debug off, file logging, respects `disabledOnDeployed` |
+
+---
+
+## Companion
+
+This package is the Python half of the `jdm-electron-flask` ecosystem:
+
+| Package | Role |
+|---|---|
+| [`jdm-electron-flask`](https://www.npmjs.com/package/jdm-electron-flask) (npm) | CLI plugin — scaffold, build, compile |
+| `jdm-electron-flask` (PyPI) | Backend library — app factory, blueprints, sockets |
+
+---
+
+## License
+
+MIT © [JDM-Github](https://github.com/JDM-Github)

jdm_electron_flask-1.0.0/jdm_electron_flask/__init__.py

@@ -0,0 +1,35 @@
+"""
+jdm-electron-flask-py
+~~~~~~~~~~~~~~~~~~~~~
+The Python backbone for jdm-electron-flask projects.
+
+Provides app factory, dynamic API registration, SocketIO setup,
+and environment-aware logging — so you build features, not boilerplate.
+"""
+
+__version__ = "1.0.0"
+__author__ = "JDM-Github"
+
+from jdm_electron_flask.core.app import create_app, get_socketio
+from jdm_electron_flask.core.blueprint import JDMBlueprint
+from jdm_electron_flask.core.event import JDMEvent
+from jdm_electron_flask.utils.printer import Printer
+from jdm_electron_flask.utils.responses import success, error
+from jdm_electron_flask.utils.validators import require_access, validate_json
+from jdm_electron_flask.core.config import JDMConfig, JDMDevelopmentConfig, JDMProductionConfig, JDMDeployedConfig
+
+__all__ = [
+    "create_app",
+    "get_socketio",
+    "JDMBlueprint",
+    "JDMEvent",
+    "Printer",
+    "success",
+    "error",
+    "require_access",
+    "validate_json",
+    "JDMConfig",
+    "JDMDevelopmentConfig",
+    "JDMProductionConfig",
+    "JDMDeployedConfig"
+]

jdm_electron_flask-1.0.0/jdm_electron_flask/core/app.py

@@ -0,0 +1,154 @@
+from flask import Flask, send_from_directory
+from flask_cors import CORS
+from flask_socketio import SocketIO
+import importlib
+import json
+import os
+import inspect
+from jdm_electron_flask.utils.printer import Printer
+_socketio = SocketIO()
+
+
+def get_socketio() -> SocketIO:
+    """Return the shared SocketIO instance."""
+    return _socketio
+
+
+def _load_config(config_name: str, app: Flask):
+    """Load Flask config based on environment name."""
+    try:
+        if config_name == "production":
+            from app.config import ProductionConfig # type: ignore
+            app.config.from_object(ProductionConfig)
+        elif config_name == "deployed":
+            from app.config import DeployedConfig # type: ignore
+            app.config.from_object(DeployedConfig)
+        else:
+            from app.config import DevelopmentConfig # type: ignore
+            app.config.from_object(DevelopmentConfig)
+    except ImportError:
+        Printer.warn(f"Config class for '{config_name}' not found — using Flask defaults")
+
+def _load_blueprints(app: Flask, env: str):
+    import inspect
+    from jdm_electron_flask import JDMBlueprint
+
+    api_config_path = os.path.join(os.getcwd(), "config", "api.json")
+    if not os.path.exists(api_config_path):
+        Printer.warn("config/api.json not found — no blueprints registered")
+        return
+
+    with open(api_config_path, "r") as f:
+        api_config = json.load(f)
+
+    for name, config in api_config.items():
+        if not config.get("masterEnabled", True):
+            Printer.warn(f"[{name}] skipped (masterEnabled: false)")
+            continue
+        if env == "production" and config.get("disabledOnProduction", False):
+            Printer.warn(f"[{name}] skipped (disabledOnProduction: true)")
+            continue
+        if env == "deployed" and config.get("disabledOnDeployed", False):
+            Printer.warn(f"[{name}] skipped (disabledOnDeployed: true)")
+            continue
+
+        try:
+            module = importlib.import_module(f"app.api.{name}")
+            blueprint = None
+            for _, obj in inspect.getmembers(module, inspect.isclass):
+                if issubclass(obj, JDMBlueprint) and obj is not JDMBlueprint:
+                    blueprint = obj()
+                    break
+            if blueprint is None:
+                blueprint = getattr(module, f"{name}_bp", None)
+
+            if blueprint is None:
+                Printer.error(f"[{name}] no JDMBlueprint subclass or '{name}_bp' found — skipped")
+                continue
+
+            app.register_blueprint(blueprint, url_prefix=config["link"])
+            Printer.success(f"[{name}] registered at {config['link']}")
+
+        except ModuleNotFoundError as e:
+            if f"app.api.{name}" in str(e):
+                Printer.error(f"[{name}] module app/api/{name}.py not found — skipped")
+            else:
+                Printer.error(f"[{name}] failed to import — missing dependency: {e}")
+        except Exception as e:
+            Printer.error(f"[{name}] unexpected error — {e}")
+
+def _load_events():
+    from jdm_electron_flask import JDMEvent
+    event_dir = os.path.join(os.getcwd(), "app", "event")
+    if not os.path.exists(event_dir):
+        return
+
+    for filename in os.listdir(event_dir):
+        if filename.endswith(".py") and not filename.startswith("_"):
+            module_name = filename[:-3]
+            try:
+                module = importlib.import_module(f"app.event.{module_name}")
+                for _, obj in inspect.getmembers(module, inspect.isclass):
+                    if issubclass(obj, JDMEvent) and obj is not JDMEvent:
+                        obj()
+
+                Printer.success(f"[event/{module_name}] loaded")
+            except Exception as e:
+                Printer.error(f"[event/{module_name}] failed to load — {e}")
+
+
+def create_app(config_name: str = None, static_folder: str = "static") -> Flask:
+    """
+    Create and configure the Flask application.
+
+    Args:
+        config_name: One of 'development', 'production', 'deployed'.
+                     Defaults to FLASK_ENV env var, then 'development'.
+        static_folder: Path to the static folder (React build output).
+
+    Returns:
+        Configured Flask app instance.
+    """
+    app = Flask(__name__, static_folder=static_folder, static_url_path="/static")
+    CORS(app, origins="*")
+
+    if config_name is None:
+        config_name = os.getenv("FLASK_ENV", "development")
+
+    _load_config(config_name, app)
+
+    Printer.init(config_name)
+    Printer.info(f"Environment: {config_name}")
+    Printer.info(f"jdm-electron-flask-py v{_get_version()}")
+
+    # ── SocketIO ──────────────────────────────────────────────
+    _socketio.init_app(
+        app,
+        cors_allowed_origins="*",
+        logger=config_name == "development",
+        engineio_logger=config_name == "development",
+    )
+    # ─────────────────────────────────────────────────────────
+    Printer.log("\n  Registering blueprints...")
+    _load_blueprints(app, config_name)
+
+    Printer.log("\n  Loading socket events...")
+    _load_events()
+
+    # ── React SPA catch-all ───────────────────────────────────
+    @app.route("/", defaults={"path": ""})
+    @app.route("/<path:path>")
+    def serve_react(path):
+        if path and os.path.exists(os.path.join(app.static_folder, path)):
+            return send_from_directory(app.static_folder, path)
+        return send_from_directory(app.static_folder, "index.html")
+    # ─────────────────────────────────────────────────────────
+
+    return app
+
+def _get_version() -> str:
+    try:
+        from jdm_electron_flask import __version__
+        return __version__
+    except Exception:
+        return "unknown"

jdm_electron_flask-1.0.0/jdm_electron_flask/core/blueprint.py

@@ -0,0 +1,80 @@
+import functools
+import inspect
+from flask import Blueprint, request
+from jdm_electron_flask.utils.responses import success, error
+from jdm_electron_flask.utils.validators import validate_json, require_access
+from typing import Callable, List, Union
+
+
+class JDMBlueprint(Blueprint):
+
+    def __init__(self, name: str, import_name: str, **kwargs):
+        super().__init__(name, import_name, **kwargs)
+        self.success = success
+        self.error   = error
+        self.register_error_handler(404, self._handle_404)
+        self.register_error_handler(500, self._handle_500)
+        self._bind_all()
+
+    def _bind_all(self):
+        for _, func in inspect.getmembers(self.__class__, predicate=inspect.isfunction):
+            if hasattr(func, "_jdm_route"):
+                self._bind(func._jdm_route, func)
+
+    def _bind(self, definition: dict, func: Callable):
+        path     = definition["path"]
+        methods  = definition["methods"]
+        auth     = definition.get("auth", False)
+        validate = definition.get("validate")
+
+        wrapped = func
+        if validate:
+            fields  = validate if isinstance(validate, list) else [validate]
+            wrapped = validate_json(*fields)(wrapped)
+        if auth:
+            wrapped = require_access(wrapped)
+
+        if inspect.iscoroutinefunction(func) and not inspect.iscoroutinefunction(wrapped):
+            inner = wrapped
+            @functools.wraps(func)
+            async def async_wrapper(*args, **kwargs):
+                return await inner(*args, **kwargs)
+            wrapped = async_wrapper
+
+        self.add_url_rule(path, func.__name__, wrapped, methods=methods)
+
+    # ── Route decorators ──────────────────────────────────────
+
+    @staticmethod
+    def get(path: str, auth: bool = False):
+        def decorator(func: Callable):
+            func._jdm_route = {"path": path, "methods": ["GET"], "auth": auth}
+            return func
+        return decorator
+
+    @staticmethod
+    def post(path: str, auth: bool = True, validate: Union[str, List[str], None] = None):
+        def decorator(func: Callable):
+            func._jdm_route = {"path": path, "methods": ["POST"], "auth": auth, "validate": validate}
+            return func
+        return decorator
+
+    @staticmethod
+    def put(path: str, auth: bool = True, validate: Union[str, List[str], None] = None):
+        def decorator(func: Callable):
+            func._jdm_route = {"path": path, "methods": ["PUT"], "auth": auth, "validate": validate}
+            return func
+        return decorator
+
+    @staticmethod
+    def delete(path: str, auth: bool = True):
+        def decorator(func: Callable):
+            func._jdm_route = {"path": path, "methods": ["DELETE"], "auth": auth}
+            return func
+        return decorator
+
+    def _handle_404(self, e):
+        return error(f"Route not found: {request.path}", status=404)
+
+    def _handle_500(self, e):
+        return error("Internal server error", status=500)

jdm_electron_flask-1.0.0/jdm_electron_flask/core/config.py

@@ -0,0 +1,31 @@
+import os
+import sys
+from dotenv import load_dotenv
+
+def _load_env():
+    """Load .env from PyInstaller bundle first, then CWD."""
+    meipass = getattr(sys, "_MEIPASS", None)
+    if meipass:
+        load_dotenv(os.path.join(meipass, ".env"))
+    load_dotenv(os.path.join(os.path.abspath("."), ".env"), override=False)
+
+_load_env()
+
+class JDMConfig:
+    """Base config. Inherit this to add your own shared fields."""
+    SECRET_KEY = os.getenv("SECRET_KEY", "change-me-in-production")
+
+
+class JDMDevelopmentConfig(JDMConfig):
+    FLASK_ENV = "development"
+    DEBUG     = True
+
+
+class JDMProductionConfig(JDMConfig):
+    FLASK_ENV = "production"
+    DEBUG     = False
+
+
+class JDMDeployedConfig(JDMConfig):
+    FLASK_ENV = "deployed"
+    DEBUG     = False

jdm_electron_flask-1.0.0/jdm_electron_flask/core/event.py

@@ -0,0 +1,45 @@
+# jdm_electron_flask/event.py
+from flask_socketio import emit
+from jdm_electron_flask import get_socketio
+
+class JDMEvent:
+    """
+    Base class for SocketIO event handlers.
+
+    Usage:
+        from jdm_electron_flask import JDMEvent
+
+        class ConnectEvent(JDMEvent):
+            def on_connect(self):
+                self.emit("connected", {"message": "Socket connected"})
+
+            def on_disconnect(self):
+                pass
+
+            def on_ping_server(self, data):
+                self.emit("pong_client", {"echo": data})
+    """
+
+    def __init__(self):
+        self._socketio = get_socketio()
+        self._register()
+
+    def emit(self, event: str, data=None, **kwargs):
+        """Shorthand emit."""
+        emit(event, data, **kwargs)
+
+    def _register(self):
+        """
+        Auto-register methods named on_<event> as SocketIO event handlers.
+        on_connect     → "connect"
+        on_disconnect  → "disconnect"
+        on_ping_server → "ping_server"
+        """
+        for attr in dir(self):
+            if not attr.startswith("on_"):
+                continue
+            handler = getattr(self, attr)
+            if not callable(handler):
+                continue
+            event_name = attr[3:]
+            self._socketio.on_event(event_name, handler)

jdm_electron_flask-1.0.0/jdm_electron_flask/utils/printer.py

@@ -0,0 +1,69 @@
+import os
+import logging
+from datetime import datetime
+
+
+class Printer:
+    """
+    Environment-aware logger.
+
+    - development: prints to console with icons
+    - production / deployed: writes to logs/<date>.log
+    """
+
+    _logger = None
+    _env: str = None
+
+    @classmethod
+    def init(cls, env: str):
+        cls._env = env
+
+        if env != "development":
+            log_dir = os.path.join(os.getcwd(), "logs")
+            os.makedirs(log_dir, exist_ok=True)
+
+            log_filename = datetime.now().strftime("%Y-%m-%d") + ".log"
+            log_path = os.path.join(log_dir, log_filename)
+
+            logging.basicConfig(
+                filename=log_path,
+                level=logging.INFO,
+                format="%(asctime)s [%(levelname)s] %(message)s",
+                datefmt="%H:%M:%S",
+            )
+            cls._logger = logging.getLogger("jdm")
+
+    @classmethod
+    def log(cls, message: str):
+        if cls._env == "development":
+            print(message)
+        else:
+            cls._logger.info(message)
+
+    @classmethod
+    def success(cls, message: str):
+        if cls._env == "development":
+            print(f"  ✔  {message}")
+        else:
+            cls._logger.info(f"[SUCCESS] {message}")
+
+    @classmethod
+    def warn(cls, message: str):
+        if cls._env == "development":
+            print(f"  ⚠  {message}")
+        else:
+            cls._logger.warning(f"[WARN] {message}")
+
+    @classmethod
+    def error(cls, message: str):
+        if cls._env == "development":
+            print(f"  ✖  {message}")
+        else:
+            cls._logger.error(f"[ERROR] {message}")
+
+    @classmethod
+    def info(cls, message: str):
+        if cls._env == "development":
+            print(f"  ℹ  {message}")
+        else:
+            cls._logger.info(f"[INFO] {message}")

jdm_electron_flask-1.0.0/jdm_electron_flask/utils/responses.py

@@ -0,0 +1,15 @@
+from flask import jsonify
+
+def success(data=None, message="OK", status=200):
+    """Unified success response."""
+    resp = {"success": True, "message": message}
+    if data is not None:
+        resp["data"] = data
+    return jsonify(resp), status
+
+def error(message, status=400, details=None):
+    """Unified error response."""
+    resp = {"success": False, "message": message}
+    if details:
+        resp["details"] = details
+    return jsonify(resp), status

jdm_electron_flask-1.0.0/jdm_electron_flask/utils/validators.py

@@ -0,0 +1,106 @@
+# import os
+# from functools import wraps
+# from flask import request
+# from .responses import error
+
+# def validate_json(*required_fields):
+#     """Decorator: ensure request has JSON and required fields."""
+#     def decorator(f):
+#         @wraps(f)
+#         def wrapper(*args, **kwargs):
+#             if not request.is_json:
+#                 return error("Request must be application/json", 415)
+#             data = request.get_json()
+#             if data is None:
+#                 return error("Invalid or empty JSON body", 400)
+#             missing = [field for field in required_fields if field not in data]
+#             if missing:
+#                 return error(f"Missing fields: {', '.join(missing)}", 400)
+#             return f(data, *args, **kwargs)
+#         return wrapper
+#     return decorator
+
+# def require_access(f):
+#     """Decorator: validates X-Auth-Token header against API_ACCESS in .env."""
+#     @wraps(f)
+#     def wrapper(*args, **kwargs):
+#         auth_header = request.headers.get("X-Auth-Token", "")
+#         if not auth_header.startswith("Bearer "):
+#             return error("Missing or invalid X-Auth-Token header", 401)
+
+#         token = auth_header.split(" ", 1)[1].strip()
+#         expected = os.getenv("API_ACCESS", "")
+
+#         if not expected:
+#             return error("Server is not configured with an API access token", 500)
+#         if token != expected:
+#             return error("Unauthorized", 401)
+
+#         return f(*args, **kwargs)
+#     return wrapper
+
+import os
+import inspect
+from functools import wraps
+from flask import request
+from .responses import error
+
+def validate_json(*required_fields):
+    """Decorator: ensure request has JSON and required fields."""
+    def decorator(f):
+        if inspect.iscoroutinefunction(f):
+            @wraps(f)
+            async def wrapper(*args, **kwargs):
+                if not request.is_json:
+                    return error("Request must be application/json", 415)
+                data = request.get_json()
+                if data is None:
+                    return error("Invalid or empty JSON body", 400)
+                missing = [field for field in required_fields if field not in data]
+                if missing:
+                    return error(f"Missing fields: {', '.join(missing)}", 400)
+                return await f(data, *args, **kwargs)
+        else:
+            @wraps(f)
+            def wrapper(*args, **kwargs):
+                if not request.is_json:
+                    return error("Request must be application/json", 415)
+                data = request.get_json()
+                if data is None:
+                    return error("Invalid or empty JSON body", 400)
+                missing = [field for field in required_fields if field not in data]
+                if missing:
+                    return error(f"Missing fields: {', '.join(missing)}", 400)
+                return f(data, *args, **kwargs)
+        return wrapper
+    return decorator
+
+def require_access(f):
+    """Decorator: validates X-Auth-Token header against API_ACCESS in .env."""
+    if inspect.iscoroutinefunction(f):
+        @wraps(f)
+        async def wrapper(*args, **kwargs):
+            auth_header = request.headers.get("X-Auth-Token", "")
+            if not auth_header.startswith("Bearer "):
+                return error("Missing or invalid X-Auth-Token header", 401)
+            token = auth_header.split(" ", 1)[1].strip()
+            expected = os.getenv("API_ACCESS", "")
+            if not expected:
+                return error("Server is not configured with an API access token", 500)
+            if token != expected:
+                return error("Unauthorized", 401)
+            return await f(*args, **kwargs)
+    else:
+        @wraps(f)
+        def wrapper(*args, **kwargs):
+            auth_header = request.headers.get("X-Auth-Token", "")
+            if not auth_header.startswith("Bearer "):
+                return error("Missing or invalid X-Auth-Token header", 401)
+            token = auth_header.split(" ", 1)[1].strip()
+            expected = os.getenv("API_ACCESS", "")
+            if not expected:
+                return error("Server is not configured with an API access token", 500)
+            if token != expected:
+                return error("Unauthorized", 401)
+            return f(*args, **kwargs)
+    return wrapper

jdm_electron_flask-1.0.0/jdm_electron_flask.egg-info/PKG-INFO

@@ -0,0 +1,183 @@
+Metadata-Version: 2.4
+Name: jdm-electron-flask
+Version: 1.0.0
+Summary: The Python backbone for jdm-electron-flask desktop apps
+Author-email: JDM-Github <jdmaster888@gmail.com>
+License: MIT
+Project-URL: Homepage, https://github.com/JDM-Github/jdm-electron-flask
+Project-URL: Repository, https://github.com/JDM-Github/jdm-electron-flask
+Project-URL: Issues, https://github.com/JDM-Github/jdm-electron-flask/issues
+Keywords: flask,electron,desktop,socketio,jdm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: flask>=3.0.0
+Requires-Dist: flask-cors>=4.0.0
+Requires-Dist: flask-socketio>=5.3.0
+Requires-Dist: simple-websocket>=1.0.0
+
+# jdm-electron-flask (Python)
+
+> The Python backbone for [`jdm-electron-flask`](https://github.com/JDM-Github/jdm-electron-flask) desktop apps.
+
+This package ships inside every project scaffolded by the `jdm-cli electron-flask` plugin. It provides the app factory, dynamic API registration, SocketIO setup, and environment-aware logging — so you build features, not boilerplate.
+
+---
+
+## Installation
+
+You don't install this manually. It's included in the scaffolded `requirements.txt`:
+
+```
+jdm-electron-flask==1.0.0
+```
+
+If you need it standalone:
+
+```bash
+pip install jdm-electron-flask
+```
+
+---
+
+## What it provides
+
+### `create_app`
+The Flask app factory. Handles config loading, SocketIO init, blueprint auto-discovery, and the React SPA catch-all route.
+
+```python
+# run.py
+from jdm_electron_flask import create_app, get_socketio
+
+app = create_app()
+socketio = get_socketio()
+
+if __name__ == "__main__":
+    socketio.run(app, host="0.0.0.0", port=5000, debug=True)
+```
+
+### `JDMBlueprint`
+Extended Blueprint with built-in response helpers.
+
+```python
+from jdm_electron_flask import JDMBlueprint
+
+health_bp = JDMBlueprint("health", __name__)
+
+@health_bp.route("/health")
+def health():
+    return health_bp.success({"status": "ok"})
+```
+
+### `JDMEvents`
+Base class for organizing socket event handlers.
+
+```python
+from jdm_electron_flask import JDMEvents
+
+class ConnectEvents(JDMEvents):
+    def register(self):
+        @self.socketio.on("connect")
+        def on_connect():
+            self.on_connect()
+
+        @self.socketio.on("ping_server")
+        def on_ping(data):
+            self.emit("pong_client", {"echo": data})
+
+ConnectEvents().register()
+```
+
+### `Printer`
+Environment-aware logger. Prints in development, writes to `logs/<date>.log` in production/deployed.
+
+```python
+from jdm_electron_flask import Printer
+
+Printer.success("Blueprint registered")
+Printer.warn("Something is off")
+Printer.error("Something broke")
+Printer.info("Just FYI")
+```
+
+### Response helpers
+
+```python
+from jdm_electron_flask import success, error, paginate
+
+return success({"user": "JDM"})
+return error("Not found", status=404)
+return paginate(items, total=100, page=1, per_page=10)
+```
+
+### Validators
+
+```python
+from jdm_electron_flask import validate_fields
+
+valid, msg, data = validate_fields(["name", "email"])
+if not valid:
+    return error(msg)
+```
+
+---
+
+## Dynamic API registration
+
+Routes are controlled by `config/api.json`:
+
+```json
+{
+    "health": {
+        "link": "/api",
+        "masterEnabled": true
+    },
+    "users": {
+        "link": "/api/users",
+        "masterEnabled": true,
+        "disabledOnProduction": false,
+        "disabledOnDeployed": false
+    }
+}
+```
+
+Adding a new route:
+1. Add entry to `config/api.json`
+2. Create `app/api/users.py` with a `users_bp` blueprint
+
+That's it. No touching `__init__.py` ever again.
+
+---
+
+## Environment modes
+
+| `FLASK_ENV` | Behavior |
+|---|---|
+| `development` | Debug on, console logging, all routes enabled |
+| `production` | Debug off, file logging, respects `disabledOnProduction` |
+| `deployed` | Debug off, file logging, respects `disabledOnDeployed` |
+
+---
+
+## Companion
+
+This package is the Python half of the `jdm-electron-flask` ecosystem:
+
+| Package | Role |
+|---|---|
+| [`jdm-electron-flask`](https://www.npmjs.com/package/jdm-electron-flask) (npm) | CLI plugin — scaffold, build, compile |
+| `jdm-electron-flask` (PyPI) | Backend library — app factory, blueprints, sockets |
+
+---
+
+## License
+
+MIT © [JDM-Github](https://github.com/JDM-Github)

jdm_electron_flask-1.0.0/jdm_electron_flask.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+README.md
+pyproject.toml
+jdm_electron_flask/__init__.py
+jdm_electron_flask.egg-info/PKG-INFO
+jdm_electron_flask.egg-info/SOURCES.txt
+jdm_electron_flask.egg-info/dependency_links.txt
+jdm_electron_flask.egg-info/requires.txt
+jdm_electron_flask.egg-info/top_level.txt
+jdm_electron_flask/core/app.py
+jdm_electron_flask/core/blueprint.py
+jdm_electron_flask/core/config.py
+jdm_electron_flask/core/event.py
+jdm_electron_flask/utils/printer.py
+jdm_electron_flask/utils/responses.py
+jdm_electron_flask/utils/validators.py

jdm_electron_flask-1.0.0/jdm_electron_flask.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

jdm_electron_flask-1.0.0/jdm_electron_flask.egg-info/requires.txt

@@ -0,0 +1,4 @@
+flask>=3.0.0
+flask-cors>=4.0.0
+flask-socketio>=5.3.0
+simple-websocket>=1.0.0

jdm_electron_flask-1.0.0/jdm_electron_flask.egg-info/top_level.txt

@@ -0,0 +1 @@
+jdm_electron_flask

jdm_electron_flask-1.0.0/pyproject.toml

@@ -0,0 +1,39 @@
+[build-system]
+requires = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "jdm-electron-flask"
+version = "1.0.0"
+description = "The Python backbone for jdm-electron-flask desktop apps"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "JDM-Github", email = "jdmaster888@gmail.com" }]
+keywords = ["flask", "electron", "desktop", "socketio", "jdm"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.9"
+dependencies = [
+    "flask>=3.0.0",
+    "flask-cors>=4.0.0",
+    "flask-socketio>=5.3.0",
+    "simple-websocket>=1.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/JDM-Github/jdm-electron-flask"
+Repository = "https://github.com/JDM-Github/jdm-electron-flask"
+Issues = "https://github.com/JDM-Github/jdm-electron-flask/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["jdm_electron_flask*"]

jdm_electron_flask-1.0.0/setup.cfg

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