iris-pex-embedded-python 3.7.2b2__py3-none-any.whl → 4.0.0__py3-none-any.whl

iop/production/diff.py

@@ -0,0 +1,327 @@
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING, Any
+
+from .common import PRODUCTION_SETTING_FIELDS, _bool_text, _text_value
+from .types import (
+    GraphEdge,
+    ProductionDiff,
+    ProductionDiffEntry,
+    _canonical_value,
+)
+
+if TYPE_CHECKING:
+    from .component import ComponentRef
+    from .model import Production
+
+
+def _diff_productions(
+    desired: Production,
+    current: Production,
+    *,
+    include_graph_metadata: bool = False,
+) -> ProductionDiff:
+    changes: list[ProductionDiffEntry] = []
+    warnings = _diff_warnings(desired, current)
+
+    if current.name != desired.name:
+        changes.append(
+            ProductionDiffEntry(
+                action="change",
+                kind="production",
+                path="production.name",
+                before=current.name,
+                after=desired.name,
+            )
+        )
+
+    _diff_mapping_values(
+        changes,
+        kind="production",
+        base_path="production",
+        before=_production_signature(current),
+        after=_production_signature(desired),
+    )
+    _diff_items(changes, desired=desired, current=current)
+    _diff_connections(
+        changes,
+        desired=desired,
+        current=current,
+        include_graph_metadata=include_graph_metadata,
+    )
+
+    return ProductionDiff(
+        production_name=desired.name,
+        changes=tuple(changes),
+        warnings=tuple(warnings),
+    )
+
+
+def _diff_warnings(desired: Production, current: Production) -> list[str]:
+    warnings = []
+    warnings.extend(f"desired: {warning}" for warning in desired.graph().warnings)
+    warnings.extend(f"current: {warning}" for warning in current.graph().warnings)
+    return warnings
+
+
+def _production_signature(production: Production) -> dict[str, Any]:
+    signature = {
+        "testing_enabled": _bool_text(production.testing_enabled),
+        "log_general_trace_events": _bool_text(production.log_general_trace_events),
+        "actor_pool_size": _text_value(production.actor_pool_size),
+        "description": production.description,
+    }
+    signature.update(
+        {
+            field_name: _text_value(getattr(production, field_name))
+            for field_name in PRODUCTION_SETTING_FIELDS
+        }
+    )
+    return signature
+
+
+def _item_signatures(production: Production) -> dict[str, dict[str, Any]]:
+    return {item.name: _item_signature(item) for item in production.items}
+
+
+def _item_signature(item: ComponentRef) -> dict[str, Any]:
+    return {
+        "class_name": item.class_name or "",
+        "category": item.category,
+        "pool_size": _text_value(item.pool_size),
+        "enabled": _bool_text(item.enabled),
+        "foreground": _bool_text(item.foreground),
+        "comment": item.comment,
+        "log_trace_events": _bool_text(item.log_trace_events),
+        "schedule": item.schedule,
+        "host_settings": _settings_signature(item.host_settings),
+        "adapter_settings": _settings_signature(item.adapter_settings),
+        "other_settings": _canonical_value(item.other_settings),
+    }
+
+
+def _settings_signature(settings: dict[str, Any]) -> dict[str, str]:
+    return {key: _text_value(settings[key]) for key in sorted(settings)}
+
+
+def _diff_items(
+    changes: list[ProductionDiffEntry],
+    *,
+    desired: Production,
+    current: Production,
+) -> None:
+    desired_items = _item_signatures(desired)
+    current_items = _item_signatures(current)
+
+    for item_name in sorted(current_items.keys() - desired_items.keys()):
+        changes.append(
+            ProductionDiffEntry(
+                action="remove",
+                kind="item",
+                path=f"items.{item_name}",
+                before=current_items[item_name],
+            )
+        )
+
+    for item_name in sorted(desired_items.keys() - current_items.keys()):
+        changes.append(
+            ProductionDiffEntry(
+                action="add",
+                kind="item",
+                path=f"items.{item_name}",
+                after=desired_items[item_name],
+            )
+        )
+
+    for item_name in sorted(desired_items.keys() & current_items.keys()):
+        _diff_item_fields(
+            changes,
+            item_name=item_name,
+            before=current_items[item_name],
+            after=desired_items[item_name],
+        )
+
+
+def _diff_item_fields(
+    changes: list[ProductionDiffEntry],
+    *,
+    item_name: str,
+    before: dict[str, Any],
+    after: dict[str, Any],
+) -> None:
+    scalar_fields = [
+        "class_name",
+        "category",
+        "pool_size",
+        "enabled",
+        "foreground",
+        "comment",
+        "log_trace_events",
+        "schedule",
+    ]
+    _diff_mapping_values(
+        changes,
+        kind="item",
+        base_path=f"items.{item_name}",
+        before={field: before[field] for field in scalar_fields},
+        after={field: after[field] for field in scalar_fields},
+    )
+    _diff_mapping_values(
+        changes,
+        kind="setting",
+        base_path=f"items.{item_name}.settings.Host",
+        before=before["host_settings"],
+        after=after["host_settings"],
+    )
+    _diff_mapping_values(
+        changes,
+        kind="setting",
+        base_path=f"items.{item_name}.settings.Adapter",
+        before=before["adapter_settings"],
+        after=after["adapter_settings"],
+    )
+    if before["other_settings"] != after["other_settings"]:
+        changes.append(
+            ProductionDiffEntry(
+                action="change",
+                kind="setting",
+                path=f"items.{item_name}.settings.Other",
+                before=before["other_settings"],
+                after=after["other_settings"],
+            )
+        )
+
+
+def _diff_mapping_values(
+    changes: list[ProductionDiffEntry],
+    *,
+    kind: str,
+    base_path: str,
+    before: dict[str, Any],
+    after: dict[str, Any],
+) -> None:
+    for key in sorted(before.keys() - after.keys()):
+        changes.append(
+            ProductionDiffEntry(
+                action="remove",
+                kind=kind,
+                path=f"{base_path}.{key}",
+                before=before[key],
+            )
+        )
+    for key in sorted(after.keys() - before.keys()):
+        changes.append(
+            ProductionDiffEntry(
+                action="add",
+                kind=kind,
+                path=f"{base_path}.{key}",
+                after=after[key],
+            )
+        )
+    for key in sorted(before.keys() & after.keys()):
+        if before[key] != after[key]:
+            changes.append(
+                ProductionDiffEntry(
+                    action="change",
+                    kind=kind,
+                    path=f"{base_path}.{key}",
+                    before=before[key],
+                    after=after[key],
+                )
+            )
+
+
+def _diff_connections(
+    changes: list[ProductionDiffEntry],
+    *,
+    desired: Production,
+    current: Production,
+    include_graph_metadata: bool = False,
+) -> None:
+    desired_connections = _connection_signature(
+        desired,
+        include_graph_metadata=include_graph_metadata,
+    )
+    current_connections = _connection_signature(
+        current,
+        include_graph_metadata=include_graph_metadata,
+    )
+
+    for source in sorted(current_connections.keys() - desired_connections.keys()):
+        changes.append(
+            ProductionDiffEntry(
+                action="remove",
+                kind="connection",
+                path=f"connections.{_connection_source_path(source)}",
+                before=current_connections[source],
+            )
+        )
+    for source in sorted(desired_connections.keys() - current_connections.keys()):
+        changes.append(
+            ProductionDiffEntry(
+                action="add",
+                kind="connection",
+                path=f"connections.{_connection_source_path(source)}",
+                after=desired_connections[source],
+            )
+        )
+    for source in sorted(desired_connections.keys() & current_connections.keys()):
+        before = current_connections[source]
+        after = desired_connections[source]
+        if before != after:
+            changes.append(
+                ProductionDiffEntry(
+                    action="change",
+                    kind="connection",
+                    path=f"connections.{_connection_source_path(source)}",
+                    before=before,
+                    after=after,
+                )
+            )
+
+
+def _connection_signature(
+    production: Production,
+    *,
+    include_graph_metadata: bool = False,
+) -> dict[tuple[str, str], list[Any]]:
+    if include_graph_metadata:
+        detailed_connections: dict[tuple[str, str], list[dict[str, Any]]] = {}
+        for edge in production.graph().edges:
+            source = (edge.source_item, edge.source_target_setting)
+            detailed_connections.setdefault(source, []).append(_edge_diff_value(edge))
+        return {
+            source: sorted(
+                values,
+                key=lambda value: json.dumps(value, sort_keys=True),
+            )
+            for source, values in sorted(detailed_connections.items())
+        }
+
+    connections: dict[tuple[str, str], set[str]] = {}
+    for edge in production.graph().edges:
+        source = (edge.source_item, edge.source_target_setting)
+        connections.setdefault(source, set()).add(edge.target)
+    return {
+        source: list(sorted(targets))
+        for source, targets in sorted(connections.items())
+    }
+
+
+def _edge_diff_value(edge: GraphEdge) -> dict[str, Any]:
+    data: dict[str, Any] = {
+        "target": edge.target,
+        "origin": edge.origin,
+        "interaction": edge.interaction,
+    }
+    if edge.metadata:
+        data["metadata"] = _canonical_value(edge.metadata)
+    return data
+
+
+def _connection_source_path(source: tuple[str, str]) -> str:
+    source_item, source_target_setting = source
+    if source_target_setting:
+        return f"{source_item}.{source_target_setting}"
+    return source_item

iop/production/import_.py

@@ -0,0 +1,296 @@
+from __future__ import annotations
+
+from typing import Any
+
+from .common import PRODUCTION_SETTING_FIELDS_BY_IRIS, _text_value
+
+
+def _as_list(value: Any) -> list[Any]:
+    if value is None:
+        return []
+    if isinstance(value, list):
+        return value
+    return [value]
+
+
+def _production_payload(data: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+    if not isinstance(data, dict) or not data:
+        raise ValueError("Production data must be a non-empty dictionary.")
+
+    if "Production" in data:
+        production_data = data["Production"]
+        if not isinstance(production_data, dict):
+            raise ValueError("Production data must be a dictionary.")
+        production_name = production_data.get("@Name") or "Production"
+        return production_name, production_data
+
+    production_name = next(iter(data.keys()))
+    production_data = data[production_name]
+    if not isinstance(production_data, dict):
+        raise ValueError("Production data must be a dictionary.")
+    production_name = production_data.get("@Name") or production_name
+    return production_name, production_data
+
+
+def _split_settings(
+    settings: Any,
+) -> tuple[dict[str, Any], dict[str, Any], list[dict[str, Any]]]:
+    host_settings: dict[str, Any] = {}
+    adapter_settings: dict[str, Any] = {}
+    other_settings: list[dict[str, Any]] = []
+
+    for setting in _as_list(settings):
+        if not isinstance(setting, dict):
+            continue
+        target = setting.get("@Target", "Host")
+        name = setting.get("@Name", "")
+        value = setting.get("#text", "")
+        if target in ("", "Host"):
+            host_settings[name] = value
+        elif target == "Adapter":
+            adapter_settings[name] = value
+        else:
+            other_settings.append(dict(setting))
+    return host_settings, adapter_settings, other_settings
+
+
+def _split_production_settings(settings: Any) -> dict[str, Any]:
+    values: dict[str, Any] = {}
+    for setting in _as_list(settings):
+        if not isinstance(setting, dict):
+            continue
+        target = setting.get("@Target", "")
+        if target not in ("", "Production"):
+            continue
+        iris_name = str(setting.get("@Name", ""))
+        field_name = PRODUCTION_SETTING_FIELDS_BY_IRIS.get(iris_name)
+        if field_name:
+            values[field_name] = setting.get("#text", "")
+    return values
+
+
+def _normalize_connections(
+    connections: Any,
+) -> tuple[dict[str, list[dict[str, Any]]], set[str], list[str]]:
+    connection_map: dict[str, list[dict[str, Any]]] = {}
+    runtime_sources: set[str] = set()
+    warnings: list[str] = []
+
+    if connections is None:
+        return connection_map, runtime_sources, warnings
+
+    if isinstance(connections, dict):
+        warnings.extend(str(value) for value in _as_list(connections.get("warnings")))
+        if "items" in connections:
+            for item in _as_list(connections.get("items")):
+                if not isinstance(item, dict):
+                    continue
+                source = (
+                    item.get("item")
+                    or item.get("name")
+                    or item.get("source_item")
+                    or ""
+                )
+                if not source:
+                    continue
+                item_warnings = [value for value in _as_list(item.get("warnings")) if value]
+                warnings.extend(
+                    f"{source}: {value}"
+                    for value in item_warnings
+                )
+                discovered = False
+                for target in _as_list(item.get("connections")):
+                    normalized = _normalize_connection_target(target)
+                    if normalized is not None:
+                        discovered = True
+                        connection_map.setdefault(source, []).append(normalized)
+                for edge in _as_list(item.get("edges")):
+                    normalized = _normalize_connection_target(edge)
+                    if normalized is not None:
+                        discovered = True
+                        connection_map.setdefault(source, []).append(normalized)
+                if not item_warnings or discovered:
+                    runtime_sources.add(source)
+            return connection_map, runtime_sources, warnings
+
+        for source, targets in connections.items():
+            if source in ("production", "warnings"):
+                continue
+            runtime_sources.add(str(source))
+            for target in _as_list(targets):
+                normalized = _normalize_connection_target(target)
+                if normalized is not None:
+                    connection_map.setdefault(str(source), []).append(normalized)
+        return connection_map, runtime_sources, warnings
+
+    if isinstance(connections, list):
+        for edge in connections:
+            if not isinstance(edge, dict):
+                continue
+            source = edge.get("source_item") or edge.get("item") or ""
+            if not source and "." in str(edge.get("source", "")):
+                source, _, source_target_setting = str(edge["source"]).rpartition(".")
+                edge = {**edge, "source_target_setting": source_target_setting}
+            if not source:
+                continue
+            runtime_sources.add(str(source))
+            normalized = _normalize_connection_target(edge)
+            if normalized is not None:
+                connection_map.setdefault(str(source), []).append(normalized)
+        return connection_map, runtime_sources, warnings
+
+    warnings.append(f"Ignoring invalid runtime connections: {connections!r}")
+    return connection_map, runtime_sources, warnings
+
+
+def _normalize_runtime_item_metadata(connections: Any) -> dict[str, dict[str, str]]:
+    metadata: dict[str, dict[str, str]] = {}
+    if not isinstance(connections, dict):
+        return metadata
+    for item in _as_list(connections.get("items")):
+        if not isinstance(item, dict):
+            continue
+        item_name = (
+            item.get("item")
+            or item.get("name")
+            or item.get("source_item")
+            or ""
+        )
+        if not item_name:
+            continue
+        adapter_class_name = (
+            item.get("adapter_class_name")
+            or item.get("adapter")
+            or item.get("AdapterClassName")
+            or item.get("Adapter")
+            or ""
+        )
+        item_metadata: dict[str, str] = {}
+        if adapter_class_name:
+            item_metadata["adapter_class_name"] = str(adapter_class_name)
+        kind = item.get("kind") or item.get("type") or item.get("role") or ""
+        if kind:
+            item_metadata["kind"] = str(kind)
+        if item.get("iop") is not None:
+            item_metadata["iop"] = str(item.get("iop"))
+        module = item.get("module") or item.get("%module") or ""
+        if module:
+            item_metadata["%module"] = str(module)
+        classname = item.get("classname") or item.get("%classname") or ""
+        if classname:
+            item_metadata["%classname"] = str(classname)
+        classpaths = item.get("classpaths") or item.get("%classpaths") or ""
+        if classpaths:
+            item_metadata["%classpaths"] = str(classpaths)
+        if item_metadata:
+            metadata[str(item_name)] = item_metadata
+    return metadata
+
+
+def _normalize_connection_target(value: Any) -> dict[str, Any] | None:
+    if isinstance(value, str):
+        if not value:
+            return None
+        return {"target": value, "source_target_setting": ""}
+    if not isinstance(value, dict):
+        return None
+    target = value.get("target") or value.get("name") or value.get("to") or ""
+    if not target:
+        return None
+    source_target_setting = (
+        value.get("source_target_setting")
+        or value.get("source_port")
+        or value.get("port")
+        or ""
+    )
+    metadata = dict(value.get("metadata") or {})
+    known_keys = {
+        "target",
+        "name",
+        "to",
+        "source_target_setting",
+        "source_port",
+        "port",
+        "interaction",
+        "metadata",
+        "logical_name",
+    }
+    for key, item in value.items():
+        if key not in known_keys and item is not None:
+            metadata.setdefault(str(key), item)
+    normalized: dict[str, Any] = {
+        "target": str(target),
+        "source_target_setting": str(source_target_setting),
+    }
+    if value.get("interaction"):
+        normalized["interaction"] = str(value["interaction"])
+    if metadata:
+        normalized["metadata"] = metadata
+    return normalized
+
+
+def _normalize_queue_info(value: Any) -> tuple[dict[str, dict[str, Any]], list[str]]:
+    queue_map: dict[str, dict[str, Any]] = {}
+    warnings: list[str] = []
+    if value is None:
+        return queue_map, warnings
+
+    if isinstance(value, dict):
+        warnings.extend(str(item) for item in _as_list(value.get("warnings")) if item)
+        if "items" in value:
+            for item in _as_list(value.get("items")):
+                normalized = _normalize_queue_item(item)
+                if normalized is None:
+                    continue
+                item_name, info = normalized
+                queue_map[item_name] = info
+            return queue_map, warnings
+
+        for item_name, info in value.items():
+            if item_name in ("production", "warnings"):
+                continue
+            if isinstance(info, dict):
+                queue_map[str(item_name)] = dict(info)
+        return queue_map, warnings
+
+    if isinstance(value, list):
+        for item in value:
+            normalized = _normalize_queue_item(item)
+            if normalized is None:
+                continue
+            item_name, info = normalized
+            queue_map[item_name] = info
+        return queue_map, warnings
+
+    warnings.append(f"Ignoring invalid queue info: {value!r}")
+    return queue_map, warnings
+
+
+def _normalize_queue_item(value: Any) -> tuple[str, dict[str, Any]] | None:
+    if not isinstance(value, dict):
+        return None
+    item_name = value.get("item") or value.get("name") or value.get("queue_name") or ""
+    if not item_name:
+        return None
+    info = dict(value)
+    info.pop("item", None)
+    info.setdefault("queue_name", info.pop("name", item_name))
+    return str(item_name), info
+
+
+def _setting_targets(value: Any) -> list[str]:
+    text = _text_value(value).strip()
+    if not text:
+        return []
+    return [part.strip() for part in text.split(",") if part.strip()]
+
+
+def _matching_host_setting(component: Any, target_name: str) -> str:
+    for name, value in component.host_settings.items():
+        if target_name in _setting_targets(value):
+            return name
+    return ""
+
+
+def _is_internal_runtime_target(target_name: str) -> bool:
+    return target_name in {"Ens.Alert", "Ens.ScheduleHandler"}