OctoPrint-Wrapped 1.0.0__py3-none-any.whl

octoprint_wrapped/__init__.py

@@ -0,0 +1,257 @@
+import json
+import os
+from typing import Optional
+
+import flask
+import octoprint.plugin
+from flask_babel import gettext
+from octoprint.access.permissions import Permissions
+from octoprint.schema import BaseModel
+
+WEEKDAYS = [
+    "Monday",
+    "Tuesday",
+    "Wednesday",
+    "Thursday",
+    "Friday",
+    "Saturday",
+    "Sunday",
+]
+SECONDS_MINUTE = 60
+SECONDS_HOUR = SECONDS_MINUTE * 60
+SECONDS_DAY = SECONDS_HOUR * 24
+
+
+class YearStats(BaseModel):
+    year: int
+    prints_completed: int
+    total_print_duration: str
+    longest_print: str
+    busiest_weekday: str
+    files_uploaded: int
+    octoprint_versions: int
+
+
+class ApiResponse(BaseModel):
+    years: list[int]
+
+
+class WrappedPlugin(
+    octoprint.plugin.AssetPlugin,
+    octoprint.plugin.BlueprintPlugin,
+    octoprint.plugin.SimpleApiPlugin,
+    octoprint.plugin.TemplatePlugin,
+):
+    ##~~ AssetPlugin mixin
+
+    def get_assets(self):
+        return {
+            "clientjs": ["clientjs/wrapped.js"],
+            "js": ["js/wrapped.js", "js/ko.src.svgtopng.js"],
+        }
+
+    ##~~ BlueprintPlugin mixin
+
+    def is_blueprint_csrf_protected(self):
+        return True
+
+    def is_protected(self):
+        return True
+
+    @octoprint.plugin.BlueprintPlugin.route("/<int:year>.svg", methods=["GET"])
+    def get_svg(self, year):
+        if (
+            not hasattr(Permissions, "PLUGIN_ACHIEVEMENTS_VIEW")
+            or not Permissions.PLUGIN_ACHIEVEMENTS_VIEW.can()
+        ):
+            flask.abort(403)
+
+        stats = self._get_year_stats(year)
+        if stats is None:
+            flask.abort(404)
+
+        response = flask.make_response(
+            flask.render_template("wrapped.svg.jinja2", **stats.model_dump(by_alias=True))
+        )
+        response.headers["Content-Type"] = "image/svg+xml"
+        return response
+
+    ##~~ SimpleApiPlugin mixin
+
+    def is_api_protected(self):
+        return True
+
+    def on_api_get(self, request):
+        if (
+            not hasattr(Permissions, "PLUGIN_ACHIEVEMENTS_VIEW")
+            or not Permissions.PLUGIN_ACHIEVEMENTS_VIEW.can()
+        ):
+            flask.abort(403)
+
+        response = ApiResponse(years=self._get_available_years())
+        return flask.jsonify(response.model_dump(by_alias=True))
+
+    ##~~ Softwareupdate hook
+
+    def get_update_information(self):
+        return {
+            "wrapped": {
+                "displayName": "OctoPrint Wrapped!",
+                "displayVersion": self._plugin_version,
+                # version check: github repository
+                "type": "github_release",
+                "user": "OctoPrint",
+                "repo": "OctoPrint-Wrapped",
+                "current": self._plugin_version,
+                # update method: pip
+                "pip": "https://github.com/OctoPrint/OctoPrint-Wrapped/archive/{target_version}.zip",
+            }
+        }
+
+    ##~~ TemplatePlugin mixin
+
+    def is_template_autoescaped(self):
+        return True
+
+    def get_template_configs(self):
+        return [
+            {
+                "type": "about",
+                "name": gettext("OctoPrint Wrapped!"),
+                "template": "wrapped_about.jinja2",
+                "custom_bindings": True,
+            },
+            {
+                "type": "navbar",
+                "template": "wrapped_navbar_wrapped.jinja2",
+                "custom_bindings": True,
+            },
+            {
+                "type": "navbar",
+                "template": "wrapped_navbar_snowfall.jinja2",
+                "custom_bindings": True,
+            },
+        ]
+
+    ##~~ helpers
+
+    def _get_year_stats_folder(self) -> Optional[str]:
+        folder = os.path.join(self.get_plugin_data_folder(), "..", "achievements")
+        if not os.path.isdir(folder):
+            return None
+        return folder
+
+    def _get_year_stats_file(self, year: int) -> Optional[str]:
+        folder = self._get_year_stats_folder()
+        if not folder:
+            return None
+
+        year_path = os.path.join(folder, f"{year}.json")
+        if not os.path.isfile(year_path):
+            return None
+
+        return year_path
+
+    def _get_available_years(self) -> list[int]:
+        import re
+
+        stats_folder = self._get_year_stats_folder()
+        if not stats_folder:
+            return []
+
+        pattern = re.compile(r"\d{4}.json")
+
+        years = []
+        for entry in os.scandir(stats_folder):
+            if not entry.is_file():
+                continue
+
+            if pattern.fullmatch(entry.name):
+                year, _ = os.path.splitext(entry.name)
+                years.append(int(year))
+
+        return years
+
+    def _get_year_stats(self, year: int) -> Optional[YearStats]:
+        stats_file = self._get_year_stats_file(year)
+        if not stats_file:
+            return None
+
+        try:
+            with open(stats_file) as f:
+                stats = json.load(f)
+        except Exception:
+            self._logger.exception(
+                f"Error while reading yearly stats for {year} from {stats_file}"
+            )
+            return None
+
+        try:
+            weekday_stats = stats.get("prints_started_per_weekday", {})
+            busiest = None
+            for key, value in weekday_stats.items():
+                if busiest is None or value > busiest[1]:
+                    busiest = (key, value)
+
+            if busiest:
+                weekday = WEEKDAYS[int(busiest[0])]
+            else:
+                weekday = "-"
+
+            return YearStats(
+                year=year,
+                prints_completed=stats.get("prints_finished", 0),
+                total_print_duration=self._to_duration_days(
+                    int(stats.get("print_duration_total", 0))
+                ),
+                longest_print=self._to_duration_hours(
+                    int(stats.get("longest_print_duration", 0))
+                ),
+                busiest_weekday=weekday,
+                files_uploaded=int(stats.get("files_uploaded", 0)),
+                octoprint_versions=int(stats.get("seen_versions", 1)),
+            )
+        except Exception:
+            self._logger.exception(
+                f"Error while parsing yearly stats for {year} from {stats_file}"
+            )
+            return None
+
+    def _to_duration_days(self, seconds: int) -> str:
+        days = int(seconds / SECONDS_DAY)
+        seconds -= days * SECONDS_DAY
+
+        hours = int(seconds / SECONDS_HOUR)
+        seconds -= hours * SECONDS_HOUR
+
+        minutes = int(seconds / SECONDS_MINUTE)
+        seconds -= minutes * SECONDS_MINUTE
+
+        if days >= 100:
+            # strip the minutes to keep things fitting...
+            return f"{days}d {hours}h"
+        else:
+            return f"{days}d {hours}h {minutes}m"
+
+    def _to_duration_hours(self, seconds: int) -> str:
+        hours = int(seconds / SECONDS_HOUR)
+        seconds -= hours * SECONDS_HOUR
+
+        minutes = int(seconds / SECONDS_MINUTE)
+        seconds -= minutes * SECONDS_MINUTE
+
+        return f"{hours}h {minutes}m"
+
+
+__plugin_name__ = "OctoPrint Wrapped!"
+__plugin_pythoncompat__ = ">=3.9,<4"  # Only Python 3
+
+
+def __plugin_load__():
+    global __plugin_implementation__
+    __plugin_implementation__ = WrappedPlugin()
+
+    global __plugin_hooks__
+    __plugin_hooks__ = {
+        "octoprint.plugin.softwareupdate.check_config": __plugin_implementation__.get_update_information,
+    }

octoprint_wrapped/static/clientjs/wrapped.js

@@ -0,0 +1,27 @@
+(function (global, factory) {
+    if (typeof define === "function" && define.amd) {
+        define(["OctoPrintClient"], factory);
+    } else {
+        factory(global.OctoPrintClient);
+    }
+})(this, function (OctoPrintClient) {
+    var OctoPrintWrappedClient = function (base) {
+        this.base = base;
+
+        this.baseUrl = this.base.getBlueprintUrl("wrapped");
+        this.apiUrl = this.base.getSimpleApiUrl("wrapped");
+    };
+
+    OctoPrintWrappedClient.prototype.get = function (opts) {
+        return this.base.get(this.apiUrl, opts);
+    };
+
+    OctoPrintWrappedClient.prototype.getYearSvgUrl = function (year, opts) {
+        return this.baseUrl + year + ".svg";
+    };
+
+    // register plugin component
+    OctoPrintClient.registerPluginComponent("wrapped", OctoPrintWrappedClient);
+
+    return OctoPrintWrappedClient;
+});

octoprint_wrapped/static/js/ko.src.svgtopng.js

@@ -0,0 +1,36 @@
+ko.bindingHandlers["src.svgtopng"] = {
+    init: (element, valueAccessor, allBindingsAccessor, viewModel, bindingContext) => {
+        const value = valueAccessor();
+        const valueUnwrapped = ko.unwrap(value);
+        if (!valueUnwrapped) return;
+
+        const $element = $(element);
+
+        $.get(valueUnwrapped).done((data, textStatus, xhr) => {
+            const svgString = xhr.responseText;
+
+            const svg = new Blob([svgString], {
+                type: "image/svg+xml;charset=utf-8"
+            });
+
+            const url = URL.createObjectURL(svg);
+
+            const img = new Image();
+            img.onload = () => {
+                URL.revokeObjectURL(url);
+
+                const canvas = document.createElement("canvas");
+                canvas.width = img.width;
+                canvas.height = img.height;
+
+                const ctx = canvas.getContext("2d");
+                ctx.drawImage(img, 0, 0);
+
+                const png = canvas.toDataURL("image/png");
+                $element.attr("src", png);
+            };
+            img.src = url;
+        });
+    }
+};
+ko.bindingHandlers["src.svgtopng"].update = ko.bindingHandlers["src.svgtopng"].init;

octoprint_wrapped/static/js/wrapped.js

@@ -0,0 +1,178 @@
+/*
+ * View model for OctoPrint-Wrapped
+ *
+ * Author: Gina Häußge
+ * License: AGPL-3.0-or-later
+ */
+$(function () {
+    const FLAKES = 50;
+    const MIN_DURATION = 5;
+    const MAX_DURATION = 15;
+
+    const MONTH_DECEMBER = 11;
+    const MONTH_JANUARY = 0;
+
+    const SNOWFALL_LOCAL_STORAGE_KEY = "plugin.wrapped.snowfall";
+    const snowfallToLocalStorage = (value) => {
+        saveToLocalStorage(SNOWFALL_LOCAL_STORAGE_KEY, {
+            enabled: value
+        });
+    };
+
+    const snowfallFromLocalStorage = () => {
+        const data = loadFromLocalStorage(SNOWFALL_LOCAL_STORAGE_KEY);
+        if (data["enabled"] !== undefined) return !!data["enabled"];
+        return false;
+    };
+
+    function WrappedViewModel(parameters) {
+        const self = this;
+
+        self.loginState = parameters[0];
+        self.access = parameters[1];
+        self.aboutVM = parameters[2];
+
+        self.availableYears = ko.observableArray([]);
+
+        self.snowfallEnabled = false;
+        self.snowfallContainer = undefined;
+
+        self.currentWrapped = ko.pureComputed(() => {
+            if (!self.withinWrappedSeason()) return false;
+
+            const now = new Date();
+            const year =
+                now.getMonth() == MONTH_DECEMBER
+                    ? now.getFullYear() // still in December
+                    : now.getFullYear() - 1; // already January
+            const years = self.availableYears();
+
+            if (years.indexOf(year) !== -1 && self.withinWrappedSeason()) {
+                return year;
+            } else {
+                return false;
+            }
+        });
+
+        self.currentWrappedAvailable = ko.pureComputed(() => {
+            return self.currentWrapped() !== false;
+        });
+
+        self.currentSvgUrl = ko.pureComputed(() => {
+            const year = self.currentWrapped();
+            if (!year) return false;
+
+            return OctoPrint.plugins.wrapped.getYearSvgUrl(year);
+        });
+
+        self.withinWrappedSeason = ko.pureComputed(() => {
+            // wrapped Season = Dec 1st until January 10th
+            const now = new Date();
+            return (
+                now.getMonth() == MONTH_DECEMBER ||
+                (now.getMonth() == MONTH_JANUARY && now.getDate() < 10)
+            );
+        });
+
+        self.requestData = () => {
+            if (
+                !self.loginState.hasPermission(
+                    self.access.permissions.PLUGIN_ACHIEVEMENTS_VIEW
+                )
+            ) {
+                return;
+            }
+            OctoPrint.plugins.wrapped.get().done(self.fromResponse);
+        };
+
+        self.fromResponse = (response) => {
+            self.availableYears(response.years);
+        };
+
+        self.showWrapped = () => {
+            self.aboutVM.show("about_plugin_wrapped");
+            return false;
+        };
+
+        self.toggleSnowfall = () => {
+            self.snowfallEnabled = !self.snowfallEnabled;
+            snowfallToLocalStorage(self.snowfallEnabled);
+            self.updateSnowfall();
+        };
+
+        self.updateSnowfall = () => {
+            let container = document.getElementById("snow");
+
+            const body = document.getElementsByTagName("body")[0];
+            const head = document.getElementsByTagName("head")[0];
+
+            if (!self.snowfallEnabled) {
+                if (typeof showSnow !== "undefined") showSnow(false);
+            } else if (self.snowfallEnabled) {
+                if (!self.withinWrappedSeason()) return;
+
+                if (!container) {
+                    container = document.createElement("div");
+                    container.id = "snow";
+                    container.dataset.count = FLAKES;
+                    container.dataset.durmin = MIN_DURATION;
+                    container.dataset.durmax = MAX_DURATION;
+                    body.insertBefore(container, body.firstChild);
+
+                    const styleSnow = document.createElement("link");
+                    styleSnow.href =
+                        BASEURL + "plugin/wrapped/static/pure-snow/pure-snow.css";
+                    styleSnow.rel = "stylesheet";
+                    head.appendChild(styleSnow);
+
+                    const scriptSnow = document.createElement("script");
+                    scriptSnow.src =
+                        BASEURL + "plugin/wrapped/static/pure-snow/pure-snow.js";
+                    scriptSnow.defer = true;
+                    scriptSnow.onload = () => {
+                        setTimeout(() => {
+                            if (
+                                typeof createSnow === "undefined" ||
+                                typeof showSnow === "undefined"
+                            )
+                                return;
+                            createSnow();
+                            showSnow(true);
+                        }, 500);
+                    };
+                    head.appendChild(scriptSnow);
+                } else {
+                    if (typeof showSnow !== "undefined") showSnow(true);
+                }
+            }
+        };
+
+        self.onUserPermissionsChanged =
+            self.onUserLoggedIn =
+            self.onUserLoggedOut =
+                (user) => {
+                    if (
+                        self.loginState.hasPermission(
+                            self.access.permissions.PLUGIN_ACHIEVEMENTS_VIEW
+                        )
+                    ) {
+                        self.requestData();
+                    }
+                };
+
+        self.onStartup = () => {
+            self.snowfallEnabled = snowfallFromLocalStorage();
+            self.updateSnowfall();
+        };
+    }
+
+    OCTOPRINT_VIEWMODELS.push({
+        construct: WrappedViewModel,
+        dependencies: ["loginStateViewModel", "accessViewModel", "aboutViewModel"],
+        elements: [
+            "#about_plugin_wrapped",
+            "#navbar_plugin_wrapped",
+            "#navbar_plugin_wrapped_2"
+        ]
+    });
+});

octoprint_wrapped/static/pure-snow/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020-present, hyperstown (github.com/hyperstown/)
+
+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.

octoprint_wrapped/static/pure-snow/pure-snow.css

@@ -0,0 +1,10 @@
+.snowflake {
+    z-index: 32768;
+    position: absolute;
+    width: 10px;
+    height: 10px;
+    background: linear-gradient(white, white);
+    /* Workaround for Chromium's selective color inversion */
+    border-radius: 50%;
+    filter: drop-shadow(0 0 10px black);
+}

octoprint_wrapped/static/pure-snow/pure-snow.js

@@ -0,0 +1,146 @@
+let snowflakesCount = 200; // Snowflake count, can be overwritten by attrs
+let minDuration = 10; // can be overwritten by attrs
+let maxDuration = 30; // can be overwritten by attrs
+let baseCSS = ``;
+
+// set global attributes
+if (typeof SNOWFLAKES_COUNT !== "undefined") {
+    snowflakesCount = SNOWFLAKES_COUNT;
+}
+if (typeof SNOWFLAKES_MIN_DURATION !== "undefined") {
+    minDuration = SNOWFLAKES_MIN_DURATION;
+}
+if (typeof SNOWFLAKES_MAX_DURATION !== "undefined") {
+    maxDuration = SNOWFLAKES_MAX_DURATION;
+}
+if (typeof BASE_CSS !== "undefined") {
+    baseCSS = BASE_CSS;
+}
+
+let bodyHeightPx = null;
+let pageHeightVh = null;
+
+function setHeightVariables() {
+    bodyHeightPx = document.body.offsetHeight;
+    pageHeightVh = Math.max((100 * bodyHeightPx) / window.innerHeight, 100.0);
+}
+
+// get params set in snow div
+function getSnowAttributes() {
+    const snowWrapper = document.getElementById("snow");
+    snowflakesCount = Number(snowWrapper?.dataset?.count || snowflakesCount);
+    minDuration = Number(snowWrapper?.dataset?.durmin || minDuration);
+    maxDuration = Number(snowWrapper?.dataset?.durmax || maxDuration);
+}
+
+// This function allows you to turn on and off the snow
+function showSnow(value) {
+    if (value) {
+        document.getElementById("snow").style.display = "block";
+    } else {
+        document.getElementById("snow").style.display = "none";
+    }
+}
+
+// Creating snowflakes
+function generateSnow(snowDensity = 200) {
+    snowDensity -= 1;
+    const snowWrapper = document.getElementById("snow");
+    snowWrapper.innerHTML = "";
+    for (let i = 0; i < snowDensity; i++) {
+        let board = document.createElement("div");
+        board.className = "snowflake";
+        snowWrapper.appendChild(board);
+    }
+}
+
+function getOrCreateCSSElement() {
+    let cssElement = document.getElementById("psjs-css");
+    if (cssElement) return cssElement;
+
+    cssElement = document.createElement("style");
+    cssElement.id = "psjs-css";
+    document.head.appendChild(cssElement);
+    return cssElement;
+}
+
+// Append style for each snowflake to the head
+function addCSS(rule) {
+    const cssElement = getOrCreateCSSElement();
+    cssElement.innerHTML = rule; // safe to use innerHTML
+    document.head.appendChild(cssElement);
+}
+
+// Math
+function randomInt(value = 100) {
+    return Math.floor(Math.random() * value) + 1;
+}
+
+function randomIntRange(min, max) {
+    min = Math.ceil(min);
+    max = Math.floor(max);
+    return Math.floor(Math.random() * (max - min + 1)) + min;
+}
+
+function getRandomArbitrary(min, max) {
+    return Math.random() * (max - min) + min;
+}
+
+// Create style for snowflake
+function generateSnowCSS(snowDensity = 200) {
+    let snowflakeName = "snowflake";
+    let rule = baseCSS;
+
+    for (let i = 1; i < snowDensity; i++) {
+        let randomX = Math.random() * 100; // vw
+        let randomOffset = Math.random() * 10; // vw;
+        let randomXEnd = randomX + randomOffset;
+        let randomXEndYoyo = randomX + randomOffset / 2;
+        let randomYoyoTime = getRandomArbitrary(0.3, 0.8);
+        let randomYoyoY = randomYoyoTime * pageHeightVh; // vh
+        let randomScale = Math.random();
+        let fallDuration = Math.min(
+            randomIntRange(minDuration, (pageHeightVh / 10) * 3),
+            maxDuration
+        ); // s
+        let fallDelay = randomInt((pageHeightVh / 10) * 3) * -1; // s
+        let opacity = Math.random();
+
+        rule += `
+      .${snowflakeName}:nth-child(${i}) {
+        opacity: ${opacity};
+        transform: translate(${randomX}vw, -10px) scale(${randomScale});
+        animation: fall-${i} ${fallDuration}s ${fallDelay}s linear infinite;
+      }
+      @keyframes fall-${i} {
+        ${randomYoyoTime * 100}% {
+          transform: translate(${randomXEnd}vw, ${randomYoyoY}vh) scale(${randomScale});
+        }
+        to {
+          transform: translate(${randomXEndYoyo}vw, ${pageHeightVh}vh) scale(${randomScale});
+        }
+      }
+    `;
+    }
+    addCSS(rule);
+}
+
+// Load the rules and execute after the DOM loads
+function createSnow() {
+    setHeightVariables();
+    getSnowAttributes();
+    generateSnowCSS(snowflakesCount);
+    generateSnow(snowflakesCount);
+}
+
+window.addEventListener("resize", createSnow);
+
+// export createSnow function if using node or CommonJS environment
+if (typeof module !== "undefined") {
+    module.exports = {
+        createSnow,
+        showSnow
+    };
+} else {
+    window.onload = createSnow;
+}