Add GitHub workflow for Python formatting checks (#10)

Co-authored-by: Claude <noreply@anthropic.com>

Author: ykhrustalev

.github/workflows/check_python.yml

@@ -0,0 +1,37 @@
+name: Check Python
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  check:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/create-github-app-token@v2
+        id: app-token
+        with:
+          app-id: ${{ secrets.AUTH_APP_ID }}
+          private-key: ${{ secrets.AUTH_APP_SECRET_KEY }}
+          owner: ${{ github.repository_owner }}
+      - uses: actions/checkout@v5
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          persist-credentials: false
+          ref: ${{ github.event.inputs.branch }}
+          submodules: recursive
+          lfs: true
+          fetch-depth: 0
+
+      - uses: astral-sh/setup-uv@v4
+      - run: uv python install 3.12
+      - run: git config --global url."https://x-access-token:${{ steps.app-token.outputs.token }}@github.com/".insteadOf "ssh://git@github.com/"
+      - run: uv sync --extra dev
+      - run: uv run ruff format --check src tests
+      - run: uv run ruff check src tests

src/liquidonnx/builder_base.py

@@ -94,9 +94,7 @@ def add_initializer(self, name: str, tensor: np.ndarray, dtype=None):
             tensor = tensor.astype(dtype)
         self.initializers.append(numpy_helper.from_array(tensor, name))
 
-    def add_value_info(
-        self, name: str, elem_type: int, shape: list[int | str]
-    ) -> None:
+    def add_value_info(self, name: str, elem_type: int, shape: list[int | str]) -> None:
         """Add shape annotation for an intermediate tensor.
 
         Args:
@@ -218,7 +216,9 @@ def make_gelu(self, input_name: str, path: str, approximate: str = "tanh") -> st
         Returns:
             Output name "{path}/Gelu/output_0"
         """
-        return self.make_node("Gelu", [input_name], [self._output_name(path, "Gelu")], approximate=approximate)
+        return self.make_node(
+            "Gelu", [input_name], [self._output_name(path, "Gelu")], approximate=approximate
+        )
 
     def make_layernorm(
         self,
@@ -334,9 +334,7 @@ def make_linear(
 
         return matmul_out
 
-    def make_slice_last_n(
-        self, input_name: str, n_elements: str, path: str, axis: int = 2
-    ) -> str:
+    def make_slice_last_n(self, input_name: str, n_elements: str, path: str, axis: int = 2) -> str:
         """Slice last N elements along axis (dynamic N).
 
         Args:
@@ -349,7 +347,9 @@ def make_slice_last_n(
             Output name "{path}/Slice/output_0"
         """
         neg_n = self.make_mul(n_elements, self.get_constant(-1), self._output_name(path, "Mul"))
-        start = self.make_unsqueeze(neg_n, self.get_constant([0]), self._output_name(path, "Unsqueeze"))
+        start = self.make_unsqueeze(
+            neg_n, self.get_constant([0]), self._output_name(path, "Unsqueeze")
+        )
 
         return self.make_slice(
             input_name,

src/liquidonnx/external_data.py

@@ -24,10 +24,7 @@
 def _model_uses_external_data(model: onnx.ModelProto) -> bool:
     """Check if any tensor in the model uses external data."""
     for tensor in model.graph.initializer:
-        if (
-            tensor.HasField("data_location")
-            and tensor.data_location == onnx.TensorProto.EXTERNAL
-        ):
+        if tensor.HasField("data_location") and tensor.data_location == onnx.TensorProto.EXTERNAL:
             return True
     return False
 
@@ -143,8 +140,7 @@ def split_external_data(
     current_chunk_file.close()
     if current_chunk_size > 0:
         logger.info(
-            f"  Chunk {chunk_idx}: {current_chunk_path.name} "
-            f"({current_chunk_size / 1e9:.2f} GB)"
+            f"  Chunk {chunk_idx}: {current_chunk_path.name} ({current_chunk_size / 1e9:.2f} GB)"
         )
     else:
         # Remove empty file

src/liquidonnx/lfm2/builder.py

@@ -58,7 +58,9 @@ def from_hf_config(cls, config) -> "LFM2Config":
             if multiplier is not None:
                 intermediate_size = int(multiplier * intermediate_size)
                 multiple_of = getattr(config, "block_multiple_of", 256)
-                intermediate_size = multiple_of * ((intermediate_size + multiple_of - 1) // multiple_of)
+                intermediate_size = multiple_of * (
+                    (intermediate_size + multiple_of - 1) // multiple_of
+                )
 
         return cls(
             hidden_size=config.hidden_size,
@@ -83,7 +85,9 @@ class LFM2Builder(ONNXBuilderBase):
     - Fused Microsoft operators (SimplifiedLayerNormalization, RotaryEmbedding, GroupQueryAttention)
     """
 
-    def __init__(self, config: LFM2Config, use_integrated_rope: bool = False, vl_naming: bool = False):
+    def __init__(
+        self, config: LFM2Config, use_integrated_rope: bool = False, vl_naming: bool = False
+    ):
         """
         Args:
             config: Model configuration
@@ -819,7 +823,10 @@ def build_lm_head(self, hidden_state: str) -> str:
         self.add_initializer(final_norm_weight, self.weights["model.embedding_norm.weight"])
         # Community uses SkipLayerNorm as node name suffix
         normed = self.make_skip_layernorm(
-            hidden_state, hidden_state, final_norm_weight, final_norm_output,
+            hidden_state,
+            hidden_state,
+            final_norm_weight,
+            final_norm_output,
             name=f"/model/layers.{num_layers}/final_norm_layernorm/SkipLayerNorm",
         )
 
@@ -843,12 +850,10 @@ def build_value_info(self):
         the community model format.
         """
         H = self.config.hidden_size
-        nh = self.config.num_attention_heads
         nkv = self.config.num_key_value_heads
         hd = self.head_dim
         kv_hidden = nkv * hd
         intermediate = self.config.intermediate_size
-        L = self.config.conv_L_cache
         num_layers = self.config.num_hidden_layers
         mask_prefix = "/model/attn_mask_reformat/attn_mask_subgraph"
 
@@ -872,7 +877,9 @@ def build_value_info(self):
 
         # === Embedding output ===
         self.add_value_info(
-            "/model/embed_tokens/Gather/output_0", TensorProto.FLOAT, ["batch_size", "sequence_length", H]
+            "/model/embed_tokens/Gather/output_0",
+            TensorProto.FLOAT,
+            ["batch_size", "sequence_length", H],
         )
 
         # === Per-layer outputs ===
@@ -900,16 +907,24 @@ def build_value_info(self):
                     ["batch_size", 3 * H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Split/output_0", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Split/output_0",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Split/output_1", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Split/output_1",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Split/output_2", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Split/output_2",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Mul_1/output_0", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Mul_1/output_0",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
                     f"{prefix}/conv/Conv_Input/output_0",
@@ -921,11 +936,17 @@ def build_value_info(self):
                 conv_gather_name = "Gather_1" if self.vl_naming else "Gather_for_slice"
                 self.add_value_info(f"{prefix}/conv/split_sizes", TensorProto.INT64, [3])
                 self.add_value_info(f"{prefix}/conv/{shape_name}/output_0", TensorProto.INT64, [3])
-                self.add_value_info(f"{prefix}/conv/{conv_gather_name}/output_0", TensorProto.INT64, [])
+                self.add_value_info(
+                    f"{prefix}/conv/{conv_gather_name}/output_0", TensorProto.INT64, []
+                )
                 self.add_value_info(f"{prefix}/conv/Neg_Seq_Len/output_0", TensorProto.INT64, [])
-                self.add_value_info(f"{prefix}/conv/Unsqueeze_starts/output_0", TensorProto.INT64, [1])
                 self.add_value_info(
-                    f"{prefix}/conv/Mul_2/output_0", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Unsqueeze_starts/output_0", TensorProto.INT64, [1]
+                )
+                self.add_value_info(
+                    f"{prefix}/conv/Mul_2/output_0",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
                     f"{prefix}/conv/Transpose_2/output_0",
@@ -1062,7 +1083,9 @@ def build_value_info(self):
             TensorProto.FLOAT,
             ["batch_size", "sequence_length", H],
         )
-        self.add_value_info("/lm_head/Transpose/output_0", TensorProto.FLOAT, [H, self.config.vocab_size])
+        self.add_value_info(
+            "/lm_head/Transpose/output_0", TensorProto.FLOAT, [H, self.config.vocab_size]
+        )
 
     def load_weights(self, model_path: str):
         """Load weights from HuggingFace model."""

src/liquidonnx/lfm2_moe/builder.py

@@ -1354,7 +1354,9 @@ def build_lm_head(self, hidden_state: str) -> str:
         # Community naming: model.layers.{num_layers}.final_norm_layernorm.weight
         num_layers = self.config.num_hidden_layers
         final_norm_weight = f"model.layers.{num_layers}.final_norm_layernorm.weight"
-        final_norm_output = f"/model/layers.{num_layers}/final_norm_layernorm/SkipLayerNorm/output_0"
+        final_norm_output = (
+            f"/model/layers.{num_layers}/final_norm_layernorm/SkipLayerNorm/output_0"
+        )
 
         self.add_initializer(final_norm_weight, self.weights["model.embedding_norm.weight"])
         normed = self.make_skip_layernorm(
@@ -1480,15 +1482,11 @@ def build(self, model_path: str) -> onnx.ModelProto:
     def build_value_info(self):
         """Build ValueInfo entries for weights and intermediate tensors."""
         H = self.config.hidden_size
-        nh = self.config.num_attention_heads
         nkv = self.config.num_key_value_heads
         hd = self.head_dim
         kv_hidden = nkv * hd
         intermediate = self.config.intermediate_size
-        moe_intermediate = self.config.moe_intermediate_size
-        L = self.config.conv_L_cache
         num_layers = self.config.num_hidden_layers
-        num_experts = self.config.num_experts
         mask_prefix = "/model/attn_mask_reformat/attn_mask_subgraph"
 
         # === Weight shapes (from initializers) ===
@@ -1509,7 +1507,9 @@ def build_value_info(self):
 
         # === Embedding output ===
         self.add_value_info(
-            "/model/embed_tokens/Gather/output_0", TensorProto.FLOAT, ["batch_size", "sequence_length", H]
+            "/model/embed_tokens/Gather/output_0",
+            TensorProto.FLOAT,
+            ["batch_size", "sequence_length", H],
         )
 
         # === Per-layer outputs ===
@@ -1538,16 +1538,24 @@ def build_value_info(self):
                     ["batch_size", 3 * H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Split/output_0", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Split/output_0",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Split/output_1", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Split/output_1",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Split/output_2", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Split/output_2",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
-                    f"{prefix}/conv/Mul_1/output_0", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Mul_1/output_0",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
                     f"{prefix}/conv/Conv_Input/output_0",
@@ -1557,9 +1565,13 @@ def build_value_info(self):
                 self.add_value_info(f"{prefix}/conv/Shape/output_0", TensorProto.INT64, [3])
                 self.add_value_info(f"{prefix}/conv/Gather_1/output_0", TensorProto.INT64, [])
                 self.add_value_info(f"{prefix}/conv/Neg_Seq_Len/output_0", TensorProto.INT64, [])
-                self.add_value_info(f"{prefix}/conv/Unsqueeze_starts/output_0", TensorProto.INT64, [1])
                 self.add_value_info(
-                    f"{prefix}/conv/Mul_2/output_0", TensorProto.FLOAT, ["batch_size", H, "sequence_length"]
+                    f"{prefix}/conv/Unsqueeze_starts/output_0", TensorProto.INT64, [1]
+                )
+                self.add_value_info(
+                    f"{prefix}/conv/Mul_2/output_0",
+                    TensorProto.FLOAT,
+                    ["batch_size", H, "sequence_length"],
                 )
                 self.add_value_info(
                     f"{prefix}/conv/Transpose_2/output_0",

src/liquidonnx/lfm2_vl/builder/vision_builder.py

@@ -1179,9 +1179,7 @@ def build_encoder_layer(self, layer_idx: int, hidden_state: str) -> str:
         )
 
         # Community naming: Add_1 for attention residual
-        hidden_state = self.make_node(
-            "Add", [residual, out_proj], [f"{layer}/Add_1/output_0"]
-        )
+        hidden_state = self.make_node("Add", [residual, out_proj], [f"{layer}/Add_1/output_0"])
 
         residual2 = hidden_state
         normed2 = self.make_vision_layernorm(
@@ -1535,8 +1533,6 @@ def load_weights(self, weights: dict[str, np.ndarray]):
     def build_value_info(self):
         """Build ValueInfo entries for weights and intermediate tensors."""
         H = self.vision_hidden
-        nh = self.vision_config.num_attention_heads
-        hd = self.head_dim
         intermediate = self.vision_config.intermediate_size
         num_layers = self.vision_config.num_hidden_layers
         text_hidden = self.text_hidden
@@ -1704,5 +1700,7 @@ def build(self) -> onnx.ModelProto:
         self.build_value_info()
 
         model = self.build_graph("embed_images")
-        logger.info(f"Vision + projector model built: {len(self.nodes)} nodes, {len(self.value_info)} value_info")
+        logger.info(
+            f"Vision + projector model built: {len(self.nodes)} nodes, {len(self.value_info)} value_info"
+        )
         return model

tests/conftest.py

@@ -25,5 +25,3 @@ def pytest_addoption(parser):
 def exports_dir(request) -> pathlib.Path:
     base = pathlib.Path(request.config.getoption("--exports-dir"))
     return base / "exports"
-
-

tests/test_lfm2/test_community_benchmark.py

@@ -189,8 +189,12 @@ def test_benchmark_comparison(
         pytest.skip(f"Community ONNX not available on HF for {model_id} {precision or 'fp32'}")
 
     # Benchmark both
-    local_result = benchmark_model(local_onnx_file, tokenizer, f"local-{model_name}-{precision or 'fp32'}")
-    community_result = benchmark_model(community_onnx_file, tokenizer, f"community-{model_name}-{precision or 'fp32'}")
+    local_result = benchmark_model(
+        local_onnx_file, tokenizer, f"local-{model_name}-{precision or 'fp32'}"
+    )
+    community_result = benchmark_model(
+        community_onnx_file, tokenizer, f"community-{model_name}-{precision or 'fp32'}"
+    )
 
     # Log results
     logger.info(f"  Prefill: {PREFILL_TOKENS} tokens, Decode: {DECODE_TOKENS} tokens")