Initial commit

Author: maximebf

.gitignore

@@ -0,0 +1,5 @@
+dist
+.venv
+*.pyc
+__pycache__
+.coverage

LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2024 Maxime Bouroumeau-Fuseau
+
+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.

README.md

@@ -0,0 +1,59 @@
+# Flask-SQLORM
+
+Flask integration for [sqlorm](https://github.com/hyperflask/sqlorm)
+
+## Setup
+
+Install:
+
+    $ pip install flask-sqlorm
+
+Setup:
+
+```python
+from flask import Flask
+from flask_sqlorm import FlaskSQLORM
+
+app = Flask()
+db = FlaskSQLORM(app, "sqlite://:memory:")
+```
+
+## Usage
+
+All exports from the `sqlorm` package are available from the extension instance.
+
+Define some models:
+
+```python
+class Task(db.Model):
+    id: db.PrimaryKey[int]
+    title: str
+    done: bool = db.Column(default=False)
+```
+
+Start a transaction using the db object:
+
+```python
+with db:
+    Task.create(title="first task")
+```
+
+In views, the current session is available using `db.session`
+
+## Configuration
+
+Configure the sqlorm engine using the extension's constructor or `init_app()`. Configuration of the engine is performed using the URI method.
+Additional engine parameters can be provided as keyword arguments.
+
+Configuration can also be provided via the app config under the `SQLORM_` namespace. Use `SQLORM_URI` to define the database URI.
+
+## Additional utilities provided by Flask-SQLORM
+
+Model classes have the additional methods:
+
+ - `find_one_or_404`: same as `find_one` but throw a 404 when no results are returned
+ - `get_or_404`: same as `get` but throw a 404 when no results are returned
+
+## Managing the schema
+
+Some CLI commands are available under the *db* command group. Check out `flask db --help` for a list of subcommands.

example.py

@@ -0,0 +1,62 @@
+from flask import Flask, render_template_string, request, redirect, url_for
+from flask_sqlorm import FlaskSQLORM
+import logging
+
+
+app = Flask(__name__)
+app.logger.setLevel(logging.DEBUG)
+db = FlaskSQLORM(app)
+
+
+class Task(db.Model):
+    id: db.PrimaryKey[int]
+    title: str
+    done: bool
+
+    def toggle(self):
+        "UPDATE Task SET done = not done WHERE id = %(self.id)s RETURNING done"
+
+
+db.create_all()
+
+
+@app.route("/")
+def index():
+    tasks = Task.find_all()
+    return render_template_string("""
+        <ul>
+            {% for task in tasks %}
+                <li>
+                    <form action="{{url_for("toggle", task_id=task.id)}}" method="post">
+                        <label>
+                            <input type="checkbox" {% if task.done %}checked{% endif %} onchange="event.target.form.submit()">
+                            {{task.title}}
+                        </label>
+                    </form>
+                </li>
+            {% endfor %}
+        </ul>
+        <form method="post" action="{{url_for("create")}}">
+            <input type="text" name="title">
+            <button type="submit">Add</button>
+        </form>
+    """, tasks=tasks)
+
+
+@app.post("/create")
+def create():
+    with db:
+        Task.create(title=request.form["title"], done=False)
+    return redirect(url_for("index"))
+
+
+@app.post("/toggle/<task_id>")
+def toggle(task_id):
+    with db:
+        task = Task.get_or_404(task_id)
+        task.toggle()
+    return redirect(url_for("index"))
+
+
+if __name__ == "__main__":
+    app.run(debug=True, port=6600)

flask_sqlorm.py

@@ -0,0 +1,113 @@
+from sqlorm import Engine, Model as _Model, get_current_session, init_db, migrate, create_all
+from sqlorm.engine import session_context
+import sqlorm
+import abc
+import os
+import click
+from flask import g, abort, has_request_context
+from flask.cli import AppGroup
+from werkzeug.local import LocalProxy
+
+
+class FlaskSQLORM:
+    def __init__(self, app=None, *args, **kwargs):
+        if app:
+            self.init_app(app, *args, **kwargs)
+
+    def init_app(self, app, database_uri="sqlite://:memory:", **engine_kwargs):
+        self.app = app
+
+        for key in dir(sqlorm):
+            if not key.startswith("_") and not hasattr(self, key):
+                setattr(self, key, getattr(sqlorm, key))
+
+        config = app.config.get_namespace("SQLORM_")
+        database_uri = config.pop("uri", database_uri)
+        for key, value in engine_kwargs.items():
+            config.setdefault(key, value)
+        config.setdefault("logger", app.logger)
+        if database_uri.startswith("sqlite://"):
+            config.setdefault("fine_tune", True)
+
+        self.engine = Engine.from_uri(database_uri, **config)
+        self.session = LocalProxy(get_current_session)
+        self.Model = Model.bind(self.engine)
+
+        @app.before_request
+        def start_db_session():
+            g.sqlorm_session = self.engine.make_session()
+            session_context.push(g.sqlorm_session)
+
+        @app.after_request
+        def close_db_session(response):
+            session_context.pop()
+            g.sqlorm_session.close()
+            return response
+        
+        cli = AppGroup("db", help="Commands to manage your database")
+
+        @cli.command()
+        def init():
+            """Initializes the database, either creating tables for models or running migrations if some exists"""
+            self.init_db()
+
+        @cli.command()
+        def create_all():
+            """Create all tables associated to models"""
+            self.create_all()
+
+        @cli.command()
+        @click.option("--from", "from_", type=int)
+        @click.option("--to", type=int)
+        @click.option("--dryrun", is_flag=True)
+        @click.option("--ignore-schema-version", is_flag=True)
+        def migrate(from_, to, dryrun, ignore_schema_version):
+            """Run database migrations from the migrations folder in your app root path"""
+            self.migrate(from_version=from_, to_version=to, dryrun=dryrun, use_schema_version=not ignore_schema_version)
+
+        app.cli.add_command(cli)
+
+    def __enter__(self):
+        if has_request_context():
+            return g.sqlorm_session.__enter__()
+        return self.engine.__enter__()
+
+    def __exit__(self, exc_type, exc_value, exc_tb):
+        if has_request_context():
+            g.sqlorm_session.__exit__(exc_type, exc_value, exc_tb)
+        else:
+            self.engine.__exit__(exc_type, exc_value, exc_tb)
+
+    def create_all(self, **kwargs):
+        kwargs.setdefault("model_registry", self.Model.__model_registry__)
+        with self.engine:
+            create_all(**kwargs)
+
+    def init_db(self, **kwargs):
+        kwargs.setdefault("path", os.path.join(self.app.root_path, "migrations"))
+        kwargs.setdefault("model_registry", self.Model.__model_registry__)
+        kwargs.setdefault("logger", self.app.logger)
+        with self.engine:
+            init_db(**kwargs)
+
+    def migrate(self, **kwargs):
+        kwargs.setdefault("path", os.path.join(self.app.root_path, "migrations"))
+        kwargs.setdefault("logger", self.app.logger)
+        with self.engine:
+            migrate(**kwargs)
+    
+
+class Model(_Model, abc.ABC):
+    @classmethod
+    def find_one_or_404(cls, *args, **kwargs):
+        obj = cls.find_one(*args, **kwargs)
+        if not obj:
+            abort(404)
+        return obj
+
+    @classmethod
+    def get_or_404(cls, *args, **kwargs):
+        obj = cls.get(*args, **kwargs)
+        if not obj:
+            abort(404)
+        return obj