OctoPrint-Wrapped 1.0.0__tar.gz

octoprint_wrapped-1.0.0/MANIFEST.in

@@ -0,0 +1,4 @@
+include README.md
+recursive-include octoprint_wrapped/templates *
+recursive-include octoprint_wrapped/translations *
+recursive-include octoprint_wrapped/static *

octoprint_wrapped-1.0.0/OctoPrint_Wrapped.egg-info/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: OctoPrint-Wrapped
+Version: 1.0.0
+Summary: Get your yearly OctoPrint stats and let it snow! Depends on the Achievements plugin.
+Author-email: Gina Häußge <gina@octoprint.org>
+License: AGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/OctoPrint/OctoPrint-Wrapped
+Requires-Python: <4,>=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: develop
+Requires-Dist: go-task-bin; extra == "develop"
+Dynamic: license
+
+# OctoPrint Wrapped! 🎁
+
+Get your yearly OctoPrint stats a shareable "wrapped" picture - and let it snow! ❄️
+
+<img src="https://raw.githubusercontent.com/OctoPrint/OctoPrint-Wrapped/main/extras/wrapped-demo.png" width="400" height="400" alt="Demo OctoPrint Wrapped share picture" />
+
+![Demo of snow effect](https://raw.githubusercontent.com/OctoPrint/OctoPrint-Wrapped/main/extras/snowfall-demo.gif)
+
+The stats picture depends on the Achievements plugin being enabled (as it takes care of
+the stats collection during the year) and can be opened via the little gift package icon
+in the navbar.
+
+The snow effect can always be toggled during the season using the little snowflake icon
+in the navbar, and its setting persists through the browser's local storage.
+
+Both wrapped and snowfall are only available from December 1st until January 10th.
+
+## Setup
+
+Install via the bundled [Plugin Manager](https://docs.octoprint.org/en/main/bundledplugins/pluginmanager.html)
+or manually using this URL:
+
+    https://github.com/OctoPrint/OctoPrint-Wrapped/archive/main.zip
+
+## Configuration
+
+The plugin does not have any configuration options.
+
+## Acknowledgements
+
+The snowfall is implemented with a slightly customized version of [pure-snow.js](https://github.com/hyperstown/pure-snow.js),
+released under the MIT license and bundled here under `octoprint_wrapped/static/pure-snow`.

octoprint_wrapped-1.0.0/OctoPrint_Wrapped.egg-info/SOURCES.txt

@@ -0,0 +1,21 @@
+MANIFEST.in
+README.md
+pyproject.toml
+setup.py
+OctoPrint_Wrapped.egg-info/PKG-INFO
+OctoPrint_Wrapped.egg-info/SOURCES.txt
+OctoPrint_Wrapped.egg-info/dependency_links.txt
+OctoPrint_Wrapped.egg-info/entry_points.txt
+OctoPrint_Wrapped.egg-info/requires.txt
+OctoPrint_Wrapped.egg-info/top_level.txt
+octoprint_wrapped/__init__.py
+octoprint_wrapped/static/clientjs/wrapped.js
+octoprint_wrapped/static/js/ko.src.svgtopng.js
+octoprint_wrapped/static/js/wrapped.js
+octoprint_wrapped/static/pure-snow/LICENSE
+octoprint_wrapped/static/pure-snow/pure-snow.css
+octoprint_wrapped/static/pure-snow/pure-snow.js
+octoprint_wrapped/templates/wrapped.svg.jinja2
+octoprint_wrapped/templates/wrapped_about.jinja2
+octoprint_wrapped/templates/wrapped_navbar_snowfall.jinja2
+octoprint_wrapped/templates/wrapped_navbar_wrapped.jinja2

octoprint_wrapped-1.0.0/OctoPrint_Wrapped.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

octoprint_wrapped-1.0.0/OctoPrint_Wrapped.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[octoprint.plugin]
+wrapped = octoprint_wrapped

octoprint_wrapped-1.0.0/OctoPrint_Wrapped.egg-info/requires.txt

@@ -0,0 +1,3 @@
+
+[develop]
+go-task-bin

octoprint_wrapped-1.0.0/OctoPrint_Wrapped.egg-info/top_level.txt

@@ -0,0 +1 @@
+octoprint_wrapped

octoprint_wrapped-1.0.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: OctoPrint-Wrapped
+Version: 1.0.0
+Summary: Get your yearly OctoPrint stats and let it snow! Depends on the Achievements plugin.
+Author-email: Gina Häußge <gina@octoprint.org>
+License: AGPL-3.0-or-later
+Project-URL: Homepage, https://github.com/OctoPrint/OctoPrint-Wrapped
+Requires-Python: <4,>=3.9
+Description-Content-Type: text/markdown
+Provides-Extra: develop
+Requires-Dist: go-task-bin; extra == "develop"
+Dynamic: license
+
+# OctoPrint Wrapped! 🎁
+
+Get your yearly OctoPrint stats a shareable "wrapped" picture - and let it snow! ❄️
+
+<img src="https://raw.githubusercontent.com/OctoPrint/OctoPrint-Wrapped/main/extras/wrapped-demo.png" width="400" height="400" alt="Demo OctoPrint Wrapped share picture" />
+
+![Demo of snow effect](https://raw.githubusercontent.com/OctoPrint/OctoPrint-Wrapped/main/extras/snowfall-demo.gif)
+
+The stats picture depends on the Achievements plugin being enabled (as it takes care of
+the stats collection during the year) and can be opened via the little gift package icon
+in the navbar.
+
+The snow effect can always be toggled during the season using the little snowflake icon
+in the navbar, and its setting persists through the browser's local storage.
+
+Both wrapped and snowfall are only available from December 1st until January 10th.
+
+## Setup
+
+Install via the bundled [Plugin Manager](https://docs.octoprint.org/en/main/bundledplugins/pluginmanager.html)
+or manually using this URL:
+
+    https://github.com/OctoPrint/OctoPrint-Wrapped/archive/main.zip
+
+## Configuration
+
+The plugin does not have any configuration options.
+
+## Acknowledgements
+
+The snowfall is implemented with a slightly customized version of [pure-snow.js](https://github.com/hyperstown/pure-snow.js),
+released under the MIT license and bundled here under `octoprint_wrapped/static/pure-snow`.

octoprint_wrapped-1.0.0/README.md

@@ -0,0 +1,32 @@
+# OctoPrint Wrapped! 🎁
+
+Get your yearly OctoPrint stats a shareable "wrapped" picture - and let it snow! ❄️
+
+<img src="https://raw.githubusercontent.com/OctoPrint/OctoPrint-Wrapped/main/extras/wrapped-demo.png" width="400" height="400" alt="Demo OctoPrint Wrapped share picture" />
+
+![Demo of snow effect](https://raw.githubusercontent.com/OctoPrint/OctoPrint-Wrapped/main/extras/snowfall-demo.gif)
+
+The stats picture depends on the Achievements plugin being enabled (as it takes care of
+the stats collection during the year) and can be opened via the little gift package icon
+in the navbar.
+
+The snow effect can always be toggled during the season using the little snowflake icon
+in the navbar, and its setting persists through the browser's local storage.
+
+Both wrapped and snowfall are only available from December 1st until January 10th.
+
+## Setup
+
+Install via the bundled [Plugin Manager](https://docs.octoprint.org/en/main/bundledplugins/pluginmanager.html)
+or manually using this URL:
+
+    https://github.com/OctoPrint/OctoPrint-Wrapped/archive/main.zip
+
+## Configuration
+
+The plugin does not have any configuration options.
+
+## Acknowledgements
+
+The snowfall is implemented with a slightly customized version of [pure-snow.js](https://github.com/hyperstown/pure-snow.js),
+released under the MIT license and bundled here under `octoprint_wrapped/static/pure-snow`.

octoprint_wrapped-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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-1.0.0/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.