brainfactory 0.1.0__tar.gz → 0.2.0__tar.gz

{brainfactory-0.1.0 → brainfactory-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainfactory
-Version: 0.1.0
+Version: 0.2.0
 Summary: The executable onboarding engine for Brain Factory — provision, adopt, and upgrade project 'brain' repositories.
 Author: Izak Laubscher
 License: MIT
@@ -40,7 +40,7 @@ pip install brainfactory
 pipx install "brainfactory[schema]"
 ```
 
-Until the package is published to PyPI, install straight from the repo:
+To install the latest unreleased build straight from the repository:
 
 ```bash
 pipx install "git+https://github.com/izakl/brainforge#subdirectory=brain-factory/adapters/python"

{brainfactory-0.1.0 → brainfactory-0.2.0}/README.md

@@ -18,7 +18,7 @@ pip install brainfactory
 pipx install "brainfactory[schema]"
 ```
 
-Until the package is published to PyPI, install straight from the repo:
+To install the latest unreleased build straight from the repository:
 
 ```bash
 pipx install "git+https://github.com/izakl/brainforge#subdirectory=brain-factory/adapters/python"

{brainfactory-0.1.0 → brainfactory-0.2.0}/brainfactory/__init__.py

@@ -22,4 +22,4 @@ __all__ = [
     "apply",
 ]
 
-__version__ = "0.1.0"
+__version__ = "0.2.0"

{brainfactory-0.1.0 → brainfactory-0.2.0}/brainfactory/apply.py

@@ -34,6 +34,8 @@ MODULE_TEMPLATE_PATHS: dict[str, tuple[str, ...]] = {
     "operating-contract": (
         "00-governance/OPERATING-CONTRACT.md.tmpl",
         "AGENTS.md.tmpl",
+        "CLAUDE.md.tmpl",
+        ".github/copilot-instructions.md.tmpl",
     ),
     "session-ritual-hooks": ("03-templates/agent-commands/hooks",),
     "continuity-log": (

{brainfactory-0.1.0 → brainfactory-0.2.0}/brainfactory/capabilities.py

@@ -17,6 +17,12 @@ Three modes:
   no matching row in the committed ``CAPABILITIES.md`` — "a feature cannot land
   without the brain growing with it".
 
+Command discovery is guarded: :func:`build_model` raises
+:class:`CommandNamingError` if any command directory's base name already starts
+with ``<prefix>-`` (the ``ap-ap-*`` double-prefix bug), so ``--write``,
+``--check`` and the intent gate all fail rather than silently emitting a doubled
+invocation. :func:`find_prefixed_command_dirs` is the read-only companion.
+
 Standard library only. Typed. Same code style as ``inspect.py``.
 """
 
@@ -63,6 +69,45 @@ class CommandInfo:
         }
 
 
+class CommandNamingError(ValueError):
+    """A command directory base name redundantly starts with the command prefix.
+
+    The generator derives a command's invocation as ``<prefix>-<base>`` (see
+    :meth:`CommandInfo.invocation`). If the directory base *already* starts with
+    ``<prefix>-`` the invocation doubles the prefix — e.g. prefix ``ap`` and a
+    directory ``ap-foo`` yield ``ap-ap-foo``. Command directories must use BARE
+    names; this error stops such a map from ever being generated (it fails
+    ``--check``, ``--write`` and the intent gate) so the bug can never silently
+    ship.
+    """
+
+    def __init__(self, offenders: list[CommandInfo], prefix: str) -> None:
+        self.offenders = list(offenders)
+        self.prefix = prefix
+        super().__init__(self._render(self.offenders, prefix))
+
+    @staticmethod
+    def _render(offenders: list[CommandInfo], prefix: str) -> str:
+        n = len(offenders)
+        noun = "directory" if n == 1 else "directories"
+        verb = "is" if n == 1 else "are"
+        lines = [
+            f"{n} command {noun} {verb} mis-named with a redundant "
+            f"'{prefix}-' prefix.",
+            "The generator invokes a command as '<prefix>-<base>', so a "
+            f"directory whose name already starts with '{prefix}-' doubles the "
+            f"prefix (e.g. '{prefix}-{prefix}-...').",
+            "Rename each directory to a BARE name:",
+        ]
+        for c in sorted(offenders, key=lambda o: (o.layer, o.base)):
+            bare = c.base[len(prefix) + 1:] or "<name>"
+            lines.append(
+                f"  - {c.layer}/{c.base} -> {c.layer}/{bare} "
+                f"(now invokes '{prefix}-{c.base}'; should be '{prefix}-{bare}')"
+            )
+        return "\n".join(lines)
+
+
 @dataclass
 class AppRepo:
     """One coordinated app repo from the manifest."""
@@ -176,6 +221,40 @@ def _discover_commands(brain: Path, layer_rel: str, layer: str) -> list[CommandI
     return found
 
 
+def _prefixed_offenders(
+    commands: list[CommandInfo], prefix: str,
+) -> list[CommandInfo]:
+    """Command dirs whose base name already starts with ``<prefix>-``.
+
+    These are the double-prefix bug: the generator would render their invocation
+    as ``<prefix>-<prefix>-...``. An empty prefix disables the check.
+    """
+    if not prefix:
+        return []
+    token = f"{prefix}-"
+    return [c for c in commands if c.base.startswith(token)]
+
+
+def find_prefixed_command_dirs(
+    brain: str | Path, prefix: str | None = None,
+) -> list[CommandInfo]:
+    """Return command dirs whose base redundantly starts with ``<prefix>-``.
+
+    Read-only companion to the guard baked into :func:`build_model`: it never
+    raises, so callers (e.g. the hub self-check) can report *all* offenders at
+    once. ``prefix`` defaults to the brain manifest's ``command_prefix`` (or
+    ``"cmd"`` when unset), matching :func:`build_model`.
+    """
+    root = Path(brain).resolve()
+    if prefix is None:
+        prefix = _read_manifest(root).get("command_prefix") or "cmd"
+    commands = [
+        *_discover_commands(root, _CORE_REL, "core"),
+        *_discover_commands(root, _EXT_REL, "extensions"),
+    ]
+    return _prefixed_offenders(commands, prefix)
+
+
 def build_model(brain: str | Path) -> CapabilitiesModel:
     """Scan a brain directory and assemble the capabilities model from code."""
     root = Path(brain).resolve()
@@ -194,13 +273,21 @@ def build_model(brain: str | Path) -> CapabilitiesModel:
         if isinstance(entry, dict) and entry.get("name"):
             app_repos.append(AppRepo(name=entry["name"], role=entry.get("role", "")))
 
+    core_commands = _discover_commands(root, _CORE_REL, "core")
+    extension_commands = _discover_commands(root, _EXT_REL, "extensions")
+
+    offenders = _prefixed_offenders(
+        [*core_commands, *extension_commands], command_prefix)
+    if offenders:
+        raise CommandNamingError(offenders, command_prefix)
+
     return CapabilitiesModel(
         project_name=project_name,
         command_prefix=command_prefix,
         framework_version=framework_version,
         platforms=platforms,
-        core_commands=_discover_commands(root, _CORE_REL, "core"),
-        extension_commands=_discover_commands(root, _EXT_REL, "extensions"),
+        core_commands=core_commands,
+        extension_commands=extension_commands,
         app_repos=app_repos,
     )
 

{brainfactory-0.1.0 → brainfactory-0.2.0}/brainfactory/cli.py

@@ -104,12 +104,18 @@ def cmd_adopt(args: argparse.Namespace) -> int:
 
 def cmd_capabilities(args: argparse.Namespace) -> int:
     brain = args.brain or "."
-    if args.write:
-        path = capabilities_mod.write(brain)
-        print(f"Wrote capabilities map: {path}")
-        return 0
-    # Default (and --check): regenerate in-memory and diff.
-    result = capabilities_mod.check(brain)
+    try:
+        if args.write:
+            path = capabilities_mod.write(brain)
+            print(f"Wrote capabilities map: {path}")
+            return 0
+        # Default (and --check): regenerate in-memory and diff.
+        result = capabilities_mod.check(brain)
+    except capabilities_mod.CommandNamingError as exc:
+        print("capabilities: FAIL — command directory naming error (refusing to "
+              "emit a doubled invocation).\n")
+        print(exc)
+        return 1
     if args.json:
         Path(args.json).write_text(
             json.dumps(result.to_dict(), indent=2) + "\n", encoding="utf-8")
@@ -140,7 +146,13 @@ def cmd_docs_mesh(args: argparse.Namespace) -> int:
 
 def cmd_intent_gate(args: argparse.Namespace) -> int:
     brain = args.brain or "."
-    result = capabilities_mod.intent_gate(brain)
+    try:
+        result = capabilities_mod.intent_gate(brain)
+    except capabilities_mod.CommandNamingError as exc:
+        print("intent-gate: FAIL — command directory naming error (refusing to "
+              "emit a doubled invocation).\n")
+        print(exc)
+        return 1
     if args.json:
         Path(args.json).write_text(
             json.dumps(result.to_dict(), indent=2) + "\n", encoding="utf-8")

{brainfactory-0.1.0 → brainfactory-0.2.0}/brainfactory/inspect.py

@@ -44,6 +44,21 @@ _EXTERNAL_SOT_SIGNALS = (
     "source of truth",
 )
 
+# Runtime/docs drift signals (inspect-first). The first codified check targets
+# PostgreSQL version mismatch between runtime config and docs.
+_PG_DOC_RE = re.compile(r"\bpostgres(?:ql)?(?:\s+version)?\s*(\d{1,2})\b",
+                        re.IGNORECASE)
+_PG_IMAGE_RE = re.compile(r"\bpostgres:(\d{1,2})(?:[.-][^\s\"']*)?\b",
+                          re.IGNORECASE)
+_RUNTIME_CONFIG_GLOBS = (
+    "docker-compose.yml",
+    "docker-compose.yaml",
+    "compose.yml",
+    "compose.yaml",
+    "docker/**/*.yml",
+    "docker/**/*.yaml",
+)
+
 
 @dataclass
 class ModuleFinding:
@@ -247,6 +262,12 @@ def inspect_repo(repo_path: str | Path) -> InspectionResult:
             f_cont.action = "augment"
     modules.append(f_cont)
 
+    # Runtime/docs drift risk scan (currently PostgreSQL-focused).
+    drift_hits = _scan_runtime_docs_drift(files, root)
+    if drift_hits:
+        for hit in drift_hits:
+            risks.append(hit)
+
     # --- capabilities-map -----------------------------------------------------
     # CAPABILITIES.md or an inventory doc.
     cap = _collect(files, root, name_globs=("CAPABILITIES.md", "CAPABILITIES*.md",
@@ -353,6 +374,59 @@ def _scan_external_sot(files: list[Path], root: Path) -> list[dict[str, str]]:
     return hits
 
 
+def _scan_runtime_docs_drift(files: list[Path], root: Path) -> list[dict[str, str]]:
+    """Detect runtime-vs-doc version drift discovered during inspect-first audits."""
+    runtime_versions: dict[str, str] = {}
+    docs_versions: dict[str, str] = {}
+
+    for f in files:
+        rel = _rel(f, root).replace(os.sep, "/")
+        lower = rel.lower()
+        try:
+            text = f.read_text(encoding="utf-8", errors="ignore")
+        except OSError:
+            continue
+
+        is_runtime_config = any(
+            _match_any(lower, f.name.lower(), (pat,)) for pat in _RUNTIME_CONFIG_GLOBS
+        )
+        if is_runtime_config:
+            for m in _PG_IMAGE_RE.finditer(text):
+                runtime_versions[m.group(1)] = rel
+
+        if f.suffix.lower() in (".md", ".txt", ".rst"):
+            for m in _PG_DOC_RE.finditer(text):
+                docs_versions[m.group(1)] = rel
+
+    if not runtime_versions or not docs_versions:
+        return []
+
+    runtime_set = set(runtime_versions.keys())
+    docs_set = set(docs_versions.keys())
+    if runtime_set == docs_set:
+        return []
+
+    runtime_text = ", ".join(sorted(runtime_set))
+    docs_text = ", ".join(sorted(docs_set))
+    evidence = (
+        f"runtime config: {', '.join(sorted(set(runtime_versions.values()))[:4])}; "
+        f"docs: {', '.join(sorted(set(docs_versions.values()))[:4])}"
+    )
+    detail = (
+        "Detected runtime/docs PostgreSQL version drift: "
+        f"runtime config indicates {runtime_text}, docs indicate {docs_text}."
+    )
+    return [{
+        "kind": "runtime-config-drift",
+        "severity": "high",
+        "evidence": evidence,
+        "detail": detail,
+        "recommended_action": (
+            "Reconcile docs and runtime config to one approved version before apply."
+        ),
+    }]
+
+
 def _detect_platforms(files: list[Path], root: Path) -> dict[str, Any]:
     """Capture platform signals: *.ps1 vs *.sh, workflows."""
     ps1 = _collect(files, root, name_globs=("*.ps1",))

{brainfactory-0.1.0 → brainfactory-0.2.0}/brainfactory.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: brainfactory
-Version: 0.1.0
+Version: 0.2.0
 Summary: The executable onboarding engine for Brain Factory — provision, adopt, and upgrade project 'brain' repositories.
 Author: Izak Laubscher
 License: MIT
@@ -40,7 +40,7 @@ pip install brainfactory
 pipx install "brainfactory[schema]"
 ```
 
-Until the package is published to PyPI, install straight from the repo:
+To install the latest unreleased build straight from the repository:
 
 ```bash
 pipx install "git+https://github.com/izakl/brainforge#subdirectory=brain-factory/adapters/python"

{brainfactory-0.1.0 → brainfactory-0.2.0}/brainfactory.egg-info/SOURCES.txt

@@ -20,8 +20,10 @@ brainfactory.egg-info/requires.txt
 brainfactory.egg-info/top_level.txt
 tests/test_adapters.py
 tests/test_apply.py
+tests/test_capabilities.py
 tests/test_emit.py
 tests/test_manifest.py
 tests/test_mcpserver.py
+tests/test_operating_standards.py
 tests/test_substitute.py
 tests/test_upgrade.py

{brainfactory-0.1.0 → brainfactory-0.2.0}/tests/test_apply.py

@@ -21,6 +21,15 @@ class ProvisionTest(unittest.TestCase):
             agents = (dest / "AGENTS.md").read_text(encoding="utf-8")
             self.assertIn("Acme brain", agents)
             self.assertNotIn("{{", agents)
+            claude = (dest / "CLAUDE.md").read_text(encoding="utf-8")
+            copilot = (dest / ".github" / "copilot-instructions.md").read_text(
+                encoding="utf-8")
+            self.assertIn("SYNC-LATEST-FIRST STANDARD", agents)
+            self.assertIn("CLEANUP-NO-STALE-STATE STANDARD", agents)
+            self.assertIn("SYNC-LATEST-FIRST STANDARD", claude)
+            self.assertIn("CLEANUP-NO-STALE-STATE STANDARD", claude)
+            self.assertIn("SYNC-LATEST-FIRST STANDARD", copilot)
+            self.assertIn("CLEANUP-NO-STALE-STATE STANDARD", copilot)
 
     def test_provision_refuses_nonempty_dest(self):
         with tempfile.TemporaryDirectory() as d:

brainfactory-0.2.0/tests/test_capabilities.py

@@ -0,0 +1,165 @@
+"""Tests for the capabilities generator's command-dir naming guard.
+
+The generator derives a command's invocation as ``<prefix>-<base>``. A command
+directory whose base already starts with ``<prefix>-`` doubles the prefix (the
+``ap-ap-*`` bug that bit the Contoso brain). :func:`build_model` must refuse such
+a brain so ``--check``, ``--write`` and the intent gate all fail rather than
+silently emitting a doubled invocation. These tests prove the guard catches the
+offense, stays silent on correctly bare directories, and that the hub's own
+shipped ``brain-template`` command dirs are clean.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import subprocess
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+from brainfactory import capabilities as cap
+
+ADAPTERS = Path(__file__).resolve().parents[2]        # .../brain-factory/adapters
+PYDIR = ADAPTERS / "python"
+BRAIN_TEMPLATE = ADAPTERS.parent / "brain-template"   # .../brain-factory/brain-template
+
+
+def _make_brain(root: Path, prefix: str,
+                dirs: list[tuple[str, str]], *, manifest: bool = True) -> Path:
+    """Build a minimal brain: a manifest plus one SKILL.md per command dir."""
+    brain = root / "brain"
+    brain.mkdir()
+    if manifest:
+        (brain / "brain.manifest.json").write_text(
+            json.dumps({"command_prefix": prefix, "project": {"name": "T"}}),
+            encoding="utf-8")
+    for layer, name in dirs:
+        cmd = brain / "03-templates" / "agent-commands" / layer / name
+        cmd.mkdir(parents=True)
+        (cmd / "SKILL.md").write_text(
+            "---\ndescription: demo\n---\nbody\n", encoding="utf-8")
+    return brain
+
+
+def _run_cli(args: list[str], cwd: str) -> subprocess.CompletedProcess:
+    env = dict(os.environ)
+    prev = env.get("PYTHONPATH")
+    env["PYTHONPATH"] = str(PYDIR) + (os.pathsep + prev if prev else "")
+    return subprocess.run(
+        [sys.executable, "-m", "brainfactory", *args],
+        capture_output=True, text=True, env=env, cwd=cwd)
+
+
+class NamingGuardModelTest(unittest.TestCase):
+    def test_build_model_raises_on_prefixed_core_dir(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap",
+                                [("core", "ap-foo"), ("core", "bar")])
+            with self.assertRaises(cap.CommandNamingError) as ctx:
+                cap.build_model(brain)
+            msg = str(ctx.exception)
+            self.assertIn("ap-foo", msg)
+            self.assertIn("ap-ap-foo", msg)       # names the doubled invocation
+            self.assertIn("core/foo", msg)        # actionable bare rename
+            self.assertEqual([c.base for c in ctx.exception.offenders], ["ap-foo"])
+            self.assertEqual(ctx.exception.prefix, "ap")
+
+    def test_build_model_raises_on_prefixed_extension_dir(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap", [("extensions", "ap-deploy")])
+            with self.assertRaises(cap.CommandNamingError):
+                cap.build_model(brain)
+
+    def test_build_model_passes_on_bare_dirs(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap",
+                                [("core", "foo"), ("extensions", "bar")])
+            model = cap.build_model(brain)
+            invs = [c.invocation("ap")
+                    for c in model.core_commands + model.extension_commands]
+            self.assertEqual(sorted(invs), ["ap-bar", "ap-foo"])
+
+    def test_substring_prefix_is_not_flagged(self):
+        # Only a leading "<prefix>-" is the bug; a base that merely starts with
+        # the prefix letters (or contains them) must be allowed.
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap",
+                                [("core", "apply"), ("core", "map-ap")])
+            model = cap.build_model(brain)        # must NOT raise
+            self.assertEqual(len(model.core_commands), 2)
+
+
+class NamingGuardCheckWriteTest(unittest.TestCase):
+    def test_check_raises_and_write_refuses_to_emit(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap", [("core", "ap-foo")])
+            with self.assertRaises(cap.CommandNamingError):
+                cap.check(brain)
+            with self.assertRaises(cap.CommandNamingError):
+                cap.write(brain)
+            # write must NOT have produced the (doubled) map.
+            self.assertFalse((brain / "01-docs" / "CAPABILITIES.md").exists())
+
+    def test_intent_gate_raises_on_prefixed_dir(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap", [("core", "ap-foo")])
+            with self.assertRaises(cap.CommandNamingError):
+                cap.intent_gate(brain)
+
+
+class FindPrefixedCommandDirsTest(unittest.TestCase):
+    def test_reports_all_offenders_without_raising(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap",
+                                [("core", "ap-foo"), ("extensions", "ap-bar"),
+                                 ("core", "ok")])
+            offenders = cap.find_prefixed_command_dirs(brain)  # prefix from manifest
+            self.assertEqual(sorted(c.base for c in offenders),
+                             ["ap-bar", "ap-foo"])
+
+    def test_explicit_prefix_overrides_manifest(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap", [("core", "zz-foo")])
+            self.assertEqual(cap.find_prefixed_command_dirs(brain), [])
+            hits = cap.find_prefixed_command_dirs(brain, prefix="zz")
+            self.assertEqual([c.base for c in hits], ["zz-foo"])
+
+
+class HubTemplateCleanTest(unittest.TestCase):
+    def test_brain_template_command_dirs_are_bare(self):
+        # Hub self-guard: the shipped brain-template command dirs must be bare
+        # against the example manifest's command_prefix (same check CI runs).
+        example = BRAIN_TEMPLATE / "brain.manifest.example.json"
+        prefix = json.loads(example.read_text(encoding="utf-8")).get("command_prefix")
+        self.assertTrue(prefix, "example manifest is missing command_prefix")
+        offenders = cap.find_prefixed_command_dirs(BRAIN_TEMPLATE, prefix)
+        self.assertEqual(
+            offenders, [],
+            "brain-template command dirs must be bare, found: "
+            + ", ".join(f"{c.layer}/{c.base}" for c in offenders))
+
+
+class NamingGuardCliTest(unittest.TestCase):
+    def test_cli_check_exits_1_with_clean_message(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap", [("core", "ap-foo")])
+            r = _run_cli(["capabilities", "--brain", str(brain), "--check"], cwd=d)
+            self.assertEqual(r.returncode, 1, r.stderr)
+            self.assertIn("naming error", r.stdout.lower())
+            self.assertIn("ap-ap-foo", r.stdout)
+            self.assertNotIn("Traceback", r.stderr)   # clean failure, not a crash
+
+    def test_cli_write_then_check_exit_0_on_bare(self):
+        with tempfile.TemporaryDirectory() as d:
+            brain = _make_brain(Path(d), "ap", [("core", "foo")])
+            w = _run_cli(["capabilities", "--brain", str(brain), "--write"], cwd=d)
+            self.assertEqual(w.returncode, 0, w.stderr)
+            self.assertTrue((brain / "01-docs" / "CAPABILITIES.md").is_file())
+            r = _run_cli(["capabilities", "--brain", str(brain), "--check"], cwd=d)
+            self.assertEqual(r.returncode, 0, r.stdout + r.stderr)
+
+
+if __name__ == "__main__":
+    unittest.main()

brainfactory-0.2.0/tests/test_operating_standards.py

@@ -0,0 +1,40 @@
+"""Regression checks for permanent operating standards across toolchains."""
+
+from __future__ import annotations
+
+import unittest
+from pathlib import Path
+
+ANCHORS = (
+    "SYNC-LATEST-FIRST STANDARD",
+    "CLEANUP-NO-STALE-STATE STANDARD",
+    "CONTINUITY-CAPTURE / BRAIN-MEMORY WRITEBACK STANDARD",
+)
+
+REQUIRED_FILES = (
+    "AGENTS.md",
+    ".github/copilot-instructions.md",
+    "CLAUDE.md",
+    "brain-factory/brain-template/AGENTS.md.tmpl",
+    "brain-factory/brain-template/.github/copilot-instructions.md.tmpl",
+    "brain-factory/brain-template/CLAUDE.md.tmpl",
+)
+
+
+class OperatingStandardsPresenceTest(unittest.TestCase):
+    def test_anchors_exist_in_all_required_files(self):
+        repo_root = Path(__file__).resolve().parents[4]
+        for rel in REQUIRED_FILES:
+            path = repo_root / rel
+            self.assertTrue(path.is_file(), f"missing required file: {rel}")
+            content = path.read_text(encoding="utf-8")
+            for anchor in ANCHORS:
+                self.assertIn(
+                    anchor,
+                    content,
+                    f"{rel} missing required operating standard anchor: {anchor}",
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()