better lora

lora_utils.py

@@ -10,36 +10,38 @@ HF_TOKEN = os.environ.get("HF_TOKEN") or os.environ.get("hf")
 def _parse_hf_lora_url(url: str):
     parsed = urlparse(url)
     if "huggingface.co" not in parsed.netloc:
-        return None, None
+        return None, None, None
 
     path_parts = [part for part in parsed.path.split("/") if part]
     if len(path_parts) < 2:
-        return None, None
+        return None, None, None
 
     repo_id = f"{path_parts[0]}/{path_parts[1]}"
     weight_parts = path_parts[2:]
+    revision = None
     if len(weight_parts) >= 2 and weight_parts[0] in {"blob", "resolve"}:
+        revision = weight_parts[1]
         weight_parts = weight_parts[2:]
     weight_name = "/".join(weight_parts) if weight_parts else None
     if not weight_name or not weight_name.endswith(".safetensors"):
-        return repo_id, None
-    return repo_id, weight_name
+        return repo_id, None, revision
+    return repo_id, weight_name, revision
 
 
 def _split_lora_spec(spec: str):
     if not spec:
-        return None, None
+        return None, None, None
 
     spec = spec.strip()
     if not spec:
-        return None, None
+        return None, None, None
 
     if spec.startswith("http://") or spec.startswith("https://"):
         return _parse_hf_lora_url(spec)
     if ":" in spec:
         repo_id, weight_name = spec.split(":", 1)
-        return repo_id.strip(), weight_name.strip()
-    return spec, None
+        return repo_id.strip(), weight_name.strip(), None
+    return spec, None, None
 
 
 def _split_adapter_line_scale(line: str):
@@ -67,7 +69,7 @@ def parse_adapter_specs(spec_text: str, global_scale: float):
             continue
 
         spec, inline_scale = _split_adapter_line_scale(line)
-        repo_id, weight_name = _split_lora_spec(spec)
+        repo_id, weight_name, revision = _split_lora_spec(spec)
         if not repo_id or not weight_name:
             raise ValueError(
                 "Please provide LoRA entries as "
@@ -75,7 +77,7 @@ def parse_adapter_specs(spec_text: str, global_scale: float):
                 f"Invalid line {line_number}: {raw_line!r}"
             )
 
-        adapter_key = (repo_id, weight_name)
+        adapter_key = (repo_id, weight_name, revision)
         if adapter_key in seen_keys:
             raise ValueError(
                 f"Duplicate LoRA entry for '{repo_id}:{weight_name}' on line {line_number}."
@@ -87,6 +89,7 @@ def parse_adapter_specs(spec_text: str, global_scale: float):
                 "key": adapter_key,
                 "repo_id": repo_id,
                 "weight_name": weight_name,
+                "revision": revision,
                 "adapter_name": adapter_runtime_name(adapter_key),
                 "inline_scale": inline_scale,
                 "global_scale": global_scale,
@@ -98,20 +101,26 @@ def parse_adapter_specs(spec_text: str, global_scale: float):
 
 
 def adapter_runtime_name(adapter_key):
-    digest = hashlib.sha1(f"{adapter_key[0]}:{adapter_key[1]}".encode("utf-8")).hexdigest()[:12]
+    key_parts = [part for part in adapter_key if part is not None]
+    digest = hashlib.sha1(":".join(str(part) for part in key_parts).encode("utf-8")).hexdigest()[:12]
     return f"{ADAPTER_NAME_PREFIX}_{digest}"
 
 
-def _iter_adapter_hosts(pipe):
+def _iter_named_adapter_hosts(pipe):
     seen = set()
-    for host in (
-        pipe,
-        getattr(pipe, "transformer", None),
-        getattr(pipe, "unconditional_transformer", None),
+    for host_name, host in (
+        (None, pipe),
+        ("transformer", getattr(pipe, "transformer", None)),
+        ("unconditional_transformer", getattr(pipe, "unconditional_transformer", None)),
     ):
         if host is None or id(host) in seen:
             continue
         seen.add(id(host))
+        yield host_name, host
+
+
+def _iter_adapter_hosts(pipe):
+    for _, host in _iter_named_adapter_hosts(pipe):
         yield host
 
 
@@ -135,12 +144,14 @@ def _sorted_lora_entries(entries):
     return sorted(entries, key=lambda entry: entry["adapter_name"])
 
 
-def _download_lora_weight(repo_id: str, weight_name: str, token=HF_TOKEN):
+def _download_lora_weight(repo_id: str, weight_name: str, revision=None, token=HF_TOKEN):
     from huggingface_hub import hf_hub_download
 
     kwargs = {}
     if token:
         kwargs["token"] = token
+    if revision:
+        kwargs["revision"] = revision
     return hf_hub_download(repo_id, filename=weight_name, **kwargs)
 
 
@@ -169,21 +180,275 @@ def _ensure_pipeline_lora_prefix(state_dict):
     return state_dict
 
 
-def safe_unload_lora_adapters(pipe):
+def _has_lora_tensors(state_dict):
+    return any(".lora_A." in key or ".lora_B." in key for key in state_dict.keys())
+
+
+def _strip_state_dict_prefix(state_dict, prefix):
+    if not prefix:
+        return state_dict
+    return {
+        key[len(prefix) :] if key.startswith(prefix) else key: value
+        for key, value in state_dict.items()
+    }
+
+
+def _strip_known_peft_prefixes(state_dict):
+    stripped = dict(state_dict)
+    for prefix in ("base_model.model.", "model."):
+        if any(key.startswith(prefix) for key in stripped.keys()):
+            stripped = _strip_state_dict_prefix(stripped, prefix)
+    return stripped
+
+
+def _state_dict_for_model_host(state_dict, host_name):
+    state_dict = _strip_known_peft_prefixes(state_dict)
+    if not host_name:
+        return state_dict
+
+    own_prefix = f"{host_name}."
+    own_state_dict = {
+        key[len(own_prefix) :]: value
+        for key, value in state_dict.items()
+        if key.startswith(own_prefix)
+    }
+    if _has_lora_tensors(own_state_dict):
+        return own_state_dict
+
+    transformer_prefix = "transformer."
+    transformer_state_dict = {
+        key[len(transformer_prefix) :]: value
+        for key, value in state_dict.items()
+        if key.startswith(transformer_prefix)
+    }
+    if _has_lora_tensors(transformer_state_dict):
+        return transformer_state_dict
+
+    if not any(
+        key.startswith(("transformer.", "unconditional_transformer."))
+        for key in state_dict.keys()
+        if ".lora_" in key or key.endswith(".alpha")
+    ):
+        return state_dict
+
+    return own_state_dict
+
+
+def _lora_module_name_from_key(key):
+    for marker in (".lora_A.", ".lora_B."):
+        if marker in key:
+            return key.split(marker, 1)[0]
+    return None
+
+
+def _module_name_from_alpha_key(key):
+    if key.endswith(".alpha"):
+        return key[: -len(".alpha")]
+    return None
+
+
+def _scalar_to_float(value):
+    if hasattr(value, "detach"):
+        return float(value.detach().cpu().reshape(-1)[0].item())
+    if hasattr(value, "item"):
+        return float(value.item())
+    return float(value)
+
+
+def _build_lora_config(state_dict):
+    from peft import LoraConfig
+
+    rank_pattern = {}
+    alpha_pattern = {}
+    for key, value in state_dict.items():
+        module_name = _lora_module_name_from_key(key)
+        if module_name is None:
+            continue
+        if ".lora_A." in key and hasattr(value, "shape") and value.shape:
+            rank_pattern[module_name] = int(value.shape[0])
+
+    for key, value in state_dict.items():
+        module_name = _module_name_from_alpha_key(key)
+        if module_name is not None:
+            alpha_pattern[module_name] = _scalar_to_float(value)
+
+    if not rank_pattern:
+        return LoraConfig()
+
+    default_rank = max(rank_pattern.values())
+    for module_name, rank in rank_pattern.items():
+        alpha_pattern.setdefault(module_name, rank)
+    return LoraConfig(
+        r=default_rank,
+        lora_alpha=default_rank,
+        rank_pattern=rank_pattern,
+        alpha_pattern=alpha_pattern,
+    )
+
+
+def _peft_load_state_dict(state_dict):
+    return {
+        key: value
+        for key, value in state_dict.items()
+        if not key.endswith(".alpha")
+    }
+
+
+def _load_lora_with_peft(host, state_dict, adapter_name):
+    from peft import inject_adapter_in_model
+    from peft.utils import set_peft_model_state_dict
+
+    state_dict = _strip_known_peft_prefixes(state_dict)
+    config = _build_lora_config(state_dict)
+    inject_adapter_in_model(config, host, adapter_name=adapter_name, state_dict=state_dict)
+    result = set_peft_model_state_dict(host, _peft_load_state_dict(state_dict), adapter_name=adapter_name)
+    unexpected_keys = [
+        key
+        for key in getattr(result, "unexpected_keys", [])
+        if ".lora_" in key or key.endswith(".alpha")
+    ]
+    if unexpected_keys:
+        raise ValueError(f"Unexpected LoRA keys while loading adapter: {unexpected_keys[:5]}")
+    return result
+
+
+def _iter_host_modules(host):
+    if not hasattr(host, "modules"):
+        return []
+    try:
+        return list(host.modules())
+    except Exception:
+        return []
+
+
+def _peft_adapter_names_on_host(host):
+    adapter_names = set()
+    peft_config = getattr(host, "peft_config", None)
+    if isinstance(peft_config, dict):
+        adapter_names.update(peft_config.keys())
+
+    for module in _iter_host_modules(host):
+        for attr_name in ("lora_A", "lora_B", "scaling"):
+            adapters = getattr(module, attr_name, None)
+            if hasattr(adapters, "keys"):
+                try:
+                    adapter_names.update(adapters.keys())
+                except Exception:
+                    pass
+    return adapter_names
+
+
+def _adapter_names_on_host(host):
+    adapter_names = set()
+    if hasattr(host, "get_list_adapters"):
+        try:
+            adapter_names.update(_flatten_adapter_names(host.get_list_adapters()))
+        except Exception:
+            pass
+    adapter_names.update(_peft_adapter_names_on_host(host))
+    return adapter_names
+
+
+def _delete_peft_adapter_on_host(host, adapter_name):
     deleted = False
-    for host in _iter_adapter_hosts(pipe):
-        if not hasattr(host, "delete_adapters"):
+    for target in (host, *_iter_host_modules(host)):
+        if not hasattr(target, "delete_adapter"):
             continue
         try:
-            adapter_names = sorted(_flatten_adapter_names(host.get_list_adapters()))
+            target.delete_adapter(adapter_name)
+            deleted = True
         except Exception:
-            adapter_names = []
-        for adapter_name in adapter_names:
+            pass
+    peft_config = getattr(host, "peft_config", None)
+    if isinstance(peft_config, dict) and adapter_name in peft_config:
+        peft_config.pop(adapter_name, None)
+        deleted = True
+    return deleted
+
+
+def _set_peft_adapters_on_host(host, adapter_names, adapter_weights):
+    changed = False
+    if not adapter_names:
+        for target in (host, *_iter_host_modules(host)):
+            if hasattr(target, "enable_adapters"):
+                try:
+                    target.enable_adapters(False)
+                    changed = True
+                except Exception:
+                    pass
+        return changed
+
+    for target in (host, *_iter_host_modules(host)):
+        if hasattr(target, "set_adapter"):
             try:
-                host.delete_adapters(adapter_name)
-                deleted = True
+                target.set_adapter(adapter_names)
+                changed = True
+            except TypeError:
+                try:
+                    target.set_adapter(adapter_names[0] if len(adapter_names) == 1 else adapter_names)
+                    changed = True
+                except Exception:
+                    pass
             except Exception:
                 pass
+        if hasattr(target, "enable_adapters"):
+            try:
+                target.enable_adapters(True)
+                changed = True
+            except Exception:
+                pass
+        if hasattr(target, "set_scale"):
+            for adapter_name, adapter_weight in zip(adapter_names, adapter_weights):
+                try:
+                    target.set_scale(adapter_name, adapter_weight)
+                    changed = True
+                except Exception:
+                    pass
+    return changed
+
+
+def _is_model_adapter_host(host):
+    return hasattr(host, "named_modules") and hasattr(host, "modules")
+
+
+def _describe_adapter_hosts(pipe):
+    descriptions = []
+    for host_name, host in _iter_named_adapter_hosts(pipe):
+        methods = [
+            method_name
+            for method_name in (
+                "load_lora_weights",
+                "load_lora_adapter",
+                "set_adapters",
+                "set_adapter",
+                "delete_adapters",
+                "delete_adapter",
+            )
+            if hasattr(host, method_name)
+        ]
+        label = host_name or "pipeline"
+        method_text = ", ".join(methods) if methods else "no adapter methods"
+        descriptions.append(f"{label}={host.__class__.__name__} ({method_text})")
+    return "; ".join(descriptions)
+
+
+def safe_unload_lora_adapters(pipe):
+    deleted = False
+    for host in _iter_adapter_hosts(pipe):
+        if hasattr(host, "delete_adapters"):
+            try:
+                adapter_names = sorted(_flatten_adapter_names(host.get_list_adapters()))
+            except Exception:
+                adapter_names = []
+            for adapter_name in adapter_names:
+                try:
+                    host.delete_adapters(adapter_name)
+                    deleted = True
+                except Exception:
+                    pass
+        for adapter_name in sorted(_peft_adapter_names_on_host(host)):
+            if _delete_peft_adapter_on_host(host, adapter_name):
+                deleted = True
     if deleted:
         return
 
@@ -210,6 +475,7 @@ def safe_unload_lora_adapters(pipe):
                 host.disable_lora()
             except Exception:
                 pass
+        _set_peft_adapters_on_host(host, [], [])
 
 
 def _set_adapters_on_host(host, adapter_names, adapter_weights):
@@ -247,6 +513,28 @@ def apply_lora_adapters(pipe, lora_entries):
     adapter_weights = [entry["scale"] for entry in sorted_entries]
 
     activated = False
+    missing_on_hosts = []
+    for host_name, host in _iter_named_adapter_hosts(pipe):
+        host_adapter_names = _adapter_names_on_host(host)
+        if not host_adapter_names:
+            continue
+        missing = set(adapter_names) - host_adapter_names
+        if missing:
+            missing_on_hosts.append(f"{host_name or 'pipeline'} missing {sorted(missing)}")
+            continue
+        if not (
+            _set_adapters_on_host(host, adapter_names, adapter_weights)
+            or _set_peft_adapters_on_host(host, adapter_names, adapter_weights)
+        ):
+            raise ValueError(f"Could not activate LoRA adapters on {host_name or 'pipeline'}.")
+        activated = True
+
+    if missing_on_hosts:
+        raise ValueError("Partial LoRA adapter state: " + "; ".join(missing_on_hosts))
+
+    if activated:
+        return
+
     for host in _iter_adapter_hosts(pipe):
         if _set_adapters_on_host(host, adapter_names, adapter_weights):
             activated = True
@@ -261,54 +549,115 @@ def apply_lora_adapters(pipe, lora_entries):
     raise ValueError("This runtime does not support activating multiple LoRA adapters.")
 
 
-def load_lora_adapter(pipe, entry, token=HF_TOKEN):
-    load_kwargs = {
+def _load_lora_adapter_on_host(host, state_dict, adapter_name):
+    try:
+        host.load_lora_adapter(dict(state_dict), adapter_name=adapter_name, prefix=None)
+        return
+    except TypeError:
+        host.load_lora_adapter(dict(state_dict), adapter_name=adapter_name)
+
+
+def _pipeline_load_kwargs(entry, token):
+    base_kwargs = {
         "weight_name": entry["weight_name"],
         "adapter_name": entry["adapter_name"],
     }
+    if entry.get("revision"):
+        base_kwargs["revision"] = entry["revision"]
     if token:
-        load_kwargs["token"] = token
+        base_kwargs["token"] = token
+
+    variants = [base_kwargs]
+    if "token" in base_kwargs:
+        without_token = dict(base_kwargs)
+        without_token.pop("token", None)
+        variants.append(without_token)
+    if "revision" in base_kwargs:
+        without_revision = dict(base_kwargs)
+        without_revision.pop("revision", None)
+        variants.append(without_revision)
+        without_token_revision = dict(without_revision)
+        without_token_revision.pop("token", None)
+        variants.append(without_token_revision)
+
+    unique_variants = []
+    seen = set()
+    for kwargs in variants:
+        key = tuple(sorted(kwargs.items()))
+        if key not in seen:
+            seen.add(key)
+            unique_variants.append(kwargs)
+    return unique_variants
 
+
+def load_lora_adapter(pipe, entry, token=HF_TOKEN):
     native_error = None
     if hasattr(pipe, "load_lora_weights"):
+        for load_kwargs in _pipeline_load_kwargs(entry, token):
+            try:
+                pipe.load_lora_weights(entry["repo_id"], **load_kwargs)
+                return
+            except TypeError as exc:
+                native_error = exc
+            except Exception as exc:
+                native_error = exc
+                break
+
+    local_path = _download_lora_weight(
+        entry["repo_id"],
+        entry["weight_name"],
+        revision=entry.get("revision"),
+        token=token,
+    )
+    state_dict = _load_adapter_state_dict(local_path)
+
+    native_hosts = [
+        (host_name, host)
+        for host_name, host in _iter_named_adapter_hosts(pipe)
+        if hasattr(host, "load_lora_adapter")
+    ]
+    if native_hosts:
+        loaded_hosts = []
         try:
-            pipe.load_lora_weights(entry["repo_id"], **load_kwargs)
+            for host_name, host in native_hosts:
+                host_state_dict = _state_dict_for_model_host(state_dict, host_name)
+                if not _has_lora_tensors(host_state_dict):
+                    raise ValueError(f"No LoRA tensors matched {host_name or 'pipeline'}.")
+                _load_lora_adapter_on_host(host, host_state_dict, entry["adapter_name"])
+                loaded_hosts.append(host)
             return
-        except TypeError as exc:
-            native_error = exc
-            if token:
-                load_kwargs.pop("token", None)
-                try:
-                    pipe.load_lora_weights(entry["repo_id"], **load_kwargs)
-                    return
-                except Exception as retry_exc:
-                    native_error = retry_exc
         except Exception as exc:
+            for host in loaded_hosts:
+                _delete_peft_adapter_on_host(host, entry["adapter_name"])
+                if hasattr(host, "delete_adapters"):
+                    try:
+                        host.delete_adapters(entry["adapter_name"])
+                    except Exception:
+                        pass
             native_error = exc
 
-    local_path = _download_lora_weight(entry["repo_id"], entry["weight_name"], token=token)
-    state_dict = _load_adapter_state_dict(local_path)
+    peft_hosts = [
+        (host_name, host)
+        for host_name, host in _iter_named_adapter_hosts(pipe)
+        if host_name is not None and _is_model_adapter_host(host)
+    ]
+    if not peft_hosts and _is_model_adapter_host(pipe):
+        peft_hosts = [(None, pipe)]
 
-    loaded = False
-    for host in _iter_adapter_hosts(pipe):
-        if not hasattr(host, "load_lora_adapter"):
-            continue
+    if peft_hosts:
+        loaded_hosts = []
         try:
-            host.load_lora_adapter(dict(state_dict), adapter_name=entry["adapter_name"], prefix=None)
-            loaded = True
-            continue
-        except TypeError:
-            try:
-                host.load_lora_adapter(dict(state_dict), adapter_name=entry["adapter_name"])
-                loaded = True
-                continue
-            except Exception as exc:
-                native_error = native_error or exc
+            for host_name, host in peft_hosts:
+                host_state_dict = _state_dict_for_model_host(state_dict, host_name)
+                if not _has_lora_tensors(host_state_dict):
+                    raise ValueError(f"No LoRA tensors matched {host_name or 'pipeline'}.")
+                _load_lora_with_peft(host, host_state_dict, entry["adapter_name"])
+                loaded_hosts.append(host)
+            return
         except Exception as exc:
-            native_error = native_error or exc
-
-    if loaded:
-        return
+            for host in loaded_hosts:
+                _delete_peft_adapter_on_host(host, entry["adapter_name"])
+            native_error = exc
 
     if hasattr(pipe, "load_lora_weights"):
         try:
@@ -320,7 +669,10 @@ def load_lora_adapter(pipe, entry, token=HF_TOKEN):
                 raise ValueError(f"{native_error}; fallback failed with {exc}") from exc
             raise
 
-    raise ValueError("This pipeline does not expose a LoRA loader on itself or its transformers.")
+    details = _describe_adapter_hosts(pipe)
+    if native_error is not None:
+        raise ValueError(f"Could not load LoRA adapter with native or PEFT fallback: {native_error}. Hosts: {details}") from native_error
+    raise ValueError(f"This pipeline does not expose a usable LoRA loader. Hosts: {details}")
 
 
 def ensure_loras_loaded(pipe, spec_text: str, global_scale: float, active_by_key: dict, token=HF_TOKEN):

tests/test_lora_utils.py

@@ -30,6 +30,46 @@ class DummyIdeogramPipeline:
         self.unconditional_transformer = DummyAdapterHost()
 
 
+class DummyPeftLayer:
+    def __init__(self):
+        self.lora_A = {}
+        self.active_names = None
+        self.scales = []
+        self.enabled = None
+        self.deleted = []
+
+    def set_adapter(self, adapter_names):
+        self.active_names = adapter_names
+
+    def set_scale(self, adapter_name, scale):
+        self.scales.append((adapter_name, scale))
+
+    def enable_adapters(self, enabled):
+        self.enabled = enabled
+
+    def delete_adapter(self, adapter_name):
+        self.deleted.append(adapter_name)
+        self.lora_A.pop(adapter_name, None)
+
+
+class DummyPeftHost:
+    def __init__(self):
+        self.peft_config = {}
+        self.layer = DummyPeftLayer()
+
+    def modules(self):
+        return [self, self.layer]
+
+    def named_modules(self):
+        return [("", self), ("layer", self.layer)]
+
+
+class DummyPeftOnlyIdeogramPipeline:
+    def __init__(self):
+        self.transformer = DummyPeftHost()
+        self.unconditional_transformer = DummyPeftHost()
+
+
 class ParseAdapterSpecsTest(unittest.TestCase):
     def test_blank_spec_returns_no_entries(self):
         self.assertEqual(parse_adapter_specs("\n  \n", 1.0), [])
@@ -61,6 +101,7 @@ class ParseAdapterSpecsTest(unittest.TestCase):
 
         self.assertEqual(entries[0]["repo_id"], "vladi/loras")
         self.assertEqual(entries[0]["weight_name"], "klein9b/klein_snofs_v1_4.safetensors")
+        self.assertEqual(entries[0]["revision"], "dev")
         self.assertEqual(entries[0]["scale"], 0.8)
 
     def test_rejects_missing_weight_name(self):
@@ -99,6 +140,37 @@ class ParseAdapterSpecsTest(unittest.TestCase):
         self.assertEqual(pipe.transformer.active_weights, [0.8])
         self.assertEqual(pipe.unconditional_transformer.active_weights, [0.8])
 
+    def test_loads_lora_with_peft_fallback_when_transformers_have_no_loader(self):
+        pipe = DummyPeftOnlyIdeogramPipeline()
+        active_by_key = {}
+        state_dict = {"transformer.transformer_blocks.0.attn.to_q.lora_A.weight": object()}
+        loaded = []
+
+        def fake_load_with_peft(host, host_state_dict, adapter_name):
+            loaded.append((host, host_state_dict, adapter_name))
+            host.peft_config[adapter_name] = object()
+            host.layer.lora_A[adapter_name] = object()
+
+        with mock.patch("lora_utils._download_lora_weight", return_value="/tmp/adapter.safetensors"), mock.patch(
+            "lora_utils._load_adapter_state_dict", return_value=state_dict
+        ), mock.patch("lora_utils._load_lora_with_peft", side_effect=fake_load_with_peft):
+            entries = ensure_loras_loaded(
+                pipe,
+                "https://huggingface.co/vladi/loras/blob/dev/klein9b/klein_snofs_v1_4.safetensors",
+                0.7,
+                active_by_key,
+                token="secret",
+            )
+
+        adapter_name = entries[0]["adapter_name"]
+        expected_state_dict = {"transformer_blocks.0.attn.to_q.lora_A.weight": state_dict[next(iter(state_dict))]}
+        self.assertEqual(loaded[0], (pipe.transformer, expected_state_dict, adapter_name))
+        self.assertEqual(loaded[1], (pipe.unconditional_transformer, expected_state_dict, adapter_name))
+        self.assertEqual(pipe.transformer.layer.active_names, [adapter_name])
+        self.assertEqual(pipe.unconditional_transformer.layer.active_names, [adapter_name])
+        self.assertEqual(pipe.transformer.layer.scales, [(adapter_name, 0.7)])
+        self.assertEqual(pipe.unconditional_transformer.layer.scales, [(adapter_name, 0.7)])
+
 
 if __name__ == "__main__":
     unittest.main()