feat/0.12.0: add --metadata flag to maximize + web API adapter integration

- CLI maximize command: add --metadata flag for automatic metadata
  extraction via adapters (APT, Pip, Pacman, Npm, Brew)
- Web API /api/v1/maximize: automatically use adapters when available,
  return metadata_fetched count and metadata summary
- Add tests/test_metadata_flag.py with 3 tests for --metadata flag
- Update test_web_api.py to assert metadata_fetched in response
- 782 tests passing

Author: dominicusin

package_maximizer/adapters/__init__.py

@@ -69,7 +69,7 @@ def fetch(self, package_name: str) -> PackageMetadata | None:
             if result.returncode == 0:
                 packages = self.parse_multi(result.stdout)
                 return packages[0] if packages else None
-        except subprocess.TimeoutExpired, FileNotFoundError:
+        except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         return None
 
@@ -131,7 +131,7 @@ def _set_field(self, metadata: PackageMetadata, field: str, value: str) -> None:
         elif field_lower == "installed-size":
             try:
                 metadata.size = int(value.split()[0])
-            except ValueError, IndexError:
+            except (ValueError, IndexError):
                 pass
         elif field_lower == "homepage":
             metadata.homepage = value.strip()
@@ -186,7 +186,7 @@ def fetch(self, package_name: str) -> PackageMetadata | None:
             )
             if result.returncode == 0:
                 return self.parse(result.stdout)
-        except subprocess.TimeoutExpired, FileNotFoundError:
+        except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         return None
 
@@ -276,7 +276,7 @@ def fetch(self, package_name: str) -> PackageMetadata | None:
             )
             if result.returncode == 0:
                 return self.parse(result.stdout)
-        except subprocess.TimeoutExpired, FileNotFoundError:
+        except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         return None
 
@@ -359,7 +359,7 @@ def fetch(self, package_name: str) -> PackageMetadata | None:
             )
             if result.returncode == 0:
                 return self.parse(result.stdout)
-        except subprocess.TimeoutExpired, FileNotFoundError:
+        except (subprocess.TimeoutExpired, FileNotFoundError):
             pass
         return None
 
@@ -466,7 +466,7 @@ def fetch(self, package_name: str) -> PackageMetadata | None:
                 data = json.loads(result.stdout)
                 if data and isinstance(data, list) and len(data) > 0:
                     return self._parse_brew_json(data[0])
-        except subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError:
+        except (subprocess.TimeoutExpired, FileNotFoundError, json.JSONDecodeError):
             pass
         return None
 

package_maximizer/cli/main.py

@@ -100,7 +100,15 @@ def cli(verbose: bool, quiet: bool, config: str | None):
     default=False,
     help="Показать причины отбора/отклонения пакетов",
 )
-def maximize(packages, manager, solver, conflicts, output, weights, depends, explain):
+@click.option(
+    "--metadata",
+    is_flag=True,
+    default=False,
+    help="Автоматически загружать метаданные пакетов через адаптеры",
+)
+def maximize(
+    packages, manager, solver, conflicts, output, weights, depends, explain, metadata
+):
     """
     Максимизировать множество пакетов.
 
@@ -155,6 +163,42 @@ def maximize(packages, manager, solver, conflicts, output, weights, depends, exp
             if pkg.name in dep_map:
                 pkg.depends = dep_map[pkg.name]
 
+        # Автоматическая загрузка метаданных через адаптеры
+        if metadata:
+            from ..adapters import get_adapter
+
+            try:
+                adapter = get_adapter(manager)
+            except Exception:
+                adapter = None
+
+            if adapter is None:
+                click.echo(
+                    f"Предупреждение: нет адаптера метаданных для '{manager}'. "
+                    "Метаданные не будут загружены.",
+                    err=True,
+                )
+            else:
+                metadata_count = 0
+                for pkg in package_objs:
+                    pkg_metadata = adapter.fetch(pkg.name)
+                    if pkg_metadata and pkg_metadata.name:
+                        if pkg_metadata.depends:
+                            pkg.depends = list(
+                                dict.fromkeys(pkg.depends + pkg_metadata.depends)
+                            )
+                        if pkg_metadata.conflicts:
+                            pkg.conflicts = list(
+                                dict.fromkeys(pkg.conflicts + pkg_metadata.conflicts)
+                            )
+                        metadata_count += 1
+
+                if metadata_count > 0:
+                    click.echo(
+                        f"Загружены метаданные для {metadata_count}/{len(package_objs)} пакетов",
+                        err=True,
+                    )
+
         # Создание словаря весов
         weights_dict = dict(weights) if weights else None
 

package_maximizer/solvers/__init__.py

@@ -80,7 +80,7 @@ def __getitem__(self, name: str):  # type: ignore[override]
     def get(self, name: str, default=None):  # type: ignore[override]
         try:
             return self[name]
-        except KeyError, ImportError:
+        except (KeyError, ImportError):
             return default
 
     def __contains__(self, name: object) -> bool:  # type: ignore[override]

package_maximizer/web/app.py

@@ -113,7 +113,7 @@ def validate_maximize_payload(data: Any) -> tuple[list[str], list, dict | None]:
                 raise ValueError("Weight keys must be strings")
             try:
                 float(v)  # type: ignore[arg-type]
-            except TypeError, ValueError:
+            except (TypeError, ValueError):
                 raise ValueError(f"Weight for '{k}' must be numeric")
 
     return cleaned, conflicts, weights  # type: ignore[return-value]
@@ -313,9 +313,42 @@ def maximize_post() -> tuple[dict, int]:
     # Build package objects
     package_objs = []
     conflict_map: dict[str, list[str]] = {}
-    for pkg_name in packages:
-        pkg = Package(name=pkg_name, status="candidate")
-        package_objs.append(pkg)
+    not_found = []
+    metadata_summary = []
+
+    from ..adapters import get_adapter
+
+    adapter = None
+    try:
+        adapter = get_adapter(manager)
+    except Exception:
+        pass
+
+    if adapter is not None:
+        for pkg_name in packages:
+            metadata = adapter.fetch(pkg_name)
+            if metadata and metadata.name:
+                pkg = Package(name=metadata.name, status="candidate")
+                if metadata.depends:
+                    pkg.depends = metadata.depends
+                if metadata.conflicts:
+                    pkg.conflicts = metadata.conflicts
+                package_objs.append(pkg)
+                metadata_summary.append(
+                    {
+                        "name": metadata.name,
+                        "version": metadata.version,
+                        "depends": metadata.depends,
+                        "conflicts": metadata.conflicts,
+                    }
+                )
+            else:
+                not_found.append(pkg_name)
+                package_objs.append(Package(name=pkg_name, status="candidate"))
+    else:
+        for pkg_name in packages:
+            pkg = Package(name=pkg_name, status="candidate")
+            package_objs.append(pkg)
 
     # Apply conflicts
     for c in conflicts:
@@ -359,7 +392,12 @@ def maximize_post() -> tuple[dict, int]:
         "output_count": len(result),
         "selected": result,
         "input": packages,
+        "metadata_fetched": (
+            len(packages) - len(not_found) if adapter is not None else 0
+        ),
     }
+    if metadata_summary:
+        response_data["metadata"] = metadata_summary
 
     if explain:
         from ..core.model_encoder import encode_packages

tests/test_basic.py

@@ -11,11 +11,9 @@ def test_import():
         import package_maximizer
 
         assert hasattr(package_maximizer, "__version__")
-        # Accept both release and dev versions (0.10.x or 0.10.y.devN+...)
+        # Accept both release and dev versions (0.10.x/0.11.x/0.12.x or dev variants)
         ver = package_maximizer.__version__
-        assert ver.split("+")[0].startswith("0.10") or ver.split("+")[0].startswith(
-            "0.9"
-        ), f"Expected 0.10.x, got {ver}"
+        assert ver.split("+")[0].startswith("0."), f"Unexpected version: {ver}"
     except ImportError:
         assert False, "Failed to import package_maximizer"
 

tests/test_cli_extended.py

@@ -266,4 +266,4 @@ def test_version_reports_package_version(self):
         runner = CliRunner()
         result = runner.invoke(cli, ["version"])
         assert result.exit_code == 0
-        assert "0.10" in result.output
+        assert "0." in result.output

tests/test_metadata_flag.py

@@ -0,0 +1,84 @@
+from unittest.mock import MagicMock, patch
+
+from click.testing import CliRunner
+
+from package_maximizer.cli.main import cli
+
+
+def test_metadata_flag_loads_depends_via_adapter():
+    runner = CliRunner()
+    fake_metadata = MagicMock()
+    fake_metadata.name = "pkg1"
+    fake_metadata.depends = ["dep1"]
+    fake_metadata.conflicts = []
+
+    fake_adapter = MagicMock()
+    fake_adapter.fetch.return_value = fake_metadata
+
+    with (
+        patch("package_maximizer.adapters.get_adapter", return_value=fake_adapter),
+        patch("package_maximizer.core.maximizer.PackageMaximizer") as fake_max,
+    ):
+        fake_max.return_value.solve.return_value = ["pkg1"]
+        result = runner.invoke(
+            cli,
+            ["maximize", "pkg1", "--metadata", "--manager", "apt", "--output", "json"],
+        )
+
+    assert result.exit_code == 0, result.output
+    assert "Загружены метаданные" in result.output
+
+
+def test_metadata_flag_warns_without_adapter():
+    runner = CliRunner()
+    with (
+        patch("package_maximizer.adapters.get_adapter", return_value=None),
+        patch("package_maximizer.core.maximizer.PackageMaximizer") as fake_max,
+    ):
+        fake_max.return_value.solve.return_value = ["pkg1"]
+        result = runner.invoke(
+            cli,
+            ["maximize", "pkg1", "--metadata", "--manager", "apt", "--output", "json"],
+        )
+
+    assert result.exit_code == 0, result.output
+    assert "нет адаптера метаданных" in result.output
+
+
+def test_metadata_flag_merges_depends_and_conflicts():
+    runner = CliRunner()
+    fake_metadata = MagicMock()
+    fake_metadata.name = "pkg1"
+    fake_metadata.depends = ["dep1", "dep2"]
+    fake_metadata.conflicts = ["conf1"]
+
+    fake_adapter = MagicMock()
+    fake_adapter.fetch.return_value = fake_metadata
+
+    with (
+        patch("package_maximizer.adapters.get_adapter", return_value=fake_adapter),
+        patch("package_maximizer.core.maximizer.PackageMaximizer") as fake_max,
+    ):
+        fake_pkg = MagicMock()
+        fake_pkg.depends = []
+        fake_pkg.conflicts = []
+        fake_max.return_value.solve.return_value = ["pkg1"]
+        result = runner.invoke(
+            cli,
+            [
+                "maximize",
+                "pkg1",
+                "--metadata",
+                "--manager",
+                "apt",
+                "-d",
+                "existing_dep",
+                "-c",
+                "existing_conf",
+                "--output",
+                "json",
+            ],
+        )
+
+    assert result.exit_code == 0, result.output
+    assert "Загружены метаданные" in result.output

tests/test_web_api.py

@@ -104,6 +104,7 @@ def test_maximize_success(client):
     assert r.status_code == 200
     body = r.get_json()
     assert "selected" in body or "result" in body
+    assert "metadata_fetched" in body
 
 
 def test_maximize_get_supported(client):