Upload folder using huggingface_hub

analyzers/ds_analyzer.py

@@ -45,7 +45,7 @@ def analyze_data_science_code(code: str, parsed: Dict[str, Any], complexity: Dic
 
     return DomainAnalysis(
         domain="data_science",
-        domain_score=max(0.05, round(score, 4)),
+        domain_score=max(0.05, min(0.99, round(score, 4))),
         issues=issues,
         suggestions=suggestions,
         highlights={

analyzers/dsa_analyzer.py

@@ -37,7 +37,7 @@ def analyze_dsa_code(code: str, parsed: Dict[str, Any], complexity: Dict[str, An
 
     return DomainAnalysis(
         domain="dsa",
-        domain_score=max(0.05, round(score, 4)),
+        domain_score=max(0.05, min(0.99, round(score, 4))),
         issues=issues,
         suggestions=suggestions,
         highlights={

analyzers/ml_analyzer.py

@@ -49,7 +49,7 @@ def analyze_ml_code(code: str, parsed: Dict[str, Any], complexity: Dict[str, Any
 
     return DomainAnalysis(
         domain="ml_dl",
-        domain_score=max(0.05, round(score, 4)),
+        domain_score=max(0.05, min(0.99, round(score, 4))),
         issues=issues,
         suggestions=suggestions,
         highlights={

analyzers/web_analyzer.py

@@ -39,7 +39,7 @@ def analyze_web_code(code: str, parsed: Dict[str, Any], complexity: Dict[str, An
 
     return DomainAnalysis(
         domain="web",
-        domain_score=max(0.05, round(score, 4)),
+        domain_score=max(0.05, min(0.99, round(score, 4))),
         issues=issues,
         suggestions=suggestions,
         highlights={

models/pytorch_model.py

@@ -101,6 +101,10 @@ class PyTorchCodeAnalyzerModel:
             self.backend_name = self._fallback.backend_name
             self.notes = list(self._fallback.notes) + [f"Pretrained load failed: {type(exc).__name__}: {exc}"]
 
+    @staticmethod
+    def _clamp_score(value: float) -> float:
+        return round(max(0.01, min(0.99, float(value))), 4)
+
     def _embed_texts(self, texts: Sequence[str]) -> torch.Tensor:
         self._ensure_loaded()
         if self._model is None or self._tokenizer is None:
@@ -132,7 +136,7 @@ class PyTorchCodeAnalyzerModel:
         for domain, texts in DOMAIN_PROTOTYPES.items():
             matrix = self._prototype_matrix(f"domain:{domain}", texts)
             similarity = torch.matmul(candidate, matrix.T).max().item()
-            domain_scores[domain] = round((similarity + 1.0) / 2.0, 4)
+            domain_scores[domain] = self._clamp_score((similarity + 1.0) / 2.0)
 
         high_matrix = self._prototype_matrix("quality:high", QUALITY_ANCHORS["high"])
         low_matrix = self._prototype_matrix("quality:low", QUALITY_ANCHORS["low"])
@@ -142,7 +146,7 @@ class PyTorchCodeAnalyzerModel:
 
         return {
             "domain_scores": domain_scores,
-            "ml_quality_score": round(float(ml_quality_score), 4),
+            "ml_quality_score": self._clamp_score(float(ml_quality_score)),
             "backend_name": self.backend_name,
             "model_id": self.model_id,
             "notes": list(self.notes),

services/analysis_service.py

@@ -17,7 +17,7 @@ from utils import estimate_complexity, parse_code_structure
 def _lint_score(parsed: Dict[str, Any]) -> float:
     """Convert structural smells into a normalized lint-style score."""
 
-    score = 1.0
+    score = 0.99
     if not parsed.get("syntax_valid", True):
         score -= 0.45
     score -= min(parsed.get("long_lines", 0), 5) * 0.03
@@ -27,7 +27,7 @@ def _lint_score(parsed: Dict[str, Any]) -> float:
         score -= 0.05
     if parsed.get("docstring_ratio", 0.0) == 0.0 and parsed.get("function_names"):
         score -= 0.08
-    return round(max(0.0, min(1.0, score)), 4)
+    return round(max(0.01, min(0.99, score)), 4)
 
 
 class AnalysisService:
@@ -68,7 +68,7 @@ class AnalysisService:
             scores["ml_dl"] += 0.1
         if "while" in code or "for" in code:
             scores["dsa"] += 0.05
-        return {key: round(min(value, 0.99), 4) for key, value in scores.items()}
+        return {key: round(max(0.01, min(value, 0.99)), 4) for key, value in scores.items()}
 
     def analyze(self, request: AnalyzeCodeRequest) -> AnalyzeCodeResponse:
         """Run the complete multi-domain analysis pipeline."""

services/reward_service.py

@@ -8,6 +8,10 @@ from schemas.response import ScoreBreakdown
 class RewardService:
     """Compute reward scores from model, domain, lint, and complexity signals."""
 
+    @staticmethod
+    def _clamp_score(value: float) -> float:
+        return round(max(0.01, min(0.99, float(value))), 4)
+
     def compute(self, *, ml_score: float, domain_score: float, lint_score: float, complexity_penalty: float) -> ScoreBreakdown:
         """Apply dynamic reward shaping based on quality, errors, and completion."""
 
@@ -27,12 +31,12 @@ class RewardService:
             ),
         )
         return ScoreBreakdown(
-            ml_score=round(ml_score, 4),
-            domain_score=round(domain_score, 4),
-            lint_score=round(lint_score, 4),
-            complexity_penalty=round(complexity_penalty, 4),
-            quality_signal=round(quality_signal, 4),
-            error_reduction_signal=round(error_reduction_signal, 4),
-            completion_signal=round(completion_signal, 4),
-            reward=round(reward, 4),
+            ml_score=self._clamp_score(ml_score),
+            domain_score=self._clamp_score(domain_score),
+            lint_score=self._clamp_score(lint_score),
+            complexity_penalty=self._clamp_score(complexity_penalty),
+            quality_signal=self._clamp_score(quality_signal),
+            error_reduction_signal=self._clamp_score(error_reduction_signal),
+            completion_signal=self._clamp_score(completion_signal),
+            reward=self._clamp_score(reward),
         )

triage.py

@@ -182,7 +182,7 @@ def _repair_risk(label: IssueLabel, confidence: float, signal_count: int) -> str
 
 
 def _clamp_unit(value: float) -> float:
-    return round(max(0.0, min(1.0, float(value))), 4)
+    return round(max(0.01, min(0.99, float(value))), 4)
 
 
 def _lint_score(code: str) -> float:
@@ -190,7 +190,7 @@ def _lint_score(code: str) -> float:
     if not stripped_lines:
         return 0.2
 
-    score = 1.0
+    score = 0.99
     if any(len(line) > 88 for line in stripped_lines):
         score -= 0.15
     if any(line.rstrip() != line for line in stripped_lines):