lionagi 0.17.10__py3-none-any.whl → 0.18.0__py3-none-any.whl

lionagi/operations/types.py

@@ -1,27 +1,122 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
-from .brainstorm.brainstorm import brainstorm
-from .chat.chat import chat
-from .communicate.communicate import communicate
-from .instruct.instruct import instruct
-from .interpret.interpret import interpret
-from .operate.operate import operate
-from .parse.parse import parse
-from .plan.plan import plan
-from .ReAct.ReAct import ReAct
-from .select.select import select
-
-__all__ = (
-    "brainstorm",
-    "plan",
-    "select",
-    "chat",
-    "communicate",
-    "instruct",
-    "interpret",
-    "operate",
-    "parse",
-    "ReAct",
-)
+from dataclasses import dataclass
+from enum import Enum
+from typing import ClassVar, Literal
+
+from pydantic import BaseModel, JsonValue
+
+from lionagi.ln._async_call import AlcallParams
+from lionagi.ln.fuzzy import FuzzyMatchKeysParams
+from lionagi.ln.types import Params
+from lionagi.protocols.action.tool import ToolRef
+from lionagi.protocols.types import ID, SenderRecipient
+from lionagi.service.imodel import iModel
+
+HandleValidation = Literal["raise", "return_value", "return_none"]
+
+
+class ContextPolicy(str, Enum):
+    """Policy for merging prompt context across morphism invocations.
+
+    Attributes:
+        REPLACE: New context completely replaces existing context
+        EXTEND: New context is appended to existing context
+        DEDUP: New context is appended but duplicates are removed
+    """
+
+    REPLACE = "replace"
+    EXTEND = "extend"
+    DEDUP = "dedup"
+
+
+@dataclass(slots=True, frozen=True, init=False)
+class MorphParam(Params):
+    """Base class for morphism parameters (invariants).
+
+    MorphParams represent the invariant properties that define a morphism
+    in LionAGI's categorical framework. They are frozen (immutable) and
+    hashable, enabling reproducible operations and efficient caching.
+
+    Morphisms are the fundamental abstraction in LionAGI - they represent
+    transformations between message states with well-defined parameters.
+    """
+
+    _none_as_sentinel: ClassVar[bool] = True
+
+
+@dataclass(slots=True, frozen=True, init=False)
+class ChatParam(MorphParam):
+    """Parameters for chat/communicate morphism.
+
+    Defines the invariant properties of a chat operation, including
+    guidance, context, response format, and LLM-visible content.
+
+    Note: 'context' field contains prompt context (LLM-visible facts).
+    This gets mapped to InstructionContent.prompt_context during message creation.
+    """
+
+    _none_as_sentinel: ClassVar[bool] = True
+    guidance: JsonValue = None
+    context: JsonValue = None
+    sender: SenderRecipient = None
+    recipient: SenderRecipient = None
+    response_format: type[BaseModel] | dict = None
+    progression: ID.RefSeq = None
+    tool_schemas: list[dict] = None
+    images: list = None
+    image_detail: Literal["low", "high", "auto"] = None
+    plain_content: str = None
+    include_token_usage_to_model: bool = False
+    imodel: iModel = None
+    imodel_kw: dict = None
+
+
+@dataclass(slots=True, frozen=True, init=False)
+class InterpretParam(MorphParam):
+    """Parameters for interpret morphism.
+
+    Defines interpretation style, domain, and sample writing for
+    transforming content according to specified guidelines.
+    """
+
+    _none_as_sentinel: ClassVar[bool] = True
+    domain: str = None
+    style: str = None
+    sample_writing: str = None
+    imodel: iModel = None
+    imodel_kw: dict = None
+
+
+@dataclass(slots=True, frozen=True, init=False)
+class ParseParam(MorphParam):
+    """Parameters for parse morphism.
+
+    Defines parsing behavior including response format validation,
+    fuzzy matching, and error handling strategies.
+    """
+
+    _none_as_sentinel: ClassVar[bool] = True
+    response_format: type[BaseModel] | dict = None
+    fuzzy_match_params: FuzzyMatchKeysParams | dict = None
+    handle_validation: HandleValidation = "raise"
+    alcall_params: AlcallParams | dict = None
+    imodel: iModel = None
+    imodel_kw: dict = None
+
+
+@dataclass(slots=True, frozen=True, init=False)
+class ActionParam(MorphParam):
+    """Parameters for action/tool execution morphism.
+
+    Defines tool execution strategy, error handling, and verbosity
+    for action-based operations.
+    """
+
+    _none_as_sentinel: ClassVar[bool] = True
+    action_call_params: AlcallParams = None
+    tools: ToolRef = None
+    strategy: Literal["concurrent", "sequential"] = "concurrent"
+    suppress_errors: bool = True
+    verbose_action: bool = False

lionagi/operations/utils.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from typing import TYPE_CHECKING

lionagi/protocols/__init__.py

@@ -1,3 +1,2 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0

lionagi/protocols/_concepts.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from abc import ABC, abstractmethod

lionagi/protocols/action/__init__.py

@@ -1,3 +1,2 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0

lionagi/protocols/action/function_calling.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 import asyncio
@@ -116,29 +115,13 @@ class FunctionCalling(Event):
             self.execution.status = EventStatus.FAILED
             self.execution.error = str(e)
 
-    def __str__(self) -> str:
-        """Returns a string representation of the function call.
-
-        Returns:
-            A string in the format "function_name(arguments)".
-        """
-        return f"{self.func_tool.function}({self.arguments})"
-
-    def __repr__(self) -> str:
-        """Returns a detailed string representation of the function call.
-
-        Returns:
-            A string containing the class name and key attributes.
-        """
-        return f"FunctionCalling(function={self.func_tool.function}, arguments={self.arguments})"
-
-    def to_dict(self) -> dict[str, Any]:
+    def to_dict(self, *args, **kw) -> dict[str, Any]:
         """Convert instance to dictionary.
 
         Returns:
             dict[str, Any]: Dictionary representation of the instance.
         """
-        dict_ = super().to_dict()
+        dict_ = super().to_dict(*args, **kw)
         dict_["function"] = self.function
         dict_["arguments"] = self.arguments
         return dict_

lionagi/protocols/action/manager.py

@@ -1,7 +1,7 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
+import logging
 from typing import Any
 
 from lionagi.fields.action import ActionRequestModel
@@ -348,16 +348,46 @@ class ActionManager(Manager):
                 if request_options and tool.name in request_options:
                     tool_request_options = request_options[tool.name]
 
+                # Extract schema from FastMCP tool and convert to lionagi format
+                tool_schema = None
                 try:
-                    # Create tool with request_options for Pydantic validation
+                    if (
+                        hasattr(tool, "inputSchema")
+                        and tool.inputSchema is not None
+                        and isinstance(tool.inputSchema, dict)
+                    ):
+                        tool_schema = {
+                            "type": "function",
+                            "function": {
+                                "name": tool.name,
+                                "description": (
+                                    tool.description
+                                    if hasattr(tool, "description")
+                                    else None
+                                ),
+                                "parameters": tool.inputSchema,
+                            },
+                        }
+                except Exception as schema_error:
+                    # If schema extraction fails, let Tool auto-generate from function signature
+                    logging.warning(
+                        f"Could not extract schema for {tool.name}: {schema_error}"
+                    )
+                    tool_schema = None
+
+                try:
+                    # Create tool with auto-populated schema from MCP discovery
                     tool_obj = Tool(
                         mcp_config=mcp_config,
                         request_options=tool_request_options,
+                        tool_schema=tool_schema,
                     )
                     self.register_tool(tool_obj, update=update)
                     registered_tools.append(tool.name)
                 except Exception as e:
-                    print(f"Warning: Failed to register tool {tool.name}: {e}")
+                    logging.warning(
+                        f"Failed to register tool {tool.name}: {e}"
+                    )
 
         return registered_tools
 

lionagi/protocols/action/tool.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 

lionagi/protocols/contracts.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 """V1 Observable Protocol for gradual evolution.

lionagi/protocols/forms/__init__.py

@@ -1,3 +1,2 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0

lionagi/protocols/forms/base.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from typing import Any, Literal

lionagi/protocols/forms/flow.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from pydantic import BaseModel, ConfigDict, Field

lionagi/protocols/forms/form.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from typing import Any

lionagi/protocols/forms/report.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from pydantic import Field

lionagi/protocols/generic/__init__.py

@@ -1,3 +1,2 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0

lionagi/protocols/generic/element.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations
@@ -48,22 +47,13 @@ class IDType:
     __slots__ = ("_id",)
 
     def __init__(self, id: UUID) -> None:
-        """Initializes an IDType instance.
-
-        Args:
-            id (UUID): A UUID object (version 4 preferred).
-        """
+        """Initializes an IDType instance."""
         self._id = id
 
     @classmethod
     def validate(cls, value: str | UUID | IDType) -> IDType:
         """Validates and converts a value into an IDType.
 
-        Args:
-            value (str | UUID | IDType):
-                A string representing a UUID, a UUID instance, or another
-                IDType instance.
-
         Returns:
             IDType: The validated IDType object.
 
@@ -105,9 +95,6 @@ class IDType:
     def __eq__(self, other: Any) -> bool:
         """Checks equality with another IDType based on UUID value.
 
-        Args:
-            other (Any): Another object for equality comparison.
-
         Returns:
             bool: True if both have the same underlying UUID; False otherwise.
         """
@@ -190,17 +177,7 @@ class Element(BaseModel, Observable):
     def _coerce_created_at(
         cls, val: float | dt.datetime | str | None
     ) -> float:
-        """Coerces `created_at` to a float-based timestamp.
-
-        Args:
-            val (float | datetime | str | None): The initial creation time value.
-
-        Returns:
-            float: A float representing Unix epoch time in seconds.
-
-        Raises:
-            ValueError: If `val` cannot be converted to a float timestamp.
-        """
+        """Coerces `created_at` to a float-based timestamp."""
         if val is None:
             return ln.now_utc().timestamp()
         if isinstance(val, float):
@@ -235,36 +212,17 @@ class Element(BaseModel, Observable):
 
     @field_validator("id", mode="before")
     def _ensure_idtype(cls, val: IDType | UUID | str) -> IDType:
-        """Ensures `id` is validated as an IDType.
-
-        Args:
-            val (IDType | UUID | str):
-                The incoming value for the `id` field.
-
-        Returns:
-            IDType: A validated IDType object.
-        """
+        """Ensures `id` is validated as an IDType."""
         return IDType.validate(val)
 
     @field_serializer("id")
     def _serialize_id_type(self, val: IDType) -> str:
-        """Serializes the `id` field to a string.
-
-        Args:
-            val (IDType): The IDType object to be serialized.
-
-        Returns:
-            str: The string representation of the UUID.
-        """
+        """Serializes the `id` field to a string."""
         return str(val)
 
     @property
     def created_datetime(self) -> dt.datetime:
-        """Returns the creation time as a datetime object.
-
-        Returns:
-            datetime: The creation time in UTC.
-        """
+        """Returns the creation time as a datetime object."""
         return dt.datetime.fromtimestamp(self.created_at, tz=dt.timezone.utc)
 
     def __eq__(self, other: Any) -> bool:
@@ -294,23 +252,25 @@ class Element(BaseModel, Observable):
             return str(cls).split("'")[1]
         return cls.__name__
 
-    def _to_dict(self) -> dict:
-        dict_ = self.model_dump()
+    def _to_dict(self, **kw) -> dict:
+        """kw for model_dump."""
+        dict_ = self.model_dump(**kw)
         dict_["metadata"].update({"lion_class": self.class_name(full=True)})
         return {k: v for k, v in dict_.items() if ln.not_sentinel(v)}
 
     def to_dict(
-        self, mode: Literal["python", "json", "db"] = "python"
+        self, mode: Literal["python", "json", "db"] = "python", **kw
     ) -> dict:
         """Converts this Element to a dictionary."""
         if mode == "python":
-            return self._to_dict()
+            return self._to_dict(**kw)
         if mode == "json":
-            return orjson.loads(self.to_json(decode=False))
+            return orjson.loads(self.to_json(decode=False, **kw))
         if mode == "db":
-            dict_ = orjson.loads(self.to_json(decode=False))
+            dict_ = orjson.loads(self.to_json(decode=False, **kw))
             dict_["node_metadata"] = dict_.pop("metadata", {})
             return dict_
+        raise ValueError(f"Unsupported mode: {mode}")
 
     @classmethod
     def from_dict(cls, data: dict) -> Element:
@@ -353,9 +313,10 @@ class Element(BaseModel, Observable):
         data["metadata"] = metadata
         return cls.model_validate(data)
 
-    def to_json(self, decode: bool = True) -> str:
+    def to_json(self, decode: bool = True, **kw) -> str:
         """Converts this Element to a JSON string."""
-        dict_ = self._to_dict()
+        kw.pop("mode", None)
+        dict_ = self._to_dict(**kw)
         return ln.json_dumps(
             dict_, default=DEFAULT_ELEMENT_SERIALIZER, decode=decode
         )
@@ -383,9 +344,6 @@ def validate_order(order: Any) -> list[IDType]:
     (e.g., a single Element, a list of Elements, a dictionary with ID keys,
     or a nested structure) and returns a flat list of IDType objects.
 
-    Args:
-        order (Any): A potentially nested structure of items to be ordered.
-
     Returns:
         list[IDType]: A flat list of validated IDType objects.
 
@@ -458,9 +416,6 @@ class ID(Generic[E]):
         - UUID: Validates and wraps it.
         - str: Interpreted as a UUID if possible.
 
-        Args:
-            item (E): The item to convert to an ID.
-
         Returns:
             IDType: The validated ID.
 
@@ -477,9 +432,6 @@ class ID(Generic[E]):
     def is_id(item: Any) -> bool:
         """Checks if an item can be validated as an IDType.
 
-        Args:
-            item (Any): The object to check.
-
         Returns:
             bool: True if `item` is or can be validated as an IDType;
                 otherwise, False.

lionagi/protocols/generic/event.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations

lionagi/protocols/generic/log.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations
@@ -11,6 +10,7 @@ from typing import Any
 
 from pydantic import BaseModel, Field, PrivateAttr, field_validator
 
+from lionagi.models.hashable_model import HashableModel
 from lionagi.utils import create_path, to_dict
 
 from .element import Element
@@ -24,6 +24,8 @@ __all__ = (
     "LogManager",
 )
 
+logger = logging.getLogger(__name__)
+
 
 class DataLoggerConfig(BaseModel):
     persist_dir: str | Path = "./data/logs"
@@ -88,13 +90,13 @@ class Log(Element):
         Create a new Log from an Element, storing a dict snapshot
         of the element's data.
         """
-        if hasattr(content, "to_dict"):
-            content = content.to_dict()
+        if isinstance(content, Element | HashableModel):
+            content = content.to_dict(mode="json")
         else:
             content = to_dict(content, recursive=True, suppress=True)
 
         if content is {}:
-            logging.warning(
+            logger.warning(
                 "No content to log, or original data was of invalid type. Making an empty log..."
             )
             return cls(content={"error": "No content to log."})
@@ -141,18 +143,19 @@ class DataLogger:
         if self._config.auto_save_on_exit:
             atexit.register(self.save_at_exit)
 
-    def log(self, log_: Log) -> None:
+    def log(self, log_: Any) -> None:
         """
         Add a log synchronously. If capacity is reached, auto-dump to file.
         """
+        log_ = Log.create(log_) if not isinstance(log_, Log) else log_
         if self._config.capacity and len(self.logs) >= self._config.capacity:
             try:
                 self.dump(clear=self._config.clear_after_dump)
             except Exception as e:
-                logging.error(f"Failed to auto-dump logs: {e}")
+                logger.error(f"Failed to auto-dump logs: {e}")
         self.logs.include(log_)
 
-    async def alog(self, log_: Log) -> None:
+    async def alog(self, log_: Any) -> None:
         """
         Add a log asynchronously. If capacity is reached, auto-dump to file.
         """
@@ -169,7 +172,7 @@ class DataLogger:
         unsupported, raise ValueError. Optionally clear logs after.
         """
         if not self.logs:
-            logging.debug("No logs to dump.")
+            logger.debug("No logs to dump.")
             return
 
         fp = persist_path or self._create_path()
@@ -182,7 +185,7 @@ class DataLogger:
             else:
                 raise ValueError(f"Unsupported file extension: {suffix}")
 
-            logging.info(f"Dumped logs to {fp}")
+            logger.info(f"Dumped logs to {fp}")
             do_clear = (
                 self._config.clear_after_dump if clear is None else clear
             )
@@ -191,12 +194,12 @@ class DataLogger:
         except Exception as e:
             # Check if it's a JSON serialization error with complex objects
             if "JSON serializable" in str(e):
-                logging.debug(f"Could not serialize logs to JSON: {e}")
+                logger.debug(f"Could not serialize logs to JSON: {e}")
                 # Don't raise for JSON serialization issues during dumps
                 if clear is not False:
                     self.logs.clear()  # Still clear if requested
             else:
-                logging.error(f"Failed to dump logs: {e}")
+                logger.error(f"Failed to dump logs: {e}")
                 raise
 
     async def adump(
@@ -233,9 +236,9 @@ class DataLogger:
                 # Only log debug level for JSON serialization errors during exit
                 # These are non-critical and often occur with complex objects
                 if "JSON serializable" in str(e):
-                    logging.debug(f"Could not serialize logs to JSON: {e}")
+                    logger.debug(f"Could not serialize logs to JSON: {e}")
                 else:
-                    logging.error(f"Failed to save logs on exit: {e}")
+                    logger.error(f"Failed to save logs on exit: {e}")
 
     @classmethod
     def from_config(

lionagi/protocols/generic/pile.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations
@@ -222,13 +221,13 @@ class Pile(Element, Collective[T], Generic[T], Adaptable, AsyncAdaptable):
         "strict_type",
     }
 
-    def __pydantic_extra__(self) -> dict[str, "FieldInfo"]:
+    def __pydantic_extra__(self) -> dict[str, FieldInfo]:
         return {
             "_lock": Field(default_factory=threading.Lock),
             "_async": Field(default_factory=ConcurrencyLock),
         }
 
-    def __pydantic_private__(self) -> dict[str, "FieldInfo"]:
+    def __pydantic_private__(self) -> dict[str, FieldInfo]:
         return self.__pydantic_extra__()
 
     @classmethod

lionagi/protocols/generic/processor.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 import asyncio

lionagi/protocols/generic/progression.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from __future__ import annotations

lionagi/protocols/graph/__init__.py

@@ -1,5 +1,4 @@
-# Copyright (c) 2023 - 2025, HaiyangLi <quantocean.li at gmail dot com>
-#
+# Copyright (c) 2023-2025, HaiyangLi <quantocean.li at gmail dot com>
 # SPDX-License-Identifier: Apache-2.0
 
 from .edge import Edge, EdgeCondition