diff --git a/pype/lib.py b/pype/lib.py
index b19491adeb..f26395d930 100644
--- a/pype/lib.py
+++ b/pype/lib.py
@@ -196,9 +196,13 @@ def any_outdated():
         if representation in checked:
             continue
 
-        representation_doc = io.find_one({"_id": io.ObjectId(representation),
-                                          "type": "representation"},
-                                         projection={"parent": True})
+        representation_doc = io.find_one(
+            {
+                "_id": io.ObjectId(representation),
+                "type": "representation"
+            },
+            projection={"parent": True}
+        )
         if representation_doc and not is_latest(representation_doc):
             return True
         elif not representation_doc:
@@ -308,27 +312,38 @@ def switch_item(container,
             representation_name = representation["name"]
 
     # Find the new one
-    asset = io.find_one({"name": asset_name, "type": "asset"})
+    asset = io.find_one({
+        "name": asset_name,
+        "type": "asset"
+    })
     assert asset, ("Could not find asset in the database with the name "
                    "'%s'" % asset_name)
 
-    subset = io.find_one({"name": subset_name,
-                          "type": "subset",
-                          "parent": asset["_id"]})
+    subset = io.find_one({
+        "name": subset_name,
+        "type": "subset",
+        "parent": asset["_id"]
+    })
     assert subset, ("Could not find subset in the database with the name "
                     "'%s'" % subset_name)
 
-    version = io.find_one({"type": "version",
-                           "parent": subset["_id"]},
-                          sort=[('name', -1)])
+    version = io.find_one(
+        {
+            "type": "version",
+            "parent": subset["_id"]
+        },
+        sort=[('name', -1)]
+    )
 
     assert version, "Could not find a version for {}.{}".format(
         asset_name, subset_name
     )
 
-    representation = io.find_one({"name": representation_name,
-                                  "type": "representation",
-                                  "parent": version["_id"]})
+    representation = io.find_one({
+        "name": representation_name,
+        "type": "representation",
+        "parent": version["_id"]}
+    )
 
     assert representation, ("Could not find representation in the database with"
                             " the name '%s'" % representation_name)
@@ -366,7 +381,10 @@ def get_asset(asset_name=None):
     if not asset_name:
         asset_name = avalon.api.Session["AVALON_ASSET"]
 
-    asset_document = io.find_one({"name": asset_name, "type": "asset"})
+    asset_document = io.find_one({
+        "name": asset_name,
+        "type": "asset"
+    })
     if not asset_document:
         raise TypeError("Entity \"{}\" was not found in DB".format(asset_name))
 
@@ -538,8 +556,7 @@ def get_subsets(asset_name,
     from avalon import io
 
     # query asset from db
-    asset_io = io.find_one({"type": "asset",
-                            "name": asset_name})
+    asset_io = io.find_one({"type": "asset", "name": asset_name})
 
     # check if anything returned
     assert asset_io, "Asset not existing. \
@@ -563,14 +580,20 @@ def get_subsets(asset_name,
     # Process subsets
     for subset in subsets:
         if not version:
-            version_sel = io.find_one({"type": "version",
-                                       "parent": subset["_id"]},
-                                      sort=[("name", -1)])
+            version_sel = io.find_one(
+                {
+                    "type": "version",
+                    "parent": subset["_id"]
+                },
+                sort=[("name", -1)]
+            )
         else:
             assert isinstance(version, int), "version needs to be `int` type"
-            version_sel = io.find_one({"type": "version",
-                                       "parent": subset["_id"],
-                                       "name": int(version)})
+            version_sel = io.find_one({
+                "type": "version",
+                "parent": subset["_id"],
+                "name": int(version)
+            })
 
         find_dict = {"type": "representation",
                      "parent": version_sel["_id"]}
diff --git a/pype/plugins/global/publish/collect_templates.py b/pype/plugins/global/publish/collect_templates.py
index e27af82595..383944e293 100644
--- a/pype/plugins/global/publish/collect_templates.py
+++ b/pype/plugins/global/publish/collect_templates.py
@@ -31,32 +31,44 @@ class CollectTemplates(pyblish.api.InstancePlugin):
         asset_name = instance.data["asset"]
         project_name = api.Session["AVALON_PROJECT"]
 
-        project = io.find_one({"type": "project",
-                               "name": project_name},
-                              projection={"config": True, "data": True})
+        project = io.find_one(
+            {
+                "type": "project",
+                "name": project_name
+            },
+            projection={"config": True, "data": True}
+        )
 
         template = project["config"]["template"]["publish"]
         anatomy = instance.context.data['anatomy']
 
-        asset = io.find_one({"type": "asset",
-                             "name": asset_name,
-                             "parent": project["_id"]})
+        asset = io.find_one({
+            "type": "asset",
+            "name": asset_name,
+            "parent": project["_id"]
+        })
 
         assert asset, ("No asset found by the name '{}' "
                        "in project '{}'".format(asset_name, project_name))
         silo = asset.get('silo')
 
-        subset = io.find_one({"type": "subset",
-                              "name": subset_name,
-                              "parent": asset["_id"]})
+        subset = io.find_one({
+            "type": "subset",
+            "name": subset_name,
+            "parent": asset["_id"]
+        })
 
         # assume there is no version yet, we start at `1`
         version = None
         version_number = 1
         if subset is not None:
-            version = io.find_one({"type": "version",
-                                   "parent": subset["_id"]},
-                                  sort=[("name", -1)])
+            version = io.find_one(
+                {
+                    "type": "version",
+                    "parent": subset["_id"]
+                },
+                sort=[("name", -1)]
+            )
 
         # if there is a subset there ought to be version
         if version is not None:
diff --git a/pype/plugins/global/publish/integrate.py b/pype/plugins/global/publish/integrate.py
index 59e05ee2aa..e24bad362d 100644
--- a/pype/plugins/global/publish/integrate.py
+++ b/pype/plugins/global/publish/integrate.py
@@ -84,9 +84,11 @@ class IntegrateAsset(pyblish.api.InstancePlugin):
 
         project = io.find_one({"type": "project"})
 
-        asset = io.find_one({"type": "asset",
-                             "name": ASSET,
-                             "parent": project["_id"]})
+        asset = io.find_one({
+            "type": "asset",
+            "name": ASSET,
+            "parent": project["_id"]
+        })
 
         assert all([project, asset]), ("Could not find current project or "
                                        "asset '%s'" % ASSET)
@@ -94,10 +96,14 @@ class IntegrateAsset(pyblish.api.InstancePlugin):
         subset = self.get_subset(asset, instance)
 
         # get next version
-        latest_version = io.find_one({"type": "version",
-                                      "parent": subset["_id"]},
-                                     {"name": True},
-                                     sort=[("name", -1)])
+        latest_version = io.find_one(
+            {
+                "type": "version",
+                "parent": subset["_id"]
+            },
+            {"name": True},
+            sort=[("name", -1)]
+        )
 
         next_version = 1
         if latest_version is not None:
@@ -318,9 +324,11 @@ class IntegrateAsset(pyblish.api.InstancePlugin):
 
     def get_subset(self, asset, instance):
 
-        subset = io.find_one({"type": "subset",
-                              "parent": asset["_id"],
-                              "name": instance.data["subset"]})
+        subset = io.find_one({
+            "type": "subset",
+            "parent": asset["_id"],
+            "name": instance.data["subset"]
+        })
 
         if subset is None:
             subset_name = instance.data["subset"]
diff --git a/pype/plugins/global/publish/integrate_assumed_destination.py b/pype/plugins/global/publish/integrate_assumed_destination.py
index a26529fc2c..d090e2711a 100644
--- a/pype/plugins/global/publish/integrate_assumed_destination.py
+++ b/pype/plugins/global/publish/integrate_assumed_destination.py
@@ -82,31 +82,40 @@ class IntegrateAssumedDestination(pyblish.api.InstancePlugin):
         project_name = api.Session["AVALON_PROJECT"]
         a_template = anatomy.templates
 
-        project = io.find_one({"type": "project",
-                               "name": project_name},
-                              projection={"config": True, "data": True})
+        project = io.find_one(
+            {"type": "project", "name": project_name},
+            projection={"config": True, "data": True}
+        )
 
         template = a_template['publish']['path']
         # anatomy = instance.context.data['anatomy']
 
-        asset = io.find_one({"type": "asset",
-                             "name": asset_name,
-                             "parent": project["_id"]})
+        asset = io.find_one({
+            "type": "asset",
+            "name": asset_name,
+            "parent": project["_id"]
+        })
 
         assert asset, ("No asset found by the name '{}' "
                        "in project '{}'".format(asset_name, project_name))
 
-        subset = io.find_one({"type": "subset",
-                              "name": subset_name,
-                              "parent": asset["_id"]})
+        subset = io.find_one({
+            "type": "subset",
+            "name": subset_name,
+            "parent": asset["_id"]
+        })
 
         # assume there is no version yet, we start at `1`
         version = None
         version_number = 1
         if subset is not None:
-            version = io.find_one({"type": "version",
-                                   "parent": subset["_id"]},
-                                  sort=[("name", -1)])
+            version = io.find_one(
+                {
+                    "type": "version",
+                    "parent": subset["_id"]
+                },
+                sort=[("name", -1)]
+            )
 
         # if there is a subset there ought to be version
         if version is not None:
diff --git a/pype/plugins/global/publish/integrate_new.py b/pype/plugins/global/publish/integrate_new.py
index e6d8561824..d860452734 100644
--- a/pype/plugins/global/publish/integrate_new.py
+++ b/pype/plugins/global/publish/integrate_new.py
@@ -153,9 +153,11 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
         io.install()
         project = io.find_one({"type": "project"})
 
-        asset = io.find_one({"type": "asset",
-                             "name": ASSET,
-                             "parent": project["_id"]})
+        asset = io.find_one({
+            "type": "asset",
+            "name": ASSET,
+            "parent": project["_id"]
+        })
 
         assert all([project, asset]), ("Could not find current project or "
                                        "asset '%s'" % ASSET)
@@ -163,10 +165,14 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
         subset = self.get_subset(asset, instance)
 
         # get next version
-        latest_version = io.find_one({"type": "version",
-                                      "parent": subset["_id"]},
-                                     {"name": True},
-                                     sort=[("name", -1)])
+        latest_version = io.find_one(
+            {
+                "type": "version",
+                "parent": subset["_id"]
+            },
+            {"name": True},
+            sort=[("name", -1)]
+        )
 
         next_version = 1
         if latest_version is not None:
@@ -521,9 +527,11 @@ class IntegrateAssetNew(pyblish.api.InstancePlugin):
         filelink.create(src, dst, filelink.HARDLINK)
 
     def get_subset(self, asset, instance):
-        subset = io.find_one({"type": "subset",
-                              "parent": asset["_id"],
-                              "name": instance.data["subset"]})
+        subset = io.find_one({
+            "type": "subset",
+            "parent": asset["_id"],
+            "name": instance.data["subset"]
+        })
 
         if subset is None:
             subset_name = instance.data["subset"]
diff --git a/pype/plugins/global/publish/integrate_rendered_frames.py b/pype/plugins/global/publish/integrate_rendered_frames.py
index 086b03802e..5819051146 100644
--- a/pype/plugins/global/publish/integrate_rendered_frames.py
+++ b/pype/plugins/global/publish/integrate_rendered_frames.py
@@ -88,9 +88,11 @@ class IntegrateFrames(pyblish.api.InstancePlugin):
 
         project = io.find_one({"type": "project"})
 
-        asset = io.find_one({"type": "asset",
-                             "name": ASSET,
-                             "parent": project["_id"]})
+        asset = io.find_one({
+            "type": "asset",
+            "name": ASSET,
+            "parent": project["_id"]
+        })
 
         assert all([project, asset]), ("Could not find current project or "
                                        "asset '%s'" % ASSET)
@@ -98,10 +100,14 @@ class IntegrateFrames(pyblish.api.InstancePlugin):
         subset = self.get_subset(asset, instance)
 
         # get next version
-        latest_version = io.find_one({"type": "version",
-                                      "parent": subset["_id"]},
-                                     {"name": True},
-                                     sort=[("name", -1)])
+        latest_version = io.find_one(
+            {
+                "type": "version",
+                "parent": subset["_id"]
+            },
+            {"name": True},
+            sort=[("name", -1)]
+        )
 
         next_version = 1
         if latest_version is not None:
@@ -251,9 +257,6 @@ class IntegrateFrames(pyblish.api.InstancePlugin):
 
             self.log.debug("path_to_save: {}".format(path_to_save))
 
-
-
-
             representation = {
                 "schema": "pype:representation-2.0",
                 "type": "representation",
@@ -332,9 +335,11 @@ class IntegrateFrames(pyblish.api.InstancePlugin):
 
     def get_subset(self, asset, instance):
 
-        subset = io.find_one({"type": "subset",
-                              "parent": asset["_id"],
-                              "name": instance.data["subset"]})
+        subset = io.find_one({
+            "type": "subset",
+            "parent": asset["_id"],
+            "name": instance.data["subset"]
+        })
 
         if subset is None:
             subset_name = instance.data["subset"]
diff --git a/pype/plugins/global/publish/submit_publish_job.py b/pype/plugins/global/publish/submit_publish_job.py
index 12737880d0..9dd917ed55 100644
--- a/pype/plugins/global/publish/submit_publish_job.py
+++ b/pype/plugins/global/publish/submit_publish_job.py
@@ -33,14 +33,22 @@ def _get_script():
 # Logic to retrieve latest files concerning extendFrames
 def get_latest_version(asset_name, subset_name, family):
     # Get asset
-    asset_name = io.find_one({"type": "asset",
-                              "name": asset_name},
-                             projection={"name": True})
+    asset_name = io.find_one(
+        {
+            "type": "asset",
+            "name": asset_name
+        },
+        projection={"name": True}
+    )
 
-    subset = io.find_one({"type": "subset",
-                          "name": subset_name,
-                          "parent": asset_name["_id"]},
-                         projection={"_id": True, "name": True})
+    subset = io.find_one(
+        {
+            "type": "subset",
+            "name": subset_name,
+            "parent": asset_name["_id"]
+        },
+        projection={"_id": True, "name": True}
+    )
 
     # Check if subsets actually exists (pre-run check)
     assert subset, "No subsets found, please publish with `extendFrames` off"
@@ -51,11 +59,15 @@ def get_latest_version(asset_name, subset_name, family):
                           "data.endFrame": True,
                           "parent": True}
 
-    version = io.find_one({"type": "version",
-                           "parent": subset["_id"],
-                           "data.families": family},
-                          projection=version_projection,
-                          sort=[("name", -1)])
+    version = io.find_one(
+        {
+            "type": "version",
+            "parent": subset["_id"],
+            "data.families": family
+        },
+        projection=version_projection,
+        sort=[("name", -1)]
+    )
 
     assert version, "No version found, this is a bug"
 
diff --git a/pype/plugins/maya/load/load_look.py b/pype/plugins/maya/load/load_look.py
index b1c88bcd18..04ac9b23e4 100644
--- a/pype/plugins/maya/load/load_look.py
+++ b/pype/plugins/maya/load/load_look.py
@@ -116,9 +116,11 @@ class LookLoader(pype.maya.plugin.ReferenceLoader):
                                                          shapes=True))
         nodes = set(nodes_list)
 
-        json_representation = io.find_one({"type": "representation",
-                                           "parent": representation['parent'],
-                                           "name": "json"})
+        json_representation = io.find_one({
+            "type": "representation",
+            "parent": representation['parent'],
+            "name": "json"
+        })
 
         # Load relationships
         shader_relation = api.get_representation_path(json_representation)
diff --git a/pype/plugins/maya/publish/extract_look.py b/pype/plugins/maya/publish/extract_look.py
index 5226f80f7a..fa6ecd72c3 100644
--- a/pype/plugins/maya/publish/extract_look.py
+++ b/pype/plugins/maya/publish/extract_look.py
@@ -429,33 +429,42 @@ class ExtractLook(pype.api.Extractor):
         a_template = anatomy.templates
 
         project = io.find_one(
-            {"type": "project", "name": project_name},
-            projection={"config": True, "data": True},
+            {
+                "type": "project",
+                "name": project_name
+            },
+            projection={"config": True, "data": True}
         )
 
         template = a_template["publish"]["path"]
         # anatomy = instance.context.data['anatomy']
 
-        asset = io.find_one(
-            {"type": "asset", "name": asset_name, "parent": project["_id"]}
-        )
+        asset = io.find_one({
+            "type": "asset",
+            "name": asset_name,
+            "parent": project["_id"]
+        })
 
         assert asset, ("No asset found by the name '{}' "
                        "in project '{}'").format(asset_name, project_name)
         silo = asset.get("silo")
 
-        subset = io.find_one(
-            {"type": "subset", "name": subset_name, "parent": asset["_id"]}
-        )
+        subset = io.find_one({
+            "type": "subset",
+            "name": subset_name,
+            "parent": asset["_id"]
+        })
 
         # assume there is no version yet, we start at `1`
         version = None
         version_number = 1
         if subset is not None:
             version = io.find_one(
-                {"type": "version",
-                 "parent": subset["_id"]
-                 }, sort=[("name", -1)]
+                {
+                    "type": "version",
+                    "parent": subset["_id"]
+                },
+                sort=[("name", -1)]
             )
 
         # if there is a subset there ought to be version
diff --git a/pype/plugins/maya/publish/validate_node_ids_related.py b/pype/plugins/maya/publish/validate_node_ids_related.py
index 4872f438d4..191ac0c2f8 100644
--- a/pype/plugins/maya/publish/validate_node_ids_related.py
+++ b/pype/plugins/maya/publish/validate_node_ids_related.py
@@ -38,9 +38,13 @@ class ValidateNodeIDsRelated(pyblish.api.InstancePlugin):
         invalid = list()
 
         asset = instance.data['asset']
-        asset_data = io.find_one({"name": asset,
-                                  "type": "asset"},
-                                 projection={"_id": True})
+        asset_data = io.find_one(
+            {
+                "name": asset,
+                "type": "asset"
+            },
+            projection={"_id": True}
+        )
         asset_id = str(asset_data['_id'])
 
         # We do want to check the referenced nodes as we it might be
diff --git a/pype/plugins/maya/publish/validate_renderlayer_aovs.py b/pype/plugins/maya/publish/validate_renderlayer_aovs.py
index e14c92a8b4..686a11e906 100644
--- a/pype/plugins/maya/publish/validate_renderlayer_aovs.py
+++ b/pype/plugins/maya/publish/validate_renderlayer_aovs.py
@@ -49,9 +49,10 @@ class ValidateRenderLayerAOVs(pyblish.api.InstancePlugin):
         """Check if subset is registered in the database under the asset"""
 
         asset = io.find_one({"type": "asset", "name": asset_name})
-        is_valid = io.find_one({"type": "subset",
-                                "name": subset_name,
-                                "parent": asset["_id"]})
+        is_valid = io.find_one({
+            "type": "subset",
+            "name": subset_name,
+            "parent": asset["_id"]
+        })
 
         return is_valid
-
diff --git a/pype/plugins/nuke/publish/collect_asset_info.py b/pype/plugins/nuke/publish/collect_asset_info.py
index 76b93ef3d0..8a8791ec36 100644
--- a/pype/plugins/nuke/publish/collect_asset_info.py
+++ b/pype/plugins/nuke/publish/collect_asset_info.py
@@ -13,8 +13,10 @@ class CollectAssetInfo(pyblish.api.ContextPlugin):
     ]
 
     def process(self, context):
-        asset_data = io.find_one({"type": "asset",
-                                  "name": api.Session["AVALON_ASSET"]})
+        asset_data = io.find_one({
+            "type": "asset",
+            "name": api.Session["AVALON_ASSET"]
+        })
         self.log.info("asset_data: {}".format(asset_data))
 
         context.data['handles'] = int(asset_data["data"].get("handles", 0))
diff --git a/pype/plugins/nuke/publish/collect_instances.py b/pype/plugins/nuke/publish/collect_instances.py
index c5fb289a1e..5b123ed7b9 100644
--- a/pype/plugins/nuke/publish/collect_instances.py
+++ b/pype/plugins/nuke/publish/collect_instances.py
@@ -15,9 +15,10 @@ class CollectNukeInstances(pyblish.api.ContextPlugin):
     hosts = ["nuke", "nukeassist"]
 
     def process(self, context):
-
-        asset_data = io.find_one({"type": "asset",
-                                  "name": api.Session["AVALON_ASSET"]})
+        asset_data = io.find_one({
+            "type": "asset",
+            "name": api.Session["AVALON_ASSET"]
+        })
 
         self.log.debug("asset_data: {}".format(asset_data["data"]))
         instances = []
diff --git a/pype/plugins/nukestudio/publish/extract_effects.py b/pype/plugins/nukestudio/publish/extract_effects.py
index 7aa79d6cc3..15d2a80a55 100644
--- a/pype/plugins/nukestudio/publish/extract_effects.py
+++ b/pype/plugins/nukestudio/publish/extract_effects.py
@@ -169,32 +169,44 @@ class ExtractVideoTracksLuts(pyblish.api.InstancePlugin):
         project_name = api.Session["AVALON_PROJECT"]
         a_template = anatomy.templates
 
-        project = io.find_one({"type": "project",
-                               "name": project_name},
-                              projection={"config": True, "data": True})
+        project = io.find_one(
+            {
+                "type": "project",
+                "name": project_name
+            },
+            projection={"config": True, "data": True}
+        )
 
         template = a_template['publish']['path']
         # anatomy = instance.context.data['anatomy']
 
-        asset = io.find_one({"type": "asset",
-                             "name": asset_name,
-                             "parent": project["_id"]})
+        asset = io.find_one({
+            "type": "asset",
+            "name": asset_name,
+            "parent": project["_id"]
+        })
 
         assert asset, ("No asset found by the name '{}' "
                        "in project '{}'".format(asset_name, project_name))
         silo = asset.get('silo')
 
-        subset = io.find_one({"type": "subset",
-                              "name": subset_name,
-                              "parent": asset["_id"]})
+        subset = io.find_one({
+            "type": "subset",
+            "name": subset_name,
+            "parent": asset["_id"]
+        })
 
         # assume there is no version yet, we start at `1`
         version = None
         version_number = 1
         if subset is not None:
-            version = io.find_one({"type": "version",
-                                   "parent": subset["_id"]},
-                                  sort=[("name", -1)])
+            version = io.find_one(
+                {
+                    "type": "version",
+                    "parent": subset["_id"]
+                },
+                sort=[("name", -1)]
+            )
 
         # if there is a subset there ought to be version
         if version is not None:
diff --git a/pype/plugins/nukestudio/publish/validate_version.py b/pype/plugins/nukestudio/publish/validate_version.py
index 194b270d51..ebb8f357f8 100644
--- a/pype/plugins/nukestudio/publish/validate_version.py
+++ b/pype/plugins/nukestudio/publish/validate_version.py
@@ -3,6 +3,7 @@ from avalon import io
 from pype.action import get_errored_instances_from_context
 import pype.api as pype
 
+
 @pyblish.api.log
 class RepairNukestudioVersionUp(pyblish.api.Action):
     label = "Version Up Workfile"
@@ -53,13 +54,17 @@ class ValidateVersion(pyblish.api.InstancePlugin):
             io.install()
             project = io.find_one({"type": "project"})
 
-            asset = io.find_one({"type": "asset",
-                                 "name": asset_name,
-                                 "parent": project["_id"]})
+            asset = io.find_one({
+                "type": "asset",
+                "name": asset_name,
+                "parent": project["_id"]
+            })
 
-            subset = io.find_one({"type": "subset",
-                                  "parent": asset["_id"],
-                                  "name": subset_name})
+            subset = io.find_one({
+                "type": "subset",
+                "parent": asset["_id"],
+                "name": subset_name
+            })
 
             version_db = io.find_one({
                 'type': 'version',
diff --git a/pype/plugins/premiere/publish/integrate_assumed_destination.py b/pype/plugins/premiere/publish/integrate_assumed_destination.py
index c82b70c66f..a0393e8a43 100644
--- a/pype/plugins/premiere/publish/integrate_assumed_destination.py
+++ b/pype/plugins/premiere/publish/integrate_assumed_destination.py
@@ -77,32 +77,44 @@ class IntegrateAssumedDestination(pyblish.api.InstancePlugin):
         asset_name = instance.data["asset"]
         project_name = api.Session["AVALON_PROJECT"]
 
-        project = io.find_one({"type": "project",
-                               "name": project_name},
-                              projection={"config": True, "data": True})
+        project = io.find_one(
+            {
+                "type": "project",
+                "name": project_name
+            },
+            projection={"config": True, "data": True}
+        )
 
         template = project["config"]["template"]["publish"]
         # anatomy = instance.context.data['anatomy']
 
-        asset = io.find_one({"type": "asset",
-                             "name": asset_name,
-                             "parent": project["_id"]})
+        asset = io.find_one({
+            "type": "asset",
+            "name": asset_name,
+            "parent": project["_id"]
+        })
 
         assert asset, ("No asset found by the name '{}' "
                        "in project '{}'".format(asset_name, project_name))
         silo = asset.get('silo')
 
-        subset = io.find_one({"type": "subset",
-                              "name": subset_name,
-                              "parent": asset["_id"]})
+        subset = io.find_one({
+            "type": "subset",
+            "name": subset_name,
+            "parent": asset["_id"]
+        })
 
         # assume there is no version yet, we start at `1`
         version = None
         version_number = 1
         if subset is not None:
-            version = io.find_one({"type": "version",
-                                   "parent": subset["_id"]},
-                                  sort=[("name", -1)])
+            version = io.find_one(
+                {
+                    "type": "version",
+                    "parent": subset["_id"]
+                },
+                sort=[("name", -1)]
+            )
 
         # if there is a subset there ought to be version
         if version is not None:
diff --git a/pype/scripts/fusion_switch_shot.py b/pype/scripts/fusion_switch_shot.py
index 26a93b9b9a..539bcf4f68 100644
--- a/pype/scripts/fusion_switch_shot.py
+++ b/pype/scripts/fusion_switch_shot.py
@@ -170,8 +170,10 @@ def switch(asset_name, filepath=None, new=True):
     assert asset, "Could not find '%s' in the database" % asset_name
 
     # Get current project
-    self._project = io.find_one({"type": "project",
-                                 "name": api.Session["AVALON_PROJECT"]})
+    self._project = io.find_one({
+        "type": "project",
+        "name": api.Session["AVALON_PROJECT"]
+    })
 
     # Go to comp
     if not filepath:
diff --git a/pype/setdress_api.py b/pype/setdress_api.py
index 55a6b4a2fb..707a5b713f 100644
--- a/pype/setdress_api.py
+++ b/pype/setdress_api.py
@@ -462,8 +462,12 @@ def update_scene(set_container, containers, current_data, new_data, new_file):
                 # Check whether the conversion can be done by the Loader.
                 # They *must* use the same asset, subset and Loader for
                 # `api.update` to make sense.
-                old = io.find_one({"_id": io.ObjectId(representation_current)})
-                new = io.find_one({"_id": io.ObjectId(representation_new)})
+                old = io.find_one({
+                    "_id": io.ObjectId(representation_current)
+                })
+                new = io.find_one({
+                    "_id": io.ObjectId(representation_new)
+                })
                 is_valid = compare_representations(old=old, new=new)
                 if not is_valid:
                     log.error("Skipping: %s. See log for details.",