Formatting: use black (#6)

* mention formatting in readme

* add pyproject.toml with black settings

* black

* GHA: Add black-lint workflow

* formatting fixups

Author: Dragorn421

.github/workflows/black-lint.yml

@@ -0,0 +1,13 @@
+# https://black.readthedocs.io/en/stable/integrations/github_actions.html
+
+name: Black Lint
+
+on: [push, pull_request]
+
+jobs:
+  black-lint:
+    permissions: {} # Remove all permissions
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: psf/black@23.12.1

README.md

@@ -7,3 +7,9 @@ It for now performs on par with the EEVEE-nodes-based rendering present in Fast6
 It also offers increased accuracy, with for example blender cycles emulation which is not possible with EEVEE.
 
 It is currently in development but very usable already!
+
+## Development
+
+### Formatting
+
+This repo uses [the same formatting policy as fast64, using black version 23](https://github.com/Fast-64/fast64/blob/main/README.md#formatting).

__init__.py

@@ -12,21 +12,23 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 bl_info = {
-    "name" : "f64render",
-    "author" : "Max Bebök, Fast64 community",
-    "description" : "Render engine for fast64 materials.",
-    "blender" : (3, 2, 0),
-    "version" : (0, 0, 1),
-    "location" : "Render Properties > Render Engine",
-    "category" : "3D View"
+    "name": "f64render",
+    "author": "Max Bebök, Fast64 community",
+    "description": "Render engine for fast64 materials.",
+    "blender": (3, 2, 0),
+    "version": (0, 0, 1),
+    "location": "Render Properties > Render Engine",
+    "category": "3D View",
 }
 
 from . import auto_load
 
 auto_load.init()
 
+
 def register():
     auto_load.register()
 
+
 def unregister():
     auto_load.unregister()

auto_load.py

@@ -18,13 +18,15 @@
 modules = None
 ordered_classes = None
 
+
 def init():
     global modules
     global ordered_classes
 
     modules = get_all_submodules(Path(__file__).parent)
     ordered_classes = get_ordered_classes_to_register(modules)
 
+
 def register():
     for cls in ordered_classes:
         bpy.utils.register_class(cls)
@@ -35,6 +37,7 @@ def register():
         if hasattr(module, "register"):
             module.register()
 
+
 def unregister():
     for cls in reversed(ordered_classes):
         bpy.utils.unregister_class(cls)
@@ -49,13 +52,16 @@ def unregister():
 # Import modules
 #################################################
 
+
 def get_all_submodules(directory):
     return list(iter_submodules(directory, __package__))
 
+
 def iter_submodules(path, package_name):
     for name in sorted(iter_submodule_names(path)):
         yield importlib.import_module("." + name, package_name)
 
+
 def iter_submodule_names(path, root=""):
     for _, module_name, is_package in pkgutil.iter_modules([str(path)]):
         if is_package:
@@ -69,29 +75,34 @@ def iter_submodule_names(path, root=""):
 # Find classes to register
 #################################################
 
+
 def get_ordered_classes_to_register(modules):
     return toposort(get_register_deps_dict(modules))
 
+
 def get_register_deps_dict(modules):
     my_classes = set(iter_my_classes(modules))
-    my_classes_by_idname = {cls.bl_idname : cls for cls in my_classes if hasattr(cls, "bl_idname")}
+    my_classes_by_idname = {cls.bl_idname: cls for cls in my_classes if hasattr(cls, "bl_idname")}
 
     deps_dict = {}
     for cls in my_classes:
         deps_dict[cls] = set(iter_my_register_deps(cls, my_classes, my_classes_by_idname))
     return deps_dict
 
+
 def iter_my_register_deps(cls, my_classes, my_classes_by_idname):
     yield from iter_my_deps_from_annotations(cls, my_classes)
     yield from iter_my_deps_from_parent_id(cls, my_classes_by_idname)
 
+
 def iter_my_deps_from_annotations(cls, my_classes):
     for value in typing.get_type_hints(cls, {}, {}).values():
         dependency = get_dependency_from_annotation(value)
         if dependency is not None:
             if dependency in my_classes:
                 yield dependency
 
+
 def get_dependency_from_annotation(value):
     if blender_version >= (2, 93):
         if isinstance(value, bpy.props._PropertyDeferred):
@@ -102,6 +113,7 @@ def get_dependency_from_annotation(value):
                 return value[1]["type"]
     return None
 
+
 def iter_my_deps_from_parent_id(cls, my_classes_by_idname):
     if issubclass(cls, bpy.types.Panel):
         parent_idname = getattr(cls, "bl_parent_id", None)
@@ -110,38 +122,54 @@ def iter_my_deps_from_parent_id(cls, my_classes_by_idname):
             if parent_cls is not None:
                 yield parent_cls
 
+
 def iter_my_classes(modules):
     base_types = get_register_base_types()
     for cls in get_classes_in_modules(modules):
         if any(issubclass(cls, base) for base in base_types):
             if not getattr(cls, "is_registered", False):
                 yield cls
 
+
 def get_classes_in_modules(modules):
     classes = set()
     for module in modules:
         for cls in iter_classes_in_module(module):
             classes.add(cls)
     return classes
 
+
 def iter_classes_in_module(module):
     for value in module.__dict__.values():
         if inspect.isclass(value):
             yield value
 
+
 def get_register_base_types():
-    return set(getattr(bpy.types, name) for name in [
-        "Panel", "Operator", "PropertyGroup",
-        "AddonPreferences", "Header", "Menu",
-        "Node", "NodeSocket", "NodeTree",
-        "UIList", "RenderEngine",
-        "Gizmo", "GizmoGroup",
-    ])
+    return set(
+        getattr(bpy.types, name)
+        for name in [
+            "Panel",
+            "Operator",
+            "PropertyGroup",
+            "AddonPreferences",
+            "Header",
+            "Menu",
+            "Node",
+            "NodeSocket",
+            "NodeTree",
+            "UIList",
+            "RenderEngine",
+            "Gizmo",
+            "GizmoGroup",
+        ]
+    )
 
 
 # Find order to register to solve dependencies
 #################################################
 
+
 def toposort(deps_dict):
     sorted_list = []
     sorted_values = set()
@@ -153,5 +181,5 @@ def toposort(deps_dict):
                 sorted_values.add(value)
             else:
                 unsorted.append(value)
-        deps_dict = {value : deps_dict[value] - sorted_values for value in unsorted}
+        deps_dict = {value: deps_dict[value] - sorted_values for value in unsorted}
     return sorted_list