antfly-sdk 0.0.2.dev2__py3-none-any.whl

antfly/client_generated/models/path_edge_metadata.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="PathEdgeMetadata")
+
+
+@_attrs_define
+class PathEdgeMetadata:
+    """ """
+
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        path_edge_metadata = cls()
+
+        path_edge_metadata.additional_properties = d
+        return path_edge_metadata
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/path_find_request.py

@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.edge_direction import EdgeDirection
+from ..models.path_find_weight_mode import PathFindWeightMode
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PathFindRequest")
+
+
+@_attrs_define
+class PathFindRequest:
+    """
+    Attributes:
+        source (str): Source node key (base64-encoded)
+        target (str): Target node key (base64-encoded)
+        edge_types (list[str] | Unset): Filter by specific edge types
+        max_depth (int | Unset):  Default: 10.
+        weight_mode (PathFindWeightMode | Unset): Algorithm for path finding:
+            - min_hops: Shortest path by hop count (breadth-first search, ignores weights)
+            - max_weight: Path with maximum product of edge weights (strongest connection chain)
+            - min_weight: Path with minimum sum of edge weights (lowest cost route)
+        k (int | Unset):  Default: 1.
+        min_weight (float | Unset):
+        max_weight (float | Unset):
+        direction (EdgeDirection | Unset): Direction of edges to query:
+            - out: Outgoing edges from the node
+            - in: Incoming edges to the node
+            - both: Both outgoing and incoming edges
+    """
+
+    source: str
+    target: str
+    edge_types: list[str] | Unset = UNSET
+    max_depth: int | Unset = 10
+    weight_mode: PathFindWeightMode | Unset = UNSET
+    k: int | Unset = 1
+    min_weight: float | Unset = UNSET
+    max_weight: float | Unset = UNSET
+    direction: EdgeDirection | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        source = self.source
+
+        target = self.target
+
+        edge_types: list[str] | Unset = UNSET
+        if not isinstance(self.edge_types, Unset):
+            edge_types = self.edge_types
+
+        max_depth = self.max_depth
+
+        weight_mode: str | Unset = UNSET
+        if not isinstance(self.weight_mode, Unset):
+            weight_mode = self.weight_mode.value
+
+        k = self.k
+
+        min_weight = self.min_weight
+
+        max_weight = self.max_weight
+
+        direction: str | Unset = UNSET
+        if not isinstance(self.direction, Unset):
+            direction = self.direction.value
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "source": source,
+                "target": target,
+            }
+        )
+        if edge_types is not UNSET:
+            field_dict["edge_types"] = edge_types
+        if max_depth is not UNSET:
+            field_dict["max_depth"] = max_depth
+        if weight_mode is not UNSET:
+            field_dict["weight_mode"] = weight_mode
+        if k is not UNSET:
+            field_dict["k"] = k
+        if min_weight is not UNSET:
+            field_dict["min_weight"] = min_weight
+        if max_weight is not UNSET:
+            field_dict["max_weight"] = max_weight
+        if direction is not UNSET:
+            field_dict["direction"] = direction
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        source = d.pop("source")
+
+        target = d.pop("target")
+
+        edge_types = cast(list[str], d.pop("edge_types", UNSET))
+
+        max_depth = d.pop("max_depth", UNSET)
+
+        _weight_mode = d.pop("weight_mode", UNSET)
+        weight_mode: PathFindWeightMode | Unset
+        if isinstance(_weight_mode, Unset):
+            weight_mode = UNSET
+        else:
+            weight_mode = PathFindWeightMode(_weight_mode)
+
+        k = d.pop("k", UNSET)
+
+        min_weight = d.pop("min_weight", UNSET)
+
+        max_weight = d.pop("max_weight", UNSET)
+
+        _direction = d.pop("direction", UNSET)
+        direction: EdgeDirection | Unset
+        if isinstance(_direction, Unset):
+            direction = UNSET
+        else:
+            direction = EdgeDirection(_direction)
+
+        path_find_request = cls(
+            source=source,
+            target=target,
+            edge_types=edge_types,
+            max_depth=max_depth,
+            weight_mode=weight_mode,
+            k=k,
+            min_weight=min_weight,
+            max_weight=max_weight,
+            direction=direction,
+        )
+
+        path_find_request.additional_properties = d
+        return path_find_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/path_find_result.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.path_find_weight_mode import PathFindWeightMode
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.path import Path
+
+
+T = TypeVar("T", bound="PathFindResult")
+
+
+@_attrs_define
+class PathFindResult:
+    """
+    Attributes:
+        paths (list[Path] | Unset):
+        source (str | Unset):
+        target (str | Unset):
+        weight_mode (PathFindWeightMode | Unset): Algorithm for path finding:
+            - min_hops: Shortest path by hop count (breadth-first search, ignores weights)
+            - max_weight: Path with maximum product of edge weights (strongest connection chain)
+            - min_weight: Path with minimum sum of edge weights (lowest cost route)
+        paths_found (int | Unset):
+        search_time_ms (float | Unset):
+    """
+
+    paths: list[Path] | Unset = UNSET
+    source: str | Unset = UNSET
+    target: str | Unset = UNSET
+    weight_mode: PathFindWeightMode | Unset = UNSET
+    paths_found: int | Unset = UNSET
+    search_time_ms: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        paths: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.paths, Unset):
+            paths = []
+            for paths_item_data in self.paths:
+                paths_item = paths_item_data.to_dict()
+                paths.append(paths_item)
+
+        source = self.source
+
+        target = self.target
+
+        weight_mode: str | Unset = UNSET
+        if not isinstance(self.weight_mode, Unset):
+            weight_mode = self.weight_mode.value
+
+        paths_found = self.paths_found
+
+        search_time_ms = self.search_time_ms
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if paths is not UNSET:
+            field_dict["paths"] = paths
+        if source is not UNSET:
+            field_dict["source"] = source
+        if target is not UNSET:
+            field_dict["target"] = target
+        if weight_mode is not UNSET:
+            field_dict["weight_mode"] = weight_mode
+        if paths_found is not UNSET:
+            field_dict["paths_found"] = paths_found
+        if search_time_ms is not UNSET:
+            field_dict["search_time_ms"] = search_time_ms
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.path import Path
+
+        d = dict(src_dict)
+        _paths = d.pop("paths", UNSET)
+        paths: list[Path] | Unset = UNSET
+        if _paths is not UNSET:
+            paths = []
+            for paths_item_data in _paths:
+                paths_item = Path.from_dict(paths_item_data)
+
+                paths.append(paths_item)
+
+        source = d.pop("source", UNSET)
+
+        target = d.pop("target", UNSET)
+
+        _weight_mode = d.pop("weight_mode", UNSET)
+        weight_mode: PathFindWeightMode | Unset
+        if isinstance(_weight_mode, Unset):
+            weight_mode = UNSET
+        else:
+            weight_mode = PathFindWeightMode(_weight_mode)
+
+        paths_found = d.pop("paths_found", UNSET)
+
+        search_time_ms = d.pop("search_time_ms", UNSET)
+
+        path_find_result = cls(
+            paths=paths,
+            source=source,
+            target=target,
+            weight_mode=weight_mode,
+            paths_found=paths_found,
+            search_time_ms=search_time_ms,
+        )
+
+        path_find_result.additional_properties = d
+        return path_find_result
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/path_find_weight_mode.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class PathFindWeightMode(str, Enum):
+    MAX_WEIGHT = "max_weight"
+    MIN_HOPS = "min_hops"
+    MIN_WEIGHT = "min_weight"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/path_weight_mode.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+
+class PathWeightMode(str, Enum):
+    MAX_WEIGHT = "max_weight"
+    MIN_HOPS = "min_hops"
+    MIN_WEIGHT = "min_weight"
+
+    def __str__(self) -> str:
+        return str(self.value)

antfly/client_generated/models/pattern_edge_step.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import Any, TypeVar, cast
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.edge_direction import EdgeDirection
+from ..types import UNSET, Unset
+
+T = TypeVar("T", bound="PatternEdgeStep")
+
+
+@_attrs_define
+class PatternEdgeStep:
+    """Edge constraints in a pattern step
+
+    Attributes:
+        types (list[str] | Unset): Edge types to traverse (empty = any)
+        direction (EdgeDirection | Unset): Direction of edges to query:
+            - out: Outgoing edges from the node
+            - in: Incoming edges to the node
+            - both: Both outgoing and incoming edges
+        min_hops (int | Unset): Minimum number of hops (1 = direct edge) Default: 1.
+        max_hops (int | Unset): Maximum number of hops (>1 = variable-length path) Default: 1.
+        min_weight (float | Unset): Minimum edge weight filter
+        max_weight (float | Unset): Maximum edge weight filter
+    """
+
+    types: list[str] | Unset = UNSET
+    direction: EdgeDirection | Unset = UNSET
+    min_hops: int | Unset = 1
+    max_hops: int | Unset = 1
+    min_weight: float | Unset = UNSET
+    max_weight: float | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        types: list[str] | Unset = UNSET
+        if not isinstance(self.types, Unset):
+            types = self.types
+
+        direction: str | Unset = UNSET
+        if not isinstance(self.direction, Unset):
+            direction = self.direction.value
+
+        min_hops = self.min_hops
+
+        max_hops = self.max_hops
+
+        min_weight = self.min_weight
+
+        max_weight = self.max_weight
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if types is not UNSET:
+            field_dict["types"] = types
+        if direction is not UNSET:
+            field_dict["direction"] = direction
+        if min_hops is not UNSET:
+            field_dict["min_hops"] = min_hops
+        if max_hops is not UNSET:
+            field_dict["max_hops"] = max_hops
+        if min_weight is not UNSET:
+            field_dict["min_weight"] = min_weight
+        if max_weight is not UNSET:
+            field_dict["max_weight"] = max_weight
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        types = cast(list[str], d.pop("types", UNSET))
+
+        _direction = d.pop("direction", UNSET)
+        direction: EdgeDirection | Unset
+        if isinstance(_direction, Unset):
+            direction = UNSET
+        else:
+            direction = EdgeDirection(_direction)
+
+        min_hops = d.pop("min_hops", UNSET)
+
+        max_hops = d.pop("max_hops", UNSET)
+
+        min_weight = d.pop("min_weight", UNSET)
+
+        max_weight = d.pop("max_weight", UNSET)
+
+        pattern_edge_step = cls(
+            types=types,
+            direction=direction,
+            min_hops=min_hops,
+            max_hops=max_hops,
+            min_weight=min_weight,
+            max_weight=max_weight,
+        )
+
+        pattern_edge_step.additional_properties = d
+        return pattern_edge_step
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/pattern_match.py

@@ -0,0 +1,98 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.path_edge import PathEdge
+    from ..models.pattern_match_bindings import PatternMatchBindings
+
+
+T = TypeVar("T", bound="PatternMatch")
+
+
+@_attrs_define
+class PatternMatch:
+    """A single match from a pattern query
+
+    Attributes:
+        bindings (PatternMatchBindings | Unset): Map of alias to matched node
+        path (list[PathEdge] | Unset): Edges traversed in this match
+    """
+
+    bindings: PatternMatchBindings | Unset = UNSET
+    path: list[PathEdge] | Unset = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        bindings: dict[str, Any] | Unset = UNSET
+        if not isinstance(self.bindings, Unset):
+            bindings = self.bindings.to_dict()
+
+        path: list[dict[str, Any]] | Unset = UNSET
+        if not isinstance(self.path, Unset):
+            path = []
+            for path_item_data in self.path:
+                path_item = path_item_data.to_dict()
+                path.append(path_item)
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update({})
+        if bindings is not UNSET:
+            field_dict["bindings"] = bindings
+        if path is not UNSET:
+            field_dict["path"] = path
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.path_edge import PathEdge
+        from ..models.pattern_match_bindings import PatternMatchBindings
+
+        d = dict(src_dict)
+        _bindings = d.pop("bindings", UNSET)
+        bindings: PatternMatchBindings | Unset
+        if isinstance(_bindings, Unset):
+            bindings = UNSET
+        else:
+            bindings = PatternMatchBindings.from_dict(_bindings)
+
+        _path = d.pop("path", UNSET)
+        path: list[PathEdge] | Unset = UNSET
+        if _path is not UNSET:
+            path = []
+            for path_item_data in _path:
+                path_item = PathEdge.from_dict(path_item_data)
+
+                path.append(path_item)
+
+        pattern_match = cls(
+            bindings=bindings,
+            path=path,
+        )
+
+        pattern_match.additional_properties = d
+        return pattern_match
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

antfly/client_generated/models/pattern_match_bindings.py

@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+    from ..models.graph_result_node import GraphResultNode
+
+
+T = TypeVar("T", bound="PatternMatchBindings")
+
+
+@_attrs_define
+class PatternMatchBindings:
+    """Map of alias to matched node"""
+
+    additional_properties: dict[str, GraphResultNode] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+
+        field_dict: dict[str, Any] = {}
+        for prop_name, prop in self.additional_properties.items():
+            field_dict[prop_name] = prop.to_dict()
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.graph_result_node import GraphResultNode
+
+        d = dict(src_dict)
+        pattern_match_bindings = cls()
+
+        additional_properties = {}
+        for prop_name, prop_dict in d.items():
+            additional_property = GraphResultNode.from_dict(prop_dict)
+
+            additional_properties[prop_name] = additional_property
+
+        pattern_match_bindings.additional_properties = additional_properties
+        return pattern_match_bindings
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> GraphResultNode:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: GraphResultNode) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties