fix: resolve all CI/CD issues

- Fix generate_json_report to return JSON content instead of filename
- Fix line length issues (max 88 chars) in multiple files
- Fix black formatting issues in code_generator.py, reporter.py, optimizer.py
- Update docstrings to be more concise
- All CI checks now passing (black, isort, flake8, mypy, tests)

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: SkySingh04

benchmarker.py

@@ -87,7 +87,9 @@ def benchmark_latency(
         return 0.0, None
 
     try:  # Load interpreter
-        interpreter = _tf.lite.Interpreter(model_path=model_path)  # type: ignore[attr-defined]
+        interpreter = _tf.lite.Interpreter(  # type: ignore[attr-defined]
+            model_path=model_path
+        )
         interpreter.allocate_tensors()
         input_details = interpreter.get_input_details()
         if not input_details:

code_generator.py

@@ -205,7 +205,9 @@ def _generate_python_class(self) -> str:
         code += '        """Initialize the inference engine."""\n'
         code += f'        self.model_path = model_path or "{model_path}"\n'
         code += f"        self.buffer_size = {buffer_size}\n"
-        code += f"        self.memory_limit = {memory_limit} * 1024 * 1024  # Convert MB to bytes\n"
+        code += (
+            f"        self.memory_limit = {memory_limit} * 1024 * 1024\n"  # MB to bytes
+        )
         code += f'        self.optimize_for = "{optimize_for}"\n'
         code += "        self.interpreter = None\n"
         code += "        self.input_details = None\n"
@@ -301,7 +303,10 @@ def _generate_python_input_processing(self) -> str:
             code += "            # Load image from file\n"
             code += "            image = cv2.imread(input_data)\n"
             code += "            if image is None:\n"
-            code += '                raise ValueError(f"Could not load image: {input_data}")\n'
+            code += (
+                "                raise ValueError("
+                'f"Could not load image: {input_data}")\n'
+            )
             code += "        else:\n"
             code += "            image = input_data\n"
             code += "        \n"
@@ -426,7 +431,10 @@ def _generate_python_main(self) -> str:
         code += (
             '    parser = argparse.ArgumentParser(description="EdgeFlow Inference")\n'
         )
-        code += '    parser.add_argument("--input", required=True, help="Input data path")\n'
+        code += (
+            '    parser.add_argument("--input", required=True, '
+            'help="Input data path")\n'
+        )
         code += '    parser.add_argument("--model", help="Model path override")\n'
         code += (
             '    parser.add_argument("--benchmark", action="store_true", '
@@ -474,7 +482,8 @@ def _generate_cpp_code(self) -> str:
         code += "    std::unique_ptr<tflite::Interpreter> interpreter_;\n"
         code += "    std::unique_ptr<tflite::FlatBufferModel> model_;\n"
         code += f'    int buffer_size_ = {self.config.get("buffer_size", 32)};\n'
-        code += f'    int memory_limit_ = {self.config.get("memory_limit", 64)} * 1024 * 1024;\n'
+        mem_limit = self.config.get("memory_limit", 64)
+        code += f"    int memory_limit_ = {mem_limit} * 1024 * 1024;\n"
         code += "    \n"
         code += "public:\n"
         code += "    EdgeFlowInference(const std::string& model_path);\n"

edgeflow_ast.py

@@ -142,7 +142,7 @@ def accept(self, visitor: "ASTVisitor") -> Any:
 
 @dataclass
 class PipelineStatement(Statement):
-    """Represents a pipeline statement: pipeline: { preprocess, inference, postprocess }"""
+    """Pipeline statement: pipeline: { preprocess, inference, postprocess }"""
 
     steps: List[str]
 

optimizer.py

@@ -115,7 +115,7 @@ def optimize_model(self, config: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
         try:
             created_baseline = False
 
-            # If we have a Keras source OR the baseline .tflite is missing, (re)create baseline
+            # If we have Keras source OR baseline is missing, recreate
             if keras_source and (
                 not os.path.exists(model_path)
                 or keras_source.endswith((".h5", ".keras"))
@@ -188,9 +188,7 @@ def optimize_model(self, config: Dict[str, Any]) -> Tuple[str, Dict[str, Any]]:
                 if os.path.isdir(model_path):
                     converter = tf.lite.TFLiteConverter.from_saved_model(model_path)
                 else:
-                    logger.warning(
-                        "Cannot perform quantization without a valid source graph; falling back"
-                    )
+                    logger.warning("Cannot quantize without valid source; falling back")
                     return self._fallback_optimization(config)
 
             # Apply quantization strategy

reporter.py

@@ -134,9 +134,7 @@ def generate_recommendations(improvements: Dict[str, float]) -> str:
     speedup = improvements.get("speedup", 0.0)
 
     if size_red >= 70:
-        recs.append(
-            "- Excellent size reduction achieved! Model is now highly suitable for edge deployment"
-        )
+        recs.append("- Excellent size reduction! Model highly suitable for edge")
     elif size_red >= 50:
         recs.append(
             "- Good size reduction achieved; consider further quantization or pruning"
@@ -209,7 +207,7 @@ def generate_report(
 
 ✨ **Model successfully optimized using EdgeFlow DSL** ✨
 
-The EdgeFlow compiler has successfully optimized your model with the following impressive results:
+EdgeFlow successfully optimized your model with these results:
 
 - **Size Reduction**: {improvements['size_reduction']:.1f}%
 - **Speed Improvement**: {improvements['speedup']:.1f}x faster
@@ -228,7 +226,7 @@ def generate_report(
 | **Model Size** | {unoptimized_stats['size_mb']:.2f} MB | \
         {optimized_stats['size_mb']:.2f} MB | ↓ {improvements['size_reduction']:.1f}% |
 | **Inference Latency** | {unoptimized_stats['latency_ms']:.2f} ms | \
-        {optimized_stats['latency_ms']:.2f} ms | ↓ {improvements['latency_reduction']:.1f}% |
+{optimized_stats['latency_ms']:.2f} ms | ↓ {improvements['latency_reduction']:.1f}% |
 | **Throughput** | {1000/float(unoptimized_stats['latency_ms']):.1f} fps | \
         {1000/float(optimized_stats['latency_ms']):.1f} fps | \
         ↑ {improvements['throughput_increase']:.1f}% |
@@ -244,7 +242,8 @@ def generate_report(
 ### Technique Applied
 - **Quantization**: INT8 quantization applied
 - **Target Device**: {config.get('target_device', 'Generic') if config else 'Generic'}
-- **Optimization Goal**: {config.get('optimize_for', 'Balanced') if config else 'Balanced'}
+- **Optimization Goal**: \
+{config.get('optimize_for', 'Balanced') if config else 'Balanced'}
 
 ### Benefits Achieved
 1. **Reduced Storage Requirements**: Your model now requires \
@@ -283,7 +282,11 @@ def generate_json_report(
     config: Optional[Dict[str, Any]] = None,
     output_path: str = "report.json",
 ) -> str:
-    """Generate machine-readable JSON report for API consumption."""
+    """Generate machine-readable JSON report for API consumption.
+
+    Returns:
+        JSON string containing the report data
+    """
     # Validate minimal fields
     required_fields = ["size_mb", "latency_ms"]
     for field in required_fields:
@@ -299,7 +302,12 @@ def generate_json_report(
         "timestamp": datetime.now().isoformat(),
     }
 
-    output = Path(output_path)
-    output.write_text(json.dumps(payload, indent=2))
-    logger.info("JSON report successfully generated: %s", output)
-    return str(output)
+    json_content = json.dumps(payload, indent=2)
+
+    # Optionally write to file if output_path is provided
+    if output_path:
+        output = Path(output_path)
+        output.write_text(json_content)
+        logger.info("JSON report successfully generated: %s", output)
+
+    return json_content

tests/test_reporter_integration.py

@@ -27,7 +27,7 @@ def test_cli_integration(self):
                 text=True,
             )
 
-            # Basic sanity: process should exit (0 or non-zero tolerated in CI simulation)
+            # Process should exit (0 or non-zero tolerated in CI)
             assert result.returncode in (0, 1, 2)
 
             # Check that report was generated