sync: 159 file da Baida98/AI@a6de7873 (2026-08-16 07:48 UTC) [deploy-all] (#42)

- sync: 159 file da Baida98/AI@a6de7873 (2026-08-16 07:48 UTC) [deploy-all] (b05c64a6c34d62e5e6a2db6133d442399495931f)

.env.example

@@ -47,6 +47,9 @@ RAILWAY_PROJECT_ID_E=YOUR_RAILWAY_PROJECT_ID_E
 # Configurare nei Secrets del provider hosting (HF/Railway)
 GROQ_API_KEY=
 OPENROUTER_API_KEY=
+# Pool opzionale: JSON senza loggare le chiavi. Ogni profilo deve avere profile e api_key.
+# Esempio: OPENROUTER_PROFILES_JSON=[{"profile":"primary","api_key":"..."},{"profile":"backup","api_key":"..."}]
+OPENROUTER_PROFILES_JSON=
 GEMINI_API_KEY=
 NVIDIA_API_KEY=
 

api/state.py

@@ -119,6 +119,9 @@ SENSITIVE = {
     'VAULT_KEY', 'INTERNAL_TOKEN', 'DEPLOY_SECRET', 'WEBHOOK_TOKEN',
     'TERMINAL_SECRET', 'EXEC_TOKEN', 'VITE_INTERNAL_TOKEN', 'VITE_TERMINAL_SECRET',
     'VITE_OPENROUTER_API_KEY', 'VITE_HF_TOKEN', 'VITE_GROQ_API_KEY',
+    'OPENROUTER_PROFILES_JSON', 'GROQ_PROFILES_JSON', 'CEREBRAS_PROFILES_JSON',
+    'SAMBANOVA_PROFILES_JSON', 'GEMINI_PROFILES_JSON', 'NVIDIA_PROFILES_JSON',
+    'HF_ROUTER_PROFILES_JSON',
     'GH_PAGES_TOKEN', 'VERCEL_TOKEN',
 }
 

main.py

@@ -57,6 +57,9 @@ async def _run_auto_migration():
         'VAULT_KEY', 'INTERNAL_TOKEN', 'DEPLOY_SECRET', 'WEBHOOK_TOKEN',
         'TERMINAL_SECRET', 'EXEC_TOKEN', 'VITE_INTERNAL_TOKEN', 'VITE_TERMINAL_SECRET',
         'VITE_OPENROUTER_API_KEY', 'VITE_HF_TOKEN', 'VITE_GROQ_API_KEY',
+        'OPENROUTER_PROFILES_JSON', 'GROQ_PROFILES_JSON', 'CEREBRAS_PROFILES_JSON',
+        'SAMBANOVA_PROFILES_JSON', 'GEMINI_PROFILES_JSON', 'NVIDIA_PROFILES_JSON',
+        'HF_ROUTER_PROFILES_JSON',
         'GH_PAGES_TOKEN', 'VERCEL_TOKEN'
     ]
     

models/ai_client.py

@@ -14,6 +14,7 @@ sempre vuoto in produzione (ogni chiamata falliva silenziosamente con
 from __future__ import annotations
 
 import asyncio
+import json
 import os
 import time as _time_mod
 from dataclasses import dataclass
@@ -49,6 +50,11 @@ class ProviderConfig:
     purpose: str = "reasoning"
     profile: str = "general"
 
+    @property
+    def identity(self) -> tuple[str, str, str]:
+        """Stable identity: different profiles must never share a client cache entry."""
+        return (self.name, self.profile, self.base_url)
+
 # Definizione statica dei provider LLM realmente attivi nel progetto.
 # base_url punta sempre all'endpoint OpenAI-compatible ufficiale del provider
 # (nessun proxy CF Worker qui: questo client gira lato backend Python, non browser).
@@ -69,9 +75,12 @@ _PROVIDER_DEFS = [
 class AIClient:
     def __init__(self) -> None:
         self.providers = self._load_providers()
-        self._client_cache: dict[str, OpenAI] = {}
-        # S-DUAL-10: Indice per round-robin tra provider dello stesso purpose
+        self._client_cache: dict[tuple[str, str, str], OpenAI] = {}
+        # Round-robin e circuit breaker sono indicizzati per purpose e profilo.
         self._rr_indices: dict[str, int] = {}
+        self._breaker: dict[tuple[str, str, str], dict[str, float | int]] = {}
+        self._breaker_threshold = 2
+        self._breaker_cooldown_s = 60.0
 
     def _load_providers(self) -> list[ProviderConfig]:
         """Carica la flotta: prova Supabase (tabella `ai_providers`, source of
@@ -113,6 +122,41 @@ class AIClient:
             ))
         )
 
+    @staticmethod
+    def _profile_rows_from_env(definition: dict) -> list[ProviderConfig]:
+        """Load optional per-provider profiles without logging secret values.
+
+        Format: ``<PROVIDER>_PROFILES_JSON=[{"profile":"p1","api_key":"...", "model":"..."}]``.
+        The legacy single-key variable remains supported and is loaded after profiles.
+        """
+        env_name = f"{definition['name'].upper()}_PROFILES_JSON"
+        raw = os.getenv(env_name, "").strip()
+        if not raw:
+            return []
+        try:
+            rows = json.loads(raw)
+        except json.JSONDecodeError:
+            _logger.warning("AIClient: %s non valido, profili ignorati", env_name)
+            return []
+        if not isinstance(rows, list):
+            _logger.warning("AIClient: %s deve essere un array JSON", env_name)
+            return []
+        result: list[ProviderConfig] = []
+        for index, row in enumerate(rows):
+            if not isinstance(row, dict) or not row.get("api_key"):
+                continue
+            result.append(ProviderConfig(
+                id=-(index + 1),
+                name=definition["name"],
+                api_key=str(row["api_key"]),
+                base_url=str(row.get("base_url") or definition["base_url"]),
+                default_model=str(row.get("model") or os.getenv(definition["model_env"], definition["default_model"])),
+                tier=definition["tier"],
+                purpose=str(row.get("purpose") or definition["purpose"]),
+                profile=str(row.get("profile") or f"profile-{index + 1}"),
+            ))
+        return result
+
     def _try_load_from_supabase(self) -> list[ProviderConfig]:
         url = os.getenv("SUPABASE_URL", "")
         key = os.getenv("SUPABASE_SERVICE_ROLE_KEY", "")
@@ -142,7 +186,10 @@ class AIClient:
                 ProviderConfig(
                     id=row["id"], name=row["name"], api_key=row["api_key"],
                     base_url=row["base_url"], default_model=self._runtime_model_override(row),
-                    tier=row["tier"], purpose=row["purpose"], profile="general",
+                    tier=row["tier"], purpose=row["purpose"],
+                    # Legacy schema has no profile column: the row id is still a
+                    # stable profile identity and prevents client-cache collisions.
+                    profile=f"db-{row['id']}",
                 )
                 for row in rows
             ]
@@ -156,6 +203,7 @@ class AIClient:
         è impostata — nessun placeholder, nessun nodo fantasma."""
         providers = []
         for i, d in enumerate(_PROVIDER_DEFS):
+            providers.extend(self._profile_rows_from_env(d))
             api_key = os.getenv(d["env_key"], "")
             if not api_key:
                 continue
@@ -167,23 +215,61 @@ class AIClient:
                 default_model=os.getenv(d["model_env"], d["default_model"]),
                 tier=d["tier"],
                 purpose=d["purpose"],
-                profile="general",
+                profile="legacy",
             ))
         if not providers:
             _logger.error("AIClient: nessuna API key provider configurata (Groq/OpenRouter/Cerebras/SambaNova/Gemini/NVIDIA/HF_TOKEN tutte assenti)")
         return providers
 
     def _client_for(self, provider: ProviderConfig) -> OpenAI:
-        if provider.name not in self._client_cache:
-            self._client_cache[provider.name] = OpenAI(
-                api_key=provider.api_key, 
-                base_url=provider.base_url, 
+        if provider.identity not in self._client_cache:
+            self._client_cache[provider.identity] = OpenAI(
+                api_key=provider.api_key,
+                base_url=provider.base_url,
                 # I task coding possono richiedere più di 20 s prima del primo
                 # chunk dal fallback gratuito; il budget esterno resta finito.
                 timeout=45,
                 max_retries=0
             )
-        return self._client_cache[provider.name]
+        return self._client_cache[provider.identity]
+
+    def _is_available(self, provider: ProviderConfig) -> bool:
+        state = self._breaker.get(provider.identity)
+        return not state or float(state.get("open_until", 0.0)) <= _time_mod.monotonic()
+
+    def _record_success(self, provider: ProviderConfig) -> None:
+        self._breaker.pop(provider.identity, None)
+
+    def _record_failure(self, provider: ProviderConfig, exc: Exception) -> None:
+        message = str(exc).lower()
+        if not any(token in message for token in ("401", "403", "429", "500", "502", "503", "504", "rate limit", "quota")):
+            return
+        state = self._breaker.setdefault(provider.identity, {"failures": 0, "open_until": 0.0})
+        failures = int(state.get("failures", 0)) + 1
+        severe = any(token in message for token in ("401", "403"))
+        threshold = 1 if severe else self._breaker_threshold
+        if failures >= threshold:
+            cooldown = 900.0 if severe else (120.0 if any(token in message for token in ("429", "rate limit", "quota")) else self._breaker_cooldown_s)
+            state["open_until"] = _time_mod.monotonic() + cooldown
+        state["failures"] = failures
+
+    def _execution_pool(self, providers: list[ProviderConfig], purpose: str) -> list[ProviderConfig]:
+        """Return one rotated, healthy profile per provider endpoint group."""
+        groups: dict[tuple[str, str], list[ProviderConfig]] = {}
+        for provider in providers:
+            if not self._is_available(provider):
+                continue
+            groups.setdefault((provider.name, provider.base_url), []).append(provider)
+        selected: list[ProviderConfig] = []
+        for group_key, profiles in groups.items():
+            index_key = f"{purpose}:{group_key[0]}:{group_key[1]}"
+            start = self._rr_indices.get(index_key, 0)
+            selected.append(profiles[start % len(profiles)])
+            self._rr_indices[index_key] = start + 1
+        if selected:
+            return selected
+        # All profiles are quarantined: probe the earliest-to-recover profile only.
+        return [min(providers, key=lambda p: self._breaker.get(p.identity, {}).get("open_until", 0.0))] if providers else []
 
     async def _fetch_one(self, provider: ProviderConfig, messages: list, temperature: float, max_tokens: int) -> Tuple[ProviderConfig, str, float]:
         client = self._client_for(provider)
@@ -202,9 +288,11 @@ class AIClient:
                 # più tempo per produrre una risposta completa dopo uno stream interrotto.
                 timeout=45
             )
+            self._record_success(provider)
             return provider, response.choices[0].message.content or "", _time_mod.monotonic() - start
         except Exception as e:
-            _logger.warning(f"Provider {provider.name} fallito: {e}")
+            self._record_failure(provider, e)
+            _logger.warning(f"Provider {provider.name}/{provider.profile} fallito: {e}")
             return provider, f"ERROR: {str(e)}", 0.0
 
     def _get_round_robin_provider(self, purpose: str) -> Optional[ProviderConfig]:
@@ -249,7 +337,10 @@ class AIClient:
         if not pool:
             raise ProviderUnavailableError([])
         
-        # 3. Esecuzione parallela (Ensemble Intelligence)
+        # 3. Un solo profilo per endpoint e richiesta: round-robin evita che
+        # profili OpenRouter condividano quota e client, mentre provider diversi
+        # restano disponibili come ensemble/fallback.
+        pool = self._execution_pool(pool, primary_purpose)
         tasks = [self._fetch_one(p, messages, temperature, max_tokens) for p in pool]
         results = await asyncio.gather(*tasks)
         
@@ -302,7 +393,8 @@ class AIClient:
         except Exception as exc:
             _logger.debug("Streaming fleet expansion skipped: %s", type(exc).__name__)
 
-        # Nello streaming proviamo il primario di ruolo, poi i fallback runtime.
+        # Nello streaming proviamo un profilo ruotato per endpoint, poi i fallback runtime.
+        providers = self._execution_pool(providers, "stream")
         for provider in providers:
             client = self._client_for(provider)
             try:
@@ -320,9 +412,11 @@ class AIClient:
                     if chunk is None: break
                     if chunk.choices and chunk.choices[0].delta.content:
                         yield chunk.choices[0].delta.content
+                self._record_success(provider)
                 return
             except Exception as e:
-                _logger.warning(f"Streaming fallito su {provider.name}: {e}")
+                self._record_failure(provider, e)
+                _logger.warning(f"Streaming fallito su {provider.name}/{provider.profile}: {e}")
                 continue
         
         raise ProviderUnavailableError([provider.name for provider in providers])

models/role_router.py

@@ -83,11 +83,37 @@ class RoleRouter:
 
     # ── Role-specific builders ─────────────────────────────────────────────────
 
+    @staticmethod
+    def _prioritize_profile_pool(client: Any, provider_name: str) -> Any:
+        """Promote all configured profiles for one provider without collapsing them."""
+        profiles = [p for p in client.providers if p.name == provider_name]
+        if not profiles:
+            return None
+        client.providers = profiles + [p for p in client.providers if p.name != provider_name]
+        client.provider_name = profiles[0].name
+        client.default_model = profiles[0].default_model
+        client.client = client._client_for(profiles[0])
+        return client
+
+    @staticmethod
+    def _profiled_client(client: Any, provider_names: tuple[str, ...]) -> Any:
+        for provider_name in provider_names:
+            env_name = f"{provider_name.upper()}_PROFILES_JSON"
+            if os.getenv(env_name):
+                profiled = RoleRouter._prioritize_profile_pool(client, provider_name)
+                if profiled:
+                    return profiled
+        return None
+
     @staticmethod
     def _fast_client() -> Any:
         """Groq GPT-OSS 20B per query brevi e a bassa latenza.
         Usato per: greetings, calcoli semplici, identity, domande 1-liner."""
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("groq",))
+        if profiled:
+            return profiled
         groq_key = os.getenv("GROQ_API_KEY")
         if not groq_key:
             return RoleRouter._tester_client()
@@ -110,6 +136,10 @@ class RoleRouter:
         """NVIDIA NIM come primario per architettura.
         Fallback 1: Groq GPT-OSS 120B. Fallback 2: OpenRouter GPT-OSS 20B gratuito."""
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("nvidia", "groq", "openrouter"))
+        if profiled:
+            return profiled
         nvidia_key = os.getenv("NVIDIA_API_KEY")
         if nvidia_key:
             client = AIClient()
@@ -141,21 +171,22 @@ class RoleRouter:
             client.default_model = architect.default_model
             client.client = client._client_for(architect)
             return client
-        # Fallback: OpenRouter GPT-OSS 20B gratuito, con ID verificato nel catalogo.
-        openrouter_key = os.getenv("OPENROUTER_API_KEY")
-        if openrouter_key:
+        # Fallback OpenRouter: usa il pool multi-profilo, se configurato.
+        if os.getenv("OPENROUTER_API_KEY") or os.getenv("OPENROUTER_PROFILES_JSON"):
             client = AIClient()
-            fallback = ProviderConfig(
-                name="openrouter-architect",
-                api_key=openrouter_key,
-                base_url="https://openrouter.ai/api/v1",
-                default_model=os.getenv("OPENROUTER_MODEL", "openai/gpt-oss-20b:free"),
-            )
-            rest = [p for p in client.providers if not p.name.startswith("openrouter")]
-            client.providers = [fallback, *rest]
-            client.provider_name = fallback.name
-            client.default_model = fallback.default_model
-            client.client = client._client_for(fallback)
+            profiles = [p for p in client.providers if p.name == "openrouter"]
+            if not profiles and os.getenv("OPENROUTER_API_KEY"):
+                profiles = [ProviderConfig(
+                    name="openrouter", api_key=os.getenv("OPENROUTER_API_KEY", ""),
+                    base_url="https://openrouter.ai/api/v1",
+                    default_model=os.getenv("OPENROUTER_MODEL", "openai/gpt-oss-20b:free"),
+                    profile="legacy",
+                )]
+            if profiles:
+                client.providers = profiles + [p for p in client.providers if p.name != "openrouter"]
+                client.provider_name = profiles[0].name
+                client.default_model = profiles[0].default_model
+                client.client = client._client_for(profiles[0])
             return client
         return AIClient()
 
@@ -164,6 +195,10 @@ class RoleRouter:
         """Groq GPT-OSS 120B per coding e debug.
         Fallback: provider ordinari del router se GROQ_API_KEY manca."""
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("groq", "nvidia", "openrouter"))
+        if profiled:
+            return profiled
         groq_key = os.getenv("GROQ_API_KEY")
         nvidia_key = os.getenv("NVIDIA_API_KEY")
         model = os.getenv("CODER_MODEL", "openai/gpt-oss-120b")
@@ -198,21 +233,22 @@ class RoleRouter:
             client.default_model = coder.default_model
             client.client = client._client_for(coder)
             return client
-        openrouter_key = os.getenv("OPENROUTER_API_KEY")
-        if openrouter_key:
+        # Fallback OpenRouter: usa il pool multi-profilo, se configurato.
+        if os.getenv("OPENROUTER_API_KEY") or os.getenv("OPENROUTER_PROFILES_JSON"):
             client = AIClient()
-            fallback = ProviderConfig(
-                name="openrouter-coder",
-                api_key=openrouter_key,
-                base_url="https://openrouter.ai/api/v1",
-                default_model=os.getenv("OPENROUTER_MODEL", "openai/gpt-oss-20b:free"),
-                purpose="coding",
-            )
-            rest = [p for p in client.providers if not p.name.startswith("openrouter")]
-            client.providers = [fallback, *rest]
-            client.provider_name = fallback.name
-            client.default_model = fallback.default_model
-            client.client = client._client_for(fallback)
+            profiles = [p for p in client.providers if p.name == "openrouter"]
+            if not profiles and os.getenv("OPENROUTER_API_KEY"):
+                profiles = [ProviderConfig(
+                    name="openrouter", api_key=os.getenv("OPENROUTER_API_KEY", ""),
+                    base_url="https://openrouter.ai/api/v1",
+                    default_model=os.getenv("OPENROUTER_MODEL", "openai/gpt-oss-20b:free"),
+                    profile="legacy",
+                )]
+            if profiles:
+                client.providers = profiles + [p for p in client.providers if p.name != "openrouter"]
+                client.provider_name = profiles[0].name
+                client.default_model = profiles[0].default_model
+                client.client = client._client_for(profiles[0])
             return client
         return AIClient()
 
@@ -225,9 +261,12 @@ class RoleRouter:
         Groq è sano. L'ordine conserva tutti i provider ordinari dopo Groq.
         """
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("groq", "gemini", "openrouter"))
+        if profiled:
+            return profiled
         groq_key = os.getenv("GROQ_API_KEY")
         if groq_key:
-            client = AIClient()
             researcher = ProviderConfig(
                 name="groq-researcher",
                 api_key=groq_key,
@@ -256,9 +295,12 @@ class RoleRouter:
         risposte deterministiche a scelta multipla. Cerebras resta un fallback
         compatibile quando Groq non è configurato."""
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("groq", "cerebras", "gemini", "openrouter"))
+        if profiled:
+            return profiled
         groq_key = os.getenv("GROQ_API_KEY")
         if groq_key:
-            client = AIClient()
             reasoner = ProviderConfig(
                 name="groq-reasoner",
                 api_key=groq_key,
@@ -301,6 +343,10 @@ class RoleRouter:
         gemma-4-31B-it: 100% ma 2132ms. Meta-Llama: rate-limited. gpt-oss-120b: ERR.
         Fallback: _architect_client (Groq) se SAMBANOVA_API_KEY mancante."""
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("sambanova",))
+        if profiled:
+            return profiled
         sn_key = os.getenv("SAMBANOVA_API_KEY")
         if not sn_key:
             return RoleRouter._architect_client()
@@ -323,6 +369,10 @@ class RoleRouter:
         """NVIDIA NIM nemotron-3-ultra-550b-a55b — 550B params, 1M ctx, API OpenAI-compat.
         Fallback: _architect_client (Groq) se NVIDIA_API_KEY mancante."""
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("nvidia",))
+        if profiled:
+            return profiled
         nvidia_key = os.getenv("NVIDIA_API_KEY")
         if not nvidia_key:
             return RoleRouter._architect_client()
@@ -344,9 +394,13 @@ class RoleRouter:
     def _tester_client() -> Any:
         """Groq GPT-OSS 20B per test rapidi e debug hints."""
         from models.ai_client import AIClient, ProviderConfig
+        client = AIClient()
+        profiled = RoleRouter._profiled_client(client, ("groq",))
+        if profiled:
+            return profiled
         groq_key = os.getenv("GROQ_API_KEY")
         if not groq_key:
-            return AIClient()
+            return client
         client = AIClient()
         tester = ProviderConfig(
             name="groq-tester",

tests/test_provider_profile_pool.py

@@ -0,0 +1,63 @@
+import json
+import os
+import unittest
+from unittest.mock import patch
+
+from models.ai_client import AIClient, ProviderConfig, _PROVIDER_DEFS
+
+
+class ProviderProfilePoolTests(unittest.TestCase):
+    def _profiles(self):
+        return [
+            ProviderConfig(name="openrouter", api_key="test-key-a", base_url="https://openrouter.ai/api/v1", profile="a", purpose="coding"),
+            ProviderConfig(name="openrouter", api_key="test-key-b", base_url="https://openrouter.ai/api/v1", profile="b", purpose="coding"),
+            ProviderConfig(name="openrouter", api_key="test-key-c", base_url="https://openrouter.ai/api/v1", profile="c", purpose="coding"),
+        ]
+
+    def test_profile_json_loads_alongside_legacy_key(self):
+        raw = json.dumps([
+            {"profile": "primary", "api_key": "profile-key-1"},
+            {"profile": "backup", "api_key": "profile-key-2", "model": "openai/gpt-oss-20b:free"},
+        ])
+        with patch.dict(os.environ, {"OPENROUTER_PROFILES_JSON": raw, "OPENROUTER_API_KEY": "legacy-key"}, clear=True):
+            client = AIClient()
+        profiles = [p for p in client.providers if p.name == "openrouter"]
+        self.assertEqual([p.profile for p in profiles], ["primary", "backup", "legacy"])
+        self.assertEqual([p.api_key for p in profiles], ["profile-key-1", "profile-key-2", "legacy-key"])
+
+    def test_profile_json_is_supported_for_every_provider(self):
+        env = {
+            f"{definition['name'].upper()}_PROFILES_JSON": json.dumps([
+                {"profile": "primary", "api_key": f"{definition['name']}-key"},
+                {"profile": "backup", "api_key": f"{definition['name']}-backup"},
+            ])
+            for definition in _PROVIDER_DEFS
+        }
+        with patch.dict(os.environ, env, clear=True):
+            client = AIClient()
+        for definition in _PROVIDER_DEFS:
+            profiles = [p for p in client.providers if p.name == definition["name"]]
+            self.assertEqual([p.profile for p in profiles], ["primary", "backup"])
+
+    def test_profiles_have_distinct_client_cache_entries(self):
+        client = AIClient()
+        first, second = self._profiles()[:2]
+        first_client = client._client_for(first)
+        second_client = client._client_for(second)
+        self.assertIsNot(first_client, second_client)
+        self.assertEqual(len(client._client_cache), 2)
+
+    def test_round_robin_rotates_profiles_and_skips_open_circuit(self):
+        client = AIClient()
+        profiles = self._profiles()
+        self.assertEqual(client._execution_pool(profiles, "coding")[0].profile, "a")
+        self.assertEqual(client._execution_pool(profiles, "coding")[0].profile, "b")
+        client._record_failure(profiles[1], RuntimeError("HTTP 429 rate limit"))
+        client._record_failure(profiles[1], RuntimeError("HTTP 429 rate limit"))
+        self.assertFalse(client._is_available(profiles[1]))
+        selected = client._execution_pool(profiles, "coding")
+        self.assertNotEqual(selected[0].profile, "b")
+
+
+if __name__ == "__main__":
+    unittest.main()