fixing setting format to use crop value

pype/nuke/__init__.py

@@ -3,7 +3,7 @@ import sys
 from avalon import api as avalon
 from pyblish import api as pyblish
 
-from .. import api as pype
+from .. import api
 
 from pype.nuke import menu
 
@@ -15,12 +15,12 @@ import nuke
 
 # removing logger handler created in avalon_core
 for name, handler in [(handler.get_name(), handler)
-                      for handler in pype.Logger.logging.root.handlers[:]]:
+                      for handler in api.Logger.logging.root.handlers[:]]:
     if "pype" not in str(name).lower():
-        pype.Logger.logging.root.removeHandler(handler)
+        api.Logger.logging.root.removeHandler(handler)
 
 
-log = pype.Logger.getLogger(__name__, "nuke")
+log = api.Logger.getLogger(__name__, "nuke")
 
 AVALON_CONFIG = os.getenv("AVALON_CONFIG", "pype")
 
@@ -37,7 +37,7 @@ self = sys.modules[__name__]
 self.nLogger = None
 
 
-class NukeHandler(pype.Logger.logging.Handler):
+class NukeHandler(api.Logger.logging.Handler):
     '''
     Nuke Handler - emits logs into nuke's script editor.
     warning will emit nuke.warning()
@@ -45,7 +45,7 @@ class NukeHandler(pype.Logger.logging.Handler):
     '''
 
     def __init__(self):
-        pype.Logger.logging.Handler.__init__(self)
+        api.Logger.logging.Handler.__init__(self)
         self.set_name("Pype_Nuke_Handler")
 
     def emit(self, record):
@@ -65,11 +65,11 @@ class NukeHandler(pype.Logger.logging.Handler):
 nuke_handler = NukeHandler()
 if nuke_handler.get_name() \
     not in [handler.get_name()
-            for handler in pype.Logger.logging.root.handlers[:]]:
-    pype.Logger.logging.getLogger().addHandler(nuke_handler)
+            for handler in api.Logger.logging.root.handlers[:]]:
+    api.Logger.logging.getLogger().addHandler(nuke_handler)
 
 if not self.nLogger:
-    self.nLogger = pype.Logger
+    self.nLogger = api.Logger
 
 
 def reload_config():
@@ -86,8 +86,6 @@ def reload_config():
         "app.api",
         "{}.api".format(AVALON_CONFIG),
         "{}.templates".format(AVALON_CONFIG),
-        "{}.nuke".format(AVALON_CONFIG),
-        "{}.nuke.lib".format(AVALON_CONFIG),
         "{}.nuke.templates".format(AVALON_CONFIG),
         "{}.nuke.menu".format(AVALON_CONFIG)
     ):
@@ -100,7 +98,8 @@ def reload_config():
 
 
 def install():
-    pype.fill_avalon_workdir()
+
+    api.fill_avalon_workdir()
     reload_config()
 
     log.info("Registering Nuke plug-ins..")
@@ -129,7 +128,7 @@ def install():
     menu.install()
 
     # load data from templates
-    pype.load_data_from_templates()
+    api.load_data_from_templates()
 
 
 def uninstall():
@@ -141,7 +140,7 @@ def uninstall():
     pyblish.deregister_callback("instanceToggled", on_pyblish_instance_toggled)
 
     # reset data from templates
-    pype.reset_data_from_templates()
+    api.reset_data_from_templates()
 
 
 def on_pyblish_instance_toggled(instance, old_value, new_value):

pype/nuke/lib.py

@@ -2,6 +2,7 @@ import sys
 from collections import OrderedDict
 from pprint import pprint
 from avalon.vendor.Qt import QtGui
+from avalon import api, io
 import avalon.nuke
 import pype.api as pype
 import nuke
@@ -99,57 +100,6 @@ def add_rendering_knobs(node):
     return node
 
 
-def update_frame_range(start, end, root=None):
-    """Set Nuke script start and end frame range
-
-    Args:
-        start (float, int): start frame
-        end (float, int): end frame
-        root (object, Optional): root object from nuke's script
-
-    Returns:
-        None
-
-    """
-
-    knobs = {
-        "first_frame": start,
-        "last_frame": end
-    }
-
-    with avalon.nuke.viewer_update_and_undo_stop():
-        for key, value in knobs.items():
-            if root:
-                root[key].setValue(value)
-            else:
-                nuke.root()[key].setValue(value)
-
-
-def get_additional_data(container):
-    """Get Nuke's related data for the container
-
-    Args:
-        container(dict): the container found by the ls() function
-
-    Returns:
-        dict
-    """
-
-    node = container["_tool"]
-    tile_color = node['tile_color'].value()
-    if tile_color is None:
-        return {}
-
-    hex = '%08x' % tile_color
-    rgba = [
-        float(int(hex[0:2], 16)) / 255.0,
-        float(int(hex[2:4], 16)) / 255.0,
-        float(int(hex[4:6], 16)) / 255.0
-    ]
-
-    return {"color": QtGui.QColor().fromRgbF(rgba[0], rgba[1], rgba[2])}
-
-
 def set_viewers_colorspace(viewer):
     assert isinstance(viewer, dict), log.error(
         "set_viewers_colorspace(): argument should be dictionary")
@@ -245,6 +195,85 @@ def get_avalon_knob_data(node):
         return None
     return data
 
+
+def reset_resolution():
+    """Set resolution to project resolution."""
+    log.info("Reseting resolution")
+    project = io.find_one({"type": "project"})
+    asset = api.Session["AVALON_ASSET"]
+    asset = io.find_one({"name": asset, "type": "asset"})
+
+    try:
+        width = asset["data"].get("resolution_width", 1920)
+        height = asset["data"].get("resolution_height", 1080)
+        pixel_aspect = asset["data"].get("pixel_aspect", 1)
+
+        bbox = asset["data"].get("crop", "0.0.1920.1080")
+
+        try:
+            x, y, r, t = bbox.split(".")
+        except Exception as e:
+            x = 0
+            y = 0
+            r = width
+            t = height
+            log.error("{}: {} \nFormat:Crop need to be set with dots, example: "
+                      "0.0.1920.1080, /nSetting to default".format(__name__, e))
+
+    except KeyError:
+        log.warning(
+            "No resolution information found for \"{0}\".".format(
+                project["name"]
+            )
+        )
+        return
+
+    used_formats = list()
+    for f in nuke.formats():
+        if project["name"] in str(f.name()):
+            used_formats.append(f.name())
+        else:
+            format_name = project["name"] + "_1"
+
+    if used_formats:
+        format_name = "{}_{}".format(
+            project["name"],
+            int(used_formats[-1][-1])+1
+        )
+        log.info("Format exists: {}. "
+                 "Will create new: {}...".format(
+                     used_formats[-1],
+                     format_name)
+                 )
+
+    make_format(
+        width=int(width),
+        height=int(height),
+        x=int(x),
+        y=int(y),
+        r=int(r),
+        t=int(t),
+        pixel_aspect=float(pixel_aspect),
+        project_name=format_name
+    )
+    log.info("Format is set")
+
+
+def make_format(**args):
+    log.info("Format does't exist, will create: \n{}".format(args))
+    nuke.addFormat(
+        "{width} "
+        "{height} "
+        "{x} "
+        "{y} "
+        "{r} "
+        "{t} "
+        "{pixel_aspect} "
+        "{project_name}".format(**args)
+    )
+    nuke.root()["format"].setValue("{project_name}".format(**args))
+
+
 # TODO: bellow functions are wip and needs to be check where they are used
 # ------------------------------------
 

pype/nuke/menu.py

@@ -5,8 +5,17 @@ from pype.nuke import lib
 
 
 def install():
+
     menubar = nuke.menu("Nuke")
     menu = menubar.findItem(Session["AVALON_LABEL"])
 
-    menu.addSeparator()
-    menu.addCommand("Set colorspace...", lib.set_colorspace)
+    # replace reset resolution from avalon core to pype's
+    name = "Reset Resolution"
+    rm_item = [(i, item)
+               for i, item in enumerate(menu.items())
+               if name in item.name()][0]
+    menu.removeItem(rm_item[1].name())
+    menu.addCommand(rm_item[1].name(), lib.reset_resolution, index=rm_item[0])
+
+    # add colorspace menu item
+    menu.addCommand("Set colorspace...", lib.set_colorspace, index=rm_item[0]+1)