zou 0.19.15__py3-none-any.whl → 0.20.11__py3-none-any.whl

zou/app/utils/redis.py

@@ -0,0 +1,11 @@
+from zou.app import config
+
+
+def get_redis_url(db_index):
+    redis_host = config.KEY_VALUE_STORE["host"]
+    redis_port = config.KEY_VALUE_STORE["port"]
+    if config.KEY_VALUE_STORE["password"]:
+        redis_password = f":{config.KEY_VALUE_STORE['password']}@"
+    else:
+        redis_password = ""
+    return f"redis://{redis_password}{redis_host}:{redis_port}/{db_index}"

zou/app/utils/saml.py

@@ -0,0 +1,51 @@
+import requests
+
+from saml2 import (
+    BINDING_HTTP_POST,
+    BINDING_HTTP_REDIRECT,
+)
+from saml2.client import Saml2Client
+from saml2.config import Config as Saml2Config
+
+from zou.app import config
+
+
+def saml_client_for(metadata_url):
+    """
+    Given the name of an IdP, return a configuation.
+    The configuration is a hash for use by saml2.config.Config
+    """
+    acs_url = (
+        f"{config.DOMAIN_PROTOCOL}://{config.DOMAIN_NAME}/api/auth/saml/sso"
+    )
+
+    rv = requests.get(metadata_url)
+
+    settings = {
+        "entityid": f"{config.DOMAIN_PROTOCOL}://{config.DOMAIN_NAME}/api/auth/saml/login",
+        "metadata": {"inline": [rv.text]},
+        "service": {
+            "sp": {
+                "endpoints": {
+                    "assertion_consumer_service": [
+                        (acs_url, BINDING_HTTP_REDIRECT),
+                        (acs_url, BINDING_HTTP_POST),
+                    ],
+                },
+                # Don't verify that the incoming requests originate from us via
+                # the built-in cache for authn request ids in pysaml2
+                "allow_unsolicited": True,
+                # Don't sign authn requests, since signed requests only make
+                # sense in a situation where you control both the SP and IdP
+                "authn_requests_signed": False,
+                "logout_requests_signed": True,
+                "want_assertions_signed": True,
+                "want_response_signed": False,
+            },
+        },
+    }
+    spConfig = Saml2Config()
+    spConfig.load(settings)
+    spConfig.allow_unknown_attributes = True
+    saml_client = Saml2Client(config=spConfig)
+    return saml_client

zou/app/utils/string.py

@@ -6,6 +6,8 @@ def strtobool(val):
     """
     if isinstance(val, bool):
         return val
+    if isinstance(val, int):
+        return bool(val)
     elif val.lower() in ("y", "yes", "t", "true", "on", "1"):
         return True
     elif val.lower() in ("n", "no", "f", "false", "off", "0"):

zou/app/utils/thumbnail.py

@@ -76,7 +76,7 @@ def make_im_bigger_if_needed(im, size):
     return im
 
 
-def fit_to_target_size(im, size):
+def fit_to_target_size(im, size, crop=False):
     """
     Make sure that the image is contained in the size given in parameter
     (shorten width and/or height proporitionnally to expected ratio).
@@ -131,11 +131,13 @@ def turn_into_thumbnail(file_path, size=None):
     return file_path
 
 
-def resize(file_path, size):
+def resize(file_path, size, crop=False):
     """
     Resize given picture
     """
     im = Image.open(file_path)
+    if crop:
+        im = prepare_image_for_thumbnail(im, size)
     im = im.resize(size, Image.Resampling.LANCZOS)
     if im.mode == "CMYK":
         im = im.convert("RGB")

zou/cli.py

@@ -30,7 +30,7 @@ def cli():
 @cli.command()
 def version():
     """
-    Returns current installation version.
+    Return current installation version.
     """
     from zou import __version__
 
@@ -39,7 +39,7 @@ def version():
 
 @cli.command()
 def init_db():
-    "Creates datababase table (database must be created through PG client)."
+    "Create database table (database must be created through PG client)."
 
     print("Creating database and tables...")
     with app.app_context():
@@ -47,6 +47,22 @@ def init_db():
     print("Database and tables created.")
 
 
+@cli.command()
+def is_db_ready():
+    """
+    Return a message telling whether the database is initialized or not.
+    """
+    with app.app_context():
+        is_init = dbhelpers.is_init()
+        if is_init:
+            print("Database is initialized.")
+        else:
+            print(
+                "Database is not initialized. "
+                "Run 'zou init-db' and 'zou init-data'."
+            )
+
+
 @cli.command()
 @click.option("--message", default="")
 def migrate_db(message):
@@ -82,7 +98,7 @@ def clear_db():
 
 @cli.command()
 def reset_db():
-    "Drop all tables then recreates them."
+    "Drop all tables, then recreate them."
     with app.app_context():
         print("Deleting database and tables...")
         dbhelpers.drop_all()
@@ -96,7 +112,7 @@ def reset_db():
 @click.option("--no-telemetry", is_flag=True, default=False)
 def upgrade_db(no_telemetry=False):
     """
-    Upgrade database schema. Send anonymized statistics to our telemery
+    Upgrade database schema. Send anonymized statistics to our telemetry
     services (user and preview amounts). It allows us to size the Kitsu
     community.
     """
@@ -140,7 +156,7 @@ def reset_migrations():
 
 @cli.command()
 @click.argument("email")
-@click.option("--password", required=True)
+@click.option("--password", default=None)
 def create_admin(email, password):
     """
     Create an admin user to allow usage of the API when database is empty.
@@ -149,10 +165,18 @@ def create_admin(email, password):
         try:
             person = persons_service.get_person_by_email(email)
             if person["role"] != "admin":
-                persons_service.update_person(person["id"], {"role": "admin"})
+                persons_service.update_person(
+                    person["id"],
+                    {"role": "admin"},
+                    bypass_protected_accounts=True,
+                )
                 print("Existing user's role has been upgraded to 'admin'.")
         except PersonNotFoundException:
             try:
+                if password is None:
+                    raise click.MissingParameter(
+                        param_type="option", param_hint="--password"
+                    )
                 auth.validate_password(password)
                 # Allow "admin@example.com" to be invalid.
                 if email != "admin@example.com":
@@ -192,7 +216,7 @@ def clear_all_auth_tokens():
 
 @cli.command()
 def init_data():
-    "Generates minimal data set required to run Kitsu."
+    "Generate minimal data set required to run Kitsu."
     commands.init_data()
 
 
@@ -397,7 +421,7 @@ def sync_file_changes(event_source, source, logs_directory):
 @click.option("--source", default="http://localhost:8080/api")
 @click.option("--minutes", default=0)
 @click.option("--page-size", default=300)
-def sync_last_events(source, minutes, page_size):
+def sync_last_events(source, minutes, limit):
     """
     Retrieve last events that occured on source instance and import data related
     to them. It expects that credentials to connect to source instance are
@@ -406,7 +430,7 @@ def sync_last_events(source, minutes, page_size):
     login = os.getenv("SYNC_LOGIN")
     password = os.getenv("SYNC_PASSWORD")
     commands.import_last_changes_from_another_instance(
-        source, login, password, minutes=minutes, page_size=page_size
+        source, login, password, minutes=minutes, limit=limit
     )
 
 
@@ -414,16 +438,16 @@ def sync_last_events(source, minutes, page_size):
 @click.option("--source", default="http://localhost:8080/api")
 @click.option("--minutes", default=20)
 @click.option("--page-size", default=50)
-def sync_last_files(source, minutes, page_size):
+def sync_last_files(source, minutes, limit):
     """
-    Retrieve last preview files and thumbnails updloaded on source instance.
+    Retrieve last preview files and thumbnails uploaded on source instance.
     It expects that credentials to connect to source instance are
     given through SYNC_LOGIN and SYNC_PASSWORD environment variables.
     """
     login = os.getenv("SYNC_LOGIN")
     password = os.getenv("SYNC_PASSWORD")
     commands.import_last_file_changes_from_another_instance(
-        source, login, password, minutes=minutes, page_size=page_size
+        source, login, password, minutes=minutes, limit=limit
     )
 
 
@@ -456,13 +480,13 @@ def upload_files_to_cloud_storage(days):
 
 
 @cli.command()
-@click.option("--projectid")
-def clean_tasks_data(projectid):
+@click.option("--project-id")
+def clean_tasks_data(project_id):
     """
     Reset task models data (retake count, wip start date and end date)
     """
-    if projectid is not None:
-        commands.reset_tasks_data(projectid)
+    if project_id is not None:
+        commands.reset_tasks_data(project_id)
 
 
 @cli.command()
@@ -470,7 +494,7 @@ def clean_tasks_data(projectid):
 def remove_old_data(days):
     """
     Remove old events, notifications and login logs older than 90 days
-    (by deafult).
+    (by default).
     """
     commands.remove_old_data(days)
 
@@ -569,7 +593,7 @@ def reset_breakdown_data():
 @click.option("--email", required=True)
 @click.option("--name", required=True)
 @click.option(
-    "--expiration_date",
+    "--expiration-date",
     required=False,
     default=None,
     show_default=True,
@@ -593,5 +617,39 @@ def create_bot(
     )
 
 
+@cli.command()
+@click.option(
+    "--preview-file-id",
+    required=False,
+    default=None,
+    show_default=True,
+)
+@click.option(
+    "--project-id",
+    required=False,
+    default=None,
+    show_default=True,
+)
+@click.option("--all-broken", is_flag=True, default=False, show_default=True)
+@click.option(
+    "--all-processing", is_flag=True, default=False, show_default=True
+)
+def renormalize_movie_preview_files(
+    preview_file_id,
+    project_id,
+    all_broken,
+    all_processing,
+):
+    """
+    Renormalize all preview files.
+    """
+    commands.renormalize_movie_preview_files(
+        preview_file_id,
+        project_id,
+        all_broken,
+        all_processing,
+    )
+
+
 if __name__ == "__main__":
     cli()

zou/debug.py

@@ -13,6 +13,8 @@ socketio = SocketIO(app, cors_allowed_origins=[], cors_credentials=False)
 
 if __name__ == "__main__":
     print(
-        "The Kitsu API server is listening on port %s..." % config.DEBUG_PORT
+        f"The Kitsu API server is listening on http://{config.DEBUG_HOST}:{config.DEBUG_PORT}"
+    )
+    socketio.run(
+        app, host=config.DEBUG_HOST, port=config.DEBUG_PORT, debug=True
     )
-    socketio.run(app, port=config.DEBUG_PORT, debug=True)

zou/event_stream.py

@@ -2,25 +2,25 @@ from gevent import monkey
 
 monkey.patch_all()
 
-from flask import Flask, jsonify
+from flask import jsonify
 from flask_jwt_extended import (
     get_jwt_identity,
     jwt_required,
     verify_jwt_in_request,
-    JWTManager,
 )
 from flask_socketio import SocketIO, disconnect, join_room, emit
-from flask_sqlalchemy import SQLAlchemy
-from zou.app import config
-from zou.app.stores import auth_tokens_store
-from zou.app.utils.monitoring import init_monitoring
-from zou.app.utils.flask import ORJSONProvider
-from zou.app.services import persons_service
+
+from zou.app import config, app
+from zou.app.utils.redis import get_redis_url
 
 server_stats = {"nb_connections": 0}
 rooms_data = {}
 
-# Review room helpers
+redis_url = get_redis_url(config.KV_EVENTS_DB_INDEX)
+socketio = SocketIO(
+    logger=True, cors_allowed_origins=[], cors_credentials=False
+)
+socketio.init_app(app, message_queue=redis_url, async_mode="gevent")
 
 
 def _get_empty_room(current_frame=0):
@@ -78,174 +78,131 @@ def _update_room_playing_status(data, room):
     return room
 
 
-# Database helpers
+@app.route("/", methods=["GET"])
+def index():
+    return jsonify({"name": "%s Event stream" % config.APP_NAME})
 
 
-def get_redis_url():
-    redis_host = config.KEY_VALUE_STORE["host"]
-    redis_port = config.KEY_VALUE_STORE["port"]
-    db_index = config.KV_EVENTS_DB_INDEX
-    return "redis://%s:%s/%s" % (redis_host, redis_port, db_index)
+@app.route("/stats", methods=["GET"])
+def stats():
+    return jsonify(server_stats)
 
 
-# Routes
+@socketio.on("connect", namespace="/events")
+def connected(_):
+    try:
+        verify_jwt_in_request()
+        server_stats["nb_connections"] += 1
+        app.logger.info("New websocket client connected")
+    except Exception:
+        app.logger.info("New websocket client failed to connect")
+        disconnect()
+        return False
 
 
-def set_info_routes(socketio, app):
-    @app.route("/", methods=["GET"])
-    def index():
-        return jsonify({"name": "%s Event stream" % config.APP_NAME})
+@socketio.on("disconnect", namespace="/events")
+def disconnected(_):
+    try:
+        verify_jwt_in_request()
+        user_id = get_jwt_identity()
+        # needed to be able to clear empty rooms
+        tmp_rooms_data = dict(rooms_data)
+        for room_id in tmp_rooms_data:
+            _leave_room(room_id, user_id)
+        server_stats["nb_connections"] -= 1
+        app.logger.info("Websocket client disconnected")
+    except Exception:
+        pass
+
+
+@socketio.on_error("/events")
+def on_error(error):
+    server_stats["nb_connections"] -= 1
+    if server_stats["nb_connections"] < 0:
+        server_stats["nb_connections"] = 0
+    app.logger.error(error)
+
+
+@app.route("/rooms", methods=["GET", "POST"])
+@jwt_required()
+def rooms():
+    return jsonify({"name": "%s Review rooms" % config.APP_NAME})
+
+
+@socketio.on("preview-room:open-playlist", namespace="/events")
+@jwt_required()
+def on_open_playlist(data):
+    """
+    when a person opens the playlist page he immediately enters the
+    websocket room. This way he can see in live which people are in the
+    review room. The user still has to explicitly enter the review room
+    to actually be in sync with the other users
+    """
+    room, room_id = _get_room_from_data(data)
+    rooms_data[room_id] = room
+    join_room(room_id)
+    emit("preview-room:room-people-updated", room, room=room_id)
 
-    @app.route("/stats", methods=["GET"])
-    def stats():
-        return jsonify(server_stats)
 
+@socketio.on("preview-room:join", namespace="/events")
+@jwt_required()
+def on_join(data):
+    """
+    When a person joins the review room, we notify all its members that a
+    new person is added to the room.
+    """
+    user_id = get_jwt_identity()
+    room, room_id = _get_room_from_data(data)
+    if len(room["people"]) == 0:
+        _update_room_playing_status(data, room)
+    room["people"] = list(set(room["people"] + [user_id]))
+    rooms_data[room_id] = room
+    emit("preview-room:room-people-updated", room, room=room_id)
 
-def set_application_routes(socketio, app):
-    @socketio.on("connect", namespace="/events")
-    def connected():
-        try:
-            verify_jwt_in_request()
-            server_stats["nb_connections"] += 1
-            app.logger.info("New websocket client connected")
-        except Exception:
-            app.logger.info("New websocket client failed to connect")
-            disconnect()
-            return False
 
-    @socketio.on("disconnect", namespace="/events")
-    def disconnected():
-        try:
-            verify_jwt_in_request()
-            user_id = get_jwt_identity()
-            # needed to be able to clear empty rooms
-            tmp_rooms_data = dict(rooms_data)
-            for room_id in tmp_rooms_data:
-                _leave_room(room_id, user_id)
-            server_stats["nb_connections"] -= 1
-            app.logger.info("Websocket client disconnected")
-        except Exception:
-            pass
+@socketio.on("preview-room:leave", namespace="/events")
+@jwt_required()
+def on_leave(data):
+    user_id = get_jwt_identity()
+    room_id = data["playlist_id"]
+    _leave_room(room_id, user_id)
 
-    @socketio.on_error("/events")
-    def on_error(error):
-        server_stats["nb_connections"] -= 1
-        if server_stats["nb_connections"] < 0:
-            server_stats["nb_connections"] = 0
-        app.logger.error(error)
-
-
-def set_playlist_room_routes(socketio, app):
-    @app.route("/rooms", methods=["GET", "POST"])
-    @jwt_required()
-    def rooms():
-        return jsonify({"name": "%s Review rooms" % config.APP_NAME})
-
-    @socketio.on("preview-room:open-playlist", namespace="/events")
-    @jwt_required()
-    def on_open_playlist(data):
-        """
-        when a person opens the playlist page he immediately enters the
-        websocket room. This way he can see in live which people are in the
-        review room. The user still has to explicitly enter the review room
-        to actually be in sync with the other users
-        """
-        room, room_id = _get_room_from_data(data)
-        rooms_data[room_id] = room
-        join_room(room_id)
-        emit("preview-room:room-people-updated", room, room=room_id)
-
-    @socketio.on("preview-room:join", namespace="/events")
-    @jwt_required()
-    def on_join(data):
-        """
-        When a person joins the review room, we notify all its members that a
-        new person is added to the room.
-        """
-        user_id = get_jwt_identity()
-        room, room_id = _get_room_from_data(data)
-        if len(room["people"]) == 0:
-            _update_room_playing_status(data, room)
-        room["people"] = list(set(room["people"] + [user_id]))
-        rooms_data[room_id] = room
-        emit("preview-room:room-people-updated", room, room=room_id)
 
-    @socketio.on("preview-room:leave", namespace="/events")
-    @jwt_required()
-    def on_leave(data):
-        user_id = get_jwt_identity()
-        room_id = data["playlist_id"]
-        _leave_room(room_id, user_id)
-
-    @socketio.on("preview-room:update-playing-status", namespace="/events")
-    @jwt_required()
-    def on_playing_status_updated(data, only_newcomer=False):
-        room, room_id = _get_room_from_data(data)
-        rooms_data[room_id] = _update_room_playing_status(data, room)
-        event_data = {"only_newcomer": only_newcomer, **rooms_data[room_id]}
-        emit("preview-room:room-updated", event_data, room=room_id)
-
-    @socketio.on("preview-room:add-annotation", namespace="/events")
-    @jwt_required()
-    def on_add_annotation(data):
-        room_id = data["playlist_id"]
-        emit("preview-room:add-annotation", data, room=room_id)
-
-    @socketio.on("preview-room:remove-annotation", namespace="/events")
-    @jwt_required()
-    def on_remove_annotation(data):
-        room_id = data["playlist_id"]
-        emit("preview-room:remove-annotation", data, room=room_id)
-
-    @socketio.on("preview-room:update-annotation", namespace="/events")
-    @jwt_required()
-    def on_update_annotation(data):
-        room_id = data["playlist_id"]
-        emit("preview-room:update-annotation", data, room=room_id)
-
-    @socketio.on("preview-room:change-version", namespace="/events")
-    @jwt_required()
-    def on_change_version(data):
-        room_id = data["playlist_id"]
-        emit("preview-room:change-version", data, room=room_id)
-
-    return app
-
-
-def create_app():
-    redis_url = get_redis_url()
-    socketio = SocketIO(
-        logger=True, cors_allowed_origins=[], cors_credentials=False
-    )
-    app = Flask(__name__)
-    app.json = ORJSONProvider(app)
-    app.config.from_object(config)
-    init_monitoring(app)
-    db = SQLAlchemy(app)
-    app.extensions["sqlalchemy"].db = db
-    set_info_routes(socketio, app)
-    set_application_routes(socketio, app)
-    set_playlist_room_routes(socketio, app)
-    socketio.init_app(app, message_queue=redis_url, async_mode="gevent")
-    return (app, socketio)
-
-
-def set_auth(app):
-    jwt = JWTManager(app)  # JWT auth tokens
-
-    @jwt.token_in_blocklist_loader
-    def check_if_token_is_revoked(_, payload):
-        identity_type = payload.get("identity_type")
-        if identity_type == "person":
-            return auth_tokens_store.is_revoked(payload["jti"])
-        elif identity_type in ["bot", "person_api"]:
-            return persons_service.is_jti_revoked(payload["jti"])
-        else:
-            return True
-
-
-(app, socketio) = create_app()
-set_auth(app)
+@socketio.on("preview-room:update-playing-status", namespace="/events")
+@jwt_required()
+def on_playing_status_updated(data, only_newcomer=False):
+    room, room_id = _get_room_from_data(data)
+    rooms_data[room_id] = _update_room_playing_status(data, room)
+    event_data = {"only_newcomer": only_newcomer, **rooms_data[room_id]}
+    emit("preview-room:room-updated", event_data, room=room_id)
+
+
+@socketio.on("preview-room:add-annotation", namespace="/events")
+@jwt_required()
+def on_add_annotation(data):
+    room_id = data["playlist_id"]
+    emit("preview-room:add-annotation", data, room=room_id)
+
+
+@socketio.on("preview-room:remove-annotation", namespace="/events")
+@jwt_required()
+def on_remove_annotation(data):
+    room_id = data["playlist_id"]
+    emit("preview-room:remove-annotation", data, room=room_id)
+
+
+@socketio.on("preview-room:update-annotation", namespace="/events")
+@jwt_required()
+def on_update_annotation(data):
+    room_id = data["playlist_id"]
+    emit("preview-room:update-annotation", data, room=room_id)
+
+
+@socketio.on("preview-room:change-version", namespace="/events")
+@jwt_required()
+def on_change_version(data):
+    room_id = data["playlist_id"]
+    emit("preview-room:change-version", data, room=room_id)
 
 
 if __name__ == "__main__":

zou/job_settings.py

@@ -3,3 +3,4 @@ from zou.app import config
 REDIS_HOST = config.KEY_VALUE_STORE["host"]
 REDIS_PORT = config.KEY_VALUE_STORE["port"]
 REDIS_DB = config.KV_JOB_DB_INDEX
+REDIS_PASSWORD = config.KEY_VALUE_STORE["password"]

zou/migrations/utils/base.py

@@ -1,7 +1,5 @@
-import datetime
-
 from sqlalchemy_utils import UUIDType
-from zou.app.utils import fields
+from zou.app.utils import fields, date_helpers
 import sqlalchemy as sa
 
 
@@ -11,9 +9,11 @@ class BaseMixin(object):
     )
 
     # Audit fields
-    created_at = sa.Column(sa.DateTime, default=datetime.datetime.utcnow)
+    created_at = sa.Column(
+        sa.DateTime, default=date_helpers.get_utc_now_datetime
+    )
     updated_at = sa.Column(
         sa.DateTime,
-        default=datetime.datetime.utcnow,
-        onupdate=datetime.datetime.utcnow,
+        default=date_helpers.get_utc_now_datetime,
+        onupdate=date_helpers.get_utc_now_datetime,
     )