Switch to uv and ruff

Author: Moguri

.github/workflows/pipeline.yaml

@@ -10,25 +10,20 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
     - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: astral-sh/setup-uv@v6
       with:
         python-version: ${{ matrix.pyversion }}
     - name: Run Tests
-      run: |
-        python -m pip install -e .[test]
-        python -m pytest
+      run: uv run pytest
   build:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v4
-    - uses: actions/setup-python@v5
+    - uses: astral-sh/setup-uv@v6
       with:
         python-version: 3.9
     - name: Build package
-      run: |
-        python -m pip install -e .
-        python -m pip install --upgrade build
-        python -m build
+      run: uv build
     - name: Publish package
       if: github.event_name == 'push' && startsWith(github.event.ref, 'refs/tags')
       uses: pypa/gh-action-pypi-publish@release/v1

README.md

@@ -75,30 +75,14 @@ This is a simple viewer (like `pview`) to view glTF (or any other file format su
 
 ## Running Tests
 
-First install `panda3d-gltf` in editable mode along with `test` extras:
-
-```bash
-pip install -e .[test]
-```
-
-Then run the test suite with `pytest`:
-
 ```bash
-pytest
+uv run pytest
 ```
 
 ## Building Wheels
 
-Install `build`:
-
-```bash
-pip install --upgrade build
-```
-
-and run:
-
 ```bash
-python -m build
+uv build
 ```
 
 ## License

gltf/__init__.py

@@ -1,5 +1,3 @@
-import panda3d.core as p3d
-
 from .version import __version__
 from ._converter import GltfSettings
 from ._loader import load_model

gltf/_converter.py

@@ -1,24 +1,21 @@
-from __future__ import annotations
-
 import base64
 import collections
 import itertools
 import os
 import math
 import struct
 import urllib.parse
-import pprint # pylint: disable=unused-import
 
 from dataclasses import dataclass
 
-from panda3d.core import * # pylint: disable=wildcard-import
+from panda3d.core import *
 import panda3d.core as p3d
 try:
     from panda3d import bullet
     HAVE_BULLET = True
 except ImportError:
     HAVE_BULLET = False
-from direct.stdpy.file import open # pylint: disable=redefined-builtin
+from direct.stdpy.file import open  # noqa: A004
 
 from ._converter_maps import (
     ATTRIB_CONTENT_MAP,
@@ -111,8 +108,8 @@ def get_lerp_factor(currtime: float, lasttime: float, nexttime: float) -> float:
 class CharInfo:
     character: p3d.Character
     nodepath: p3d.NodePath
-    jvtmap: 'dict[int, p3d.JointVertexTransform]'
-    cvsmap: 'dict[tuple[int, str], p3d.CharacterVertexSlider]'
+    jvtmap: dict[int, p3d.JointVertexTransform]
+    cvsmap: dict[tuple[int, str], p3d.CharacterVertexSlider]
 
     def __init__(self, name: str):
         self.character = p3d.Character(name)
@@ -121,9 +118,7 @@ def __init__(self, name: str):
         self.cvsmap = {}
 
 
-class Converter():
-
-
+class Converter:
     def __init__(
             self,
             filepath,
@@ -253,7 +248,7 @@ def add_node(root, gltf_scene, nodeid):
             charinfo = self.characters.get(skinid, None)
             scene_extras = get_extras(gltf_scene)
             node_name = gltf_node.get('name', 'node'+str(nodeid))
-            if nodeid in self._joint_nodes and not nodeid in self.skeletons:
+            if nodeid in self._joint_nodes and nodeid not in self.skeletons:
                 # Handle non-joint children of joints, but don't add joints themselves
                 for child_nodeid in gltf_node.get('children', []):
                     add_node(root, gltf_scene, child_nodeid)
@@ -482,8 +477,10 @@ def load_buffer(self, buffid, gltf_buffer):
         uri = gltf_buffer['uri']
         if uri == '_glb_bin' and buffid == 0:
             buff_data = gltf_buffer['_glb_bin']
-        elif uri.startswith('data:application/octet-stream;base64') or \
-           uri.startswith('data:application/gltf-buffer;base64'):
+        elif uri.startswith((
+            'data:application/octet-stream;base64',
+            'data:application/gltf-buffer;base64',
+        )):
             buff_data = gltf_buffer['uri'].split(',')[1]
             buff_data = base64.b64decode(buff_data)
         elif uri.endswith('.bin'):
@@ -538,8 +535,7 @@ def get_buffer_from_accessor(self, gltf_data, accid, unpack=True):
 
         if unpack:
             return list(map(convertfn, struct.iter_unpack(f'<{formatstr}', buffdata)))
-        else:
-            return buffdata
+        return buffdata
 
     def get_texture_stage(self, slot_name, texmode, texcoord):
         texcoord = str(texcoord)
@@ -916,14 +912,17 @@ def load_primitive(self, geom_node, gltf_primitive, gltf_mesh, gltf_data):
         accessors = sorted(accessors, key=lambda x: x['bufferView'])
         data_copies = []
         is_skinned = 'JOINTS_0' in mesh_attribs
-        calc_normals = not 'NORMAL' in mesh_attribs
-        calc_tangents = not 'TANGENT' in mesh_attribs
+        calc_normals = 'NORMAL' not in mesh_attribs
+        calc_tangents = 'TANGENT' not in mesh_attribs
         normalize_weights = False
 
-        for buffview, accs in itertools.groupby(accessors, key=lambda x: x['bufferView']):
+        for buffview, accs_unsorted in itertools.groupby(accessors, key=lambda x: x['bufferView']):
             buffview = gltf_data['bufferViews'][buffview]
-            accs = sorted(accs, key=lambda x: x.get('byteOffset', 0))
-            is_interleaved = len(accs) > 1 and accs[1].get('byteOffset', 0) < buffview['byteStride']
+            accs = sorted(accs_unsorted, key=lambda x: x.get('byteOffset', 0))
+            is_interleaved = (
+                len(accs) > 1 
+                and accs[1].get('byteOffset', 0) < buffview['byteStride']
+            )
 
             varray = GeomVertexArrayFormat()
             for acc in accs:
@@ -1585,18 +1584,18 @@ def calculate_frame_value(frame, path):
 
             if interpolation_mode == 'STEP':
                 return output_buff[lastidx]
-            elif interpolation_mode == 'LINEAR':
+
+            if interpolation_mode == 'LINEAR':
                 nexttime = input_buff[nextidx]
                 lasttime = input_buff[lastidx]
                 lerpfactor = get_lerp_factor(currtime, lasttime, nexttime)
 
                 if path == 'rotation':
                     return slerp(output_buff[lastidx], output_buff[nextidx], lerpfactor)
                 return vlerp(output_buff[lastidx], output_buff[nextidx], lerpfactor)
-            else:
-                return RuntimeError(
-                    f'Unrecognized interpolation mode ({interpolation_mode}) found on {bone_name}:{path}'
-                )
+            raise RuntimeError(
+                f'Unrecognized interpolation mode ({interpolation_mode}) found on {bone_name}:{path}'
+            )
 
         for i in range(num_frames):
             frame_translation = calculate_frame_value(i, 'translation')
@@ -1709,7 +1708,7 @@ def create_channels(parent, nodeid, target_names, default_weights):
                                 + target_weights[nextidx] * lerpfactor
                             )
                         else:
-                            return RuntimeError(
+                            raise RuntimeError(
                                 f'Unrecognized interpolation mode ({interpolation_mode}) found on {target_name}'
                             )
 
@@ -1866,8 +1865,9 @@ def load_physics_bullet(self, node_name, geomnode, shape_type, bounding_box, rad
                 mass = 1.0 if gltf_rigidbody is None else gltf_rigidbody.get('mass', 1.0)
                 phynode.set_mass(mass)
             return phynode
-        else:
-            print(f"Could not create collision shape for object ({node_name})")
+
+        print(f"Could not create collision shape for object ({node_name})")
+        return None
 
     def load_physics_builtin(self, node_name, geomnode, shape_type, bounding_box, radius, height, intangible):
         phynode = CollisionNode(node_name)
@@ -1975,5 +1975,6 @@ def load_physics_builtin(self, node_name, geomnode, shape_type, bounding_box, ra
 
         if phynode.solids:
             return phynode
-        else:
-            print(f"Could not create collision shape for object ({node_name})")
+
+        print(f"Could not create collision shape for object ({node_name})")
+        return None

gltf/_loader.py

@@ -16,9 +16,9 @@ def load_model(file_path, gltf_settings=None):
 
 def _config_var_for_type(var_type):
     return {
-        'str': p3d.ConfigVariableString,
-        'bool': p3d.ConfigVariableBool,
-        'int': p3d.ConfigVariableInt,
+        str: p3d.ConfigVariableString,
+        bool: p3d.ConfigVariableBool,
+        int: p3d.ConfigVariableInt,
     }.get(var_type, None)
 
 

gltf/parseutils.py

@@ -6,8 +6,7 @@ def is_glb_file(filepath):
     with open(filepath, 'rb') as glbfile:
         if glbfile.read(4) == b'glTF':
             return True
-        else:
-            return False
+        return False
 
 
 def parse_glb_data(data):

pyproject.toml

@@ -24,13 +24,17 @@ dependencies = [
     "panda3d >= 1.10.8",
     "panda3d-simplepbr >= 0.6",
 ]
-requires-python = ">= 3.8"
+requires-python = ">= 3.9"
 
 [project.urls]
 homepage = "https://github.com/Moguri/panda3d-gltf"
 
-[project.optional-dependencies]
-test = ["pytest", "pylint~=3.1.0", "pytest-pylint"]
+[dependency-groups]
+dev = [
+    "pytest",
+    "ruff>=0.12.9",
+    "pytest-ruff",
+]
 
 [project.scripts]
 gltf2bam = "gltf.cli:main"
@@ -48,5 +52,48 @@ packages = ["gltf"]
 [tool.setuptools.dynamic]
 version = {attr = "gltf.version.__version__"}
 
+[tool.ruff.lint]
+extend-select = [
+    #"ALL",
+    "E",
+    "F",
+    "YTT",
+    "ASYNC",
+    "BLE",
+    "B",
+    "A",
+    "C4",
+    "PIE",
+    "PT",
+    "RSE",
+    "RET",
+    "SLF",
+    "SLOT",
+    "N",
+    "PERF",
+    "PLC",
+    "PLE",
+    "PLW",
+    "UP",
+    "FURB",
+    # Try to enable these later
+    #"S",
+    #"I",
+    #"COM",
+    #"PTH",
+    #"TRY",
+    #"SIM",
+    #"FBT",
+    #"RUF",
+]
+ignore = [
+    "E501",  # Line too long
+    "E731",  # Do not assign a lambda expression, use a def
+    # Fix these
+    "F403",  # 'from module import *' used; unable to detect undefined names
+    "F405",  # Name may be undefined, or defined from star imports: *
+    "PLW2901", # loop variable overwritten by assignment target
+]
+
 [tool.pytest.ini_options]
-addopts = "--pylint"
+addopts = "--ruff"