DISCUSSION, DO NOT MERGE: Separate out Models, Widgets and Delegates

avalon/gui/delegates/__init__.py

@@ -0,0 +1,12 @@
+from . import lib
+
+from .delegate_pretty_time import PrettyTimeDelegate
+from .delegate_version import VersionDelegate
+
+
+__all__ = [
+    "lib",
+
+    "PrettyTimeDelegate",
+    "VersionDelegate"
+]

avalon/gui/delegates/delegate_pretty_time.py

@@ -0,0 +1,13 @@
+from ...vendor.Qt import QtWidgets
+from .lib import pretty_timestamp
+
+
+class PrettyTimeDelegate(QtWidgets.QStyledItemDelegate):
+    """A delegate that displays a timestamp as a pretty date.
+
+    This displays dates like `pretty_date`.
+
+    """
+
+    def displayText(self, value, locale):
+        return pretty_timestamp(value)

avalon/gui/delegates/delegate_version.py

@@ -0,0 +1,70 @@
+from ...vendor.Qt import QtWidgets, QtCore
+from ... import io
+from ..models import SubsetModel
+
+
+class VersionDelegate(QtWidgets.QStyledItemDelegate):
+    """A delegate that display version integer formatted as version string."""
+
+    version_changed = QtCore.Signal()
+    first_run = False
+    lock = False
+
+    def _format_version(self, value):
+        """Formats integer to displayable version name"""
+        return "v{0:03d}".format(value)
+
+    def displayText(self, value, locale):
+        assert isinstance(value, int), "Version is not `int`"
+        return self._format_version(value)
+
+    def createEditor(self, parent, option, index):
+        node = index.data(SubsetModel.NodeRole)
+        if node.get("isGroup"):
+            return
+
+        editor = QtWidgets.QComboBox(parent)
+
+        def commit_data():
+            if not self.first_run:
+                self.commitData.emit(editor)  # Update model data
+                self.version_changed.emit()   # Display model data
+        editor.currentIndexChanged.connect(commit_data)
+
+        self.first_run = True
+        self.lock = False
+
+        return editor
+
+    def setEditorData(self, editor, index):
+        if self.lock:
+            # Only set editor data once per delegation
+            return
+
+        editor.clear()
+
+        # Current value of the index
+        value = index.data(QtCore.Qt.DisplayRole)
+        assert isinstance(value, int), "Version is not `int`"
+
+        # Add all available versions to the editor
+        node = index.data(SubsetModel.NodeRole)
+        parent_id = node['version_document']['parent']
+        versions = io.find({"type": "version", "parent": parent_id},
+                           sort=[("name", 1)])
+        index = 0
+        for i, version in enumerate(versions):
+            label = self._format_version(version['name'])
+            editor.addItem(label, userData=version)
+
+            if version['name'] == value:
+                index = i
+
+        editor.setCurrentIndex(index)  # Will trigger index-change signal
+        self.first_run = False
+        self.lock = True
+
+    def setModelData(self, editor, model, index):
+        """Apply the integer version back in the model"""
+        version = editor.itemData(editor.currentIndex())
+        model.setData(index, version['name'])

avalon/gui/delegates/lib.py

@@ -0,0 +1,89 @@
+import time
+from datetime import datetime
+import logging
+
+log = logging.getLogger(__name__)
+
+
+def pretty_date(t, now=None, strftime="%b %d %Y %H:%M"):
+    """Parse datetime to readable timestamp
+
+    Within first ten seconds:
+        - "just now",
+    Within first minute ago:
+        - "%S seconds ago"
+    Within one hour ago:
+        - "%M minutes ago".
+    Within one day ago:
+        - "%H:%M hours ago"
+    Else:
+        "%Y-%m-%d %H:%M:%S"
+
+    """
+
+    assert isinstance(t, datetime)
+    if now is None:
+        now = datetime.now()
+    assert isinstance(now, datetime)
+    diff = now - t
+
+    second_diff = diff.seconds
+    day_diff = diff.days
+
+    # future (consider as just now)
+    if day_diff < 0:
+        return 'just now'
+
+    # history
+    if day_diff == 0:
+        if second_diff < 10:
+            return "just now"
+        if second_diff < 60:
+            return str(second_diff) + " seconds ago"
+        if second_diff < 120:
+            return "a minute ago"
+        if second_diff < 3600:
+            return str(second_diff // 60) + " minutes ago"
+        if second_diff < 86400:
+            minutes = (second_diff % 3600) // 60
+            hours = second_diff // 3600
+            return "{0}:{1:02d} hours ago".format(hours, minutes)
+
+    return t.strftime(strftime)
+
+
+def pretty_timestamp(t, now=None):
+    """Parse timestamp to user readable format
+
+    >>> pretty_timestamp("20170614T151122Z", now="20170614T151123Z")
+    'just now'
+
+    >>> pretty_timestamp("20170614T151122Z", now="20170614T171222Z")
+    '2:01 hours ago'
+
+    Args:
+        t (str): The time string to parse.
+        now (str, optional)
+
+    Returns:
+        str: human readable "recent" date.
+
+    """
+
+    if now is not None:
+        try:
+            now = time.strptime(now, "%Y%m%dT%H%M%SZ")
+            now = datetime.fromtimestamp(time.mktime(now))
+        except ValueError as e:
+            log.warning("Can't parse 'now' time format: {0} {1}".format(t, e))
+            return None
+
+    try:
+        t = time.strptime(t, "%Y%m%dT%H%M%SZ")
+    except ValueError as e:
+        log.warning("Can't parse time format: {0} {1}".format(t, e))
+        return None
+    dt = datetime.fromtimestamp(time.mktime(t))
+
+    # prettify
+    return pretty_date(dt, now=now)

avalon/gui/lib.py

@@ -0,0 +1,73 @@
+from .. import io, api
+from ..vendor import qtawesome
+
+FAMILY_ICON_COLOR = "#0091B2"
+FAMILY_CONFIG = {}
+
+
+def get(config, name):
+    """Get value from config with fallback to default"""
+    # We assume the default fallback key in the config is `__default__`
+    return config.get(name, config.get("__default__", None))
+
+
+def refresh_family_config():
+    """Get the family configurations from the database
+
+    The configuration must be stored on the project under `config`.
+    For example:
+
+    {
+        "config": {
+            "families": [
+                {"name": "avalon.camera", label: "Camera", "icon": "photo"},
+                {"name": "avalon.anim", label: "Animation", "icon": "male"},
+            ]
+        }
+    }
+
+    It is possible to override the default behavior and set specific families
+    checked. For example we only want the families imagesequence  and camera
+    to be visible in the Loader.
+
+    # This will turn every item off
+    api.data["familyStateDefault"] = False
+
+    # Only allow the imagesequence and camera
+    api.data["familyStateToggled"] = ["imagesequence", "camera"]
+
+    """
+    # Update the icons from the project configuration
+    project = io.find_one({"type": "project"},
+                          projection={"config.families": True})
+
+    assert project, "Project not found!"
+    families = project['config'].get("families", [])
+    families = {family['name']: family for family in families}
+
+    # Check if any family state are being overwritten by the configuration
+    default_state = api.data.get("familiesStateDefault", True)
+    toggled = set(api.data.get("familiesStateToggled", []))
+
+    # Replace icons with a Qt icon we can use in the user interfaces
+    default_icon = qtawesome.icon("fa.folder", color=FAMILY_ICON_COLOR)
+    for name, family in families.items():
+        # Set family icon
+        icon = family.get("icon", None)
+        if icon:
+            family['icon'] = qtawesome.icon("fa.{}".format(icon),
+                                            color=FAMILY_ICON_COLOR)
+        else:
+            family['icon'] = default_icon
+
+        # Update state
+        state = not default_state if name in toggled else default_state
+        family["state"] = state
+
+    # Default configuration
+    families["__default__"] = {"icon": default_icon}
+
+    FAMILY_CONFIG.clear()
+    FAMILY_CONFIG.update(families)
+
+    return families

avalon/gui/models/__init__.py

@@ -0,0 +1,36 @@
+from . import lib
+
+from .node import Node
+
+from .model_tree import TreeModel
+from .model_task import TaskModel
+from .model_asset import AssetModel
+from .model_subset import SubsetModel
+from .model_inventory import InventoryModel
+
+from .proxy_filter import FilterProxyModel
+from .proxy_exact_matches_filter import ExactMatchesFilterProxyModel
+from .proxy_recursive_sort_filter import RecursiveSortFilterProxyModel
+from .proxy_group_filter import GroupMemberFilterProxyModel
+from .proxy_subset_filter import SubsetFilterProxyModel
+from .proxy_family_filter import FamilyFilterProxyModel
+
+
+__all__ = [
+    "lib",
+
+    "Node",
+
+    "TreeModel",
+    "TaskModel",
+    "AssetModel",
+    "SubsetModel",
+    "InventoryModel",
+
+    "FilterProxyModel",
+    "ExactMatchesFilterProxyModel",
+    "RecursiveSortFilterProxyModel",
+    "GroupMemberFilterProxyModel",
+    "SubsetFilterProxyModel",
+    "FamilyFilterProxyModel"
+]