lionagi 0.3.2__py3-none-any.whl → 0.3.4__py3-none-any.whl

lionagi/core/unit/unit.py

@@ -12,7 +12,7 @@ from lionagi.libs.ln_func_call import rcall
 
 from .unit_form import UnitForm
 from .unit_mixin import DirectiveMixin
-from .util import retry_kwargs
+from .util import break_down_annotation, retry_kwargs
 
 
 class Unit(Directive, DirectiveMixin):
@@ -75,7 +75,7 @@ class Unit(Directive, DirectiveMixin):
         return_branch=False,
         formatter=None,
         format_kwargs={},
-        pydantic_model: type[BaseModel] = None,
+        pydantic_model: type[BaseModel] | BaseModel = None,
         return_pydantic_model: bool = False,
         **kwargs,
     ):
@@ -114,7 +114,13 @@ class Unit(Directive, DirectiveMixin):
                 raise ValueError(
                     "Cannot use both requested_fields and pydantic_model."
                 )
-            requested_fields = pydantic_model.model_json_schema()["properties"]
+            requested_fields = break_down_annotation(pydantic_model)
+            context = {
+                "info": context,
+                "return_guidance": pydantic_model.model_json_schema()[
+                    "properties"
+                ],
+            }
 
         output, branch = await rcall(
             self._chat,
@@ -148,8 +154,13 @@ class Unit(Directive, DirectiveMixin):
 
         if return_pydantic_model:
             try:
-                a_ = to_dict(output, recursive=True, max_recursive_depth=3)
-                output = pydantic_model(**a_)
+                a_ = to_dict(
+                    output,
+                    recursive=True,
+                    max_recursive_depth=5,
+                    fuzzy_parse=True,
+                )
+                output = pydantic_model.model_validate(a_)
                 return output, branch if return_branch else output
             except Exception as e:
                 logging.error(f"Error converting to pydantic model: {e}")

lionagi/core/unit/util.py

@@ -1,3 +1,8 @@
+import inspect
+from typing import get_args
+
+from pydantic import BaseModel
+
 retry_kwargs = {
     "retries": 0,  # kwargs for rcall, number of retries if failed
     "delay": 0,  # number of seconds to delay before retrying
@@ -74,3 +79,25 @@ async def _direct(
         )
 
     return await directive.direct(form=form, return_form=True, **kwargs)
+
+
+def break_down_annotation(model: type[BaseModel]):
+
+    def _ispydantic_model(x):
+        return inspect.isclass(x) and issubclass(x, BaseModel)
+
+    if not _ispydantic_model(model):
+        return model
+
+    out = {}
+    for k, v in model.__annotations__.items():
+        if _ispydantic_model(v):
+            out[k] = break_down_annotation(v)
+        elif "list" in str(v) and get_args(v):
+            v = get_args(v)[0]
+            if _ispydantic_model(v):
+                v = break_down_annotation(v)
+            out[k] = [v]
+        else:
+            out[k] = v
+    return out

lionagi/lions/judge/config.py

@@ -0,0 +1,8 @@
+judge_model_config = {
+    "model": "gpt-4o-mini",
+    "temperature": 0.1,
+    "api_key_schema": "OPENAI_API_KEY",
+    "max_tokens": 1000,
+    "costs": (0.15, 0.6),
+    "top_p": 0.9,
+}

lionagi/lions/judge/data/sample_codes.py

@@ -0,0 +1,526 @@
+code1 = '''
+from collections import deque
+from functools import singledispatchmethod
+from typing import Annotated, Any, ClassVar, TypeVar
+
+from lionabc.exceptions import LionValueError
+from lionfuncs import LN_UNDEFINED, copy, time
+from pydantic import Field, field_serializer, field_validator
+from pydantic.fields import FieldInfo
+from pydantic_core import PydanticUndefined
+from typing_extensions import override
+
+from lion_core._class_registry import get_class
+from lion_core.converter import Converter
+from lion_core.generic.component_converter import ComponentConverterRegistry
+from lion_core.generic.element import Element
+from lion_core.generic.note import Note
+
+T = TypeVar("T", bound=Element)
+
+DEFAULT_SERIALIZATION_INCLUDE: set[str] = {
+    "ln_id",
+    "timestamp",
+    "metadata",
+    "content",
+    "embedding",
+}
+
+
+NAMED_FIELD = Annotated[str, Field(..., alias="field")]
+
+
+class Component(Element):
+    """Extended base class for components in the Lion framework."""
+
+    metadata: Note = Field(
+        default_factory=Note,
+        description="Additional metadata for the component",
+    )
+
+    content: Any = Field(
+        default=None,
+        description="The main content of the Component",
+    )
+
+    embedding: list[float] = Field(default_factory=list)
+
+    extra_fields: dict[str, Any] = Field(default_factory=dict)
+
+    _converter_registry: ClassVar = ComponentConverterRegistry
+
+    @field_serializer("metadata")
+    def _serialize_metadata(self, value):
+        return value.to_dict()
+
+    @field_serializer("extra_fields")
+    def _serialize_extra_fields(
+        self,
+        value: dict[str, FieldInfo],
+    ) -> dict[str, Any]:
+        """Custom serializer for extra fields."""
+        output_dict = {}
+        for k in value.keys():
+            k_value = self.__dict__.get(k)
+            output_dict[k] = k_value
+        return output_dict
+
+    @field_validator("extra_fields")
+    def _validate_extra_fields(cls, value: Any) -> dict[str, FieldInfo]:
+        """Custom validator for extra fields."""
+        if not isinstance(value, dict):
+            raise LionValueError("Extra fields must be a dictionary")
+
+        out_ = {}
+        for k, v in value.items():
+            out_[k] = Field(**v) if isinstance(v, dict) else v
+
+        return out_
+
+    @property
+    def all_fields(self) -> dict[str, FieldInfo]:
+        """
+        Get all fields including model fields and extra fields.
+
+        Returns:
+            dict[str, FieldInfo]: A dictionary containing all fields.
+        """
+        return {**self.model_fields, **self.extra_fields}
+
+    def add_field(
+        self,
+        field_name: NAMED_FIELD,
+        /,
+        value: Any = LN_UNDEFINED,
+        annotation: Any = LN_UNDEFINED,
+        field_obj: FieldInfo = LN_UNDEFINED,
+        **kwargs,
+    ) -> None:
+        """
+        Add a new field to the component's extra fields.
+
+        Args:
+            field_name: The name of the field to add.
+            value: The value of the field.
+            annotation: Type annotation for the field.
+            field_obj: A pre-configured FieldInfo object.
+            **kwargs: Additional keyword arguments for Field configuration.
+
+        Raises:
+            LionValueError: If the field already exists.
+        """
+        if field_name in self.all_fields:
+            raise LionValueError(f"Field '{field_name}' already exists")
+
+        self.update_field(
+            field_name,
+            value=value,
+            annotation=annotation,
+            field_obj=field_obj,
+            **kwargs,
+        )
+
+    # when updating field, we do not check the validity of annotation
+    # meaning current value will not get validated, and can lead to
+    # errors when storing and loading if you change annotation to a type
+    # that is not compatible with the current value
+    def update_field(
+        self,
+        field_name: NAMED_FIELD,
+        /,
+        value: Any = LN_UNDEFINED,
+        annotation: Any = LN_UNDEFINED,
+        field_obj: FieldInfo | Any = LN_UNDEFINED,
+        **kwargs,
+    ) -> None:
+        """
+        Update an existing field or create a new one if it doesn't exist.
+
+        Args:
+            field_name: The name of the field to update or create.
+            value: The new value for the field.
+            annotation: Type annotation for the field.
+            field_obj: A pre-configured FieldInfo object.
+            **kwargs: Additional keyword arguments for Field configuration.
+
+        Raises:
+            ValueError: If both 'default' and 'default_factory' are
+                        provided in kwargs.
+        """
+
+        # pydanitc Field object cannot have both default and default_factory
+        if "default" in kwargs and "default_factory" in kwargs:
+            raise ValueError(
+                "Cannot provide both 'default' and 'default_factory'",
+            )
+
+        # handle field_obj
+        if field_obj is not LN_UNDEFINED:
+            if not isinstance(field_obj, FieldInfo):
+                raise ValueError(
+                    "Invalid field_obj, should be a pydantic FieldInfo object"
+                )
+            self.extra_fields[field_name] = field_obj
+
+        # handle kwargs
+        if kwargs:
+            if field_name in self.all_fields:  # existing field
+                for k, v in kwargs.items():
+                    self.field_setattr(field_name, k, v)
+            else:
+                self.extra_fields[field_name] = Field(**kwargs)
+
+        # handle no explicit defined field
+        if field_obj is LN_UNDEFINED and not kwargs:
+            if field_name not in self.all_fields:
+                self.extra_fields[field_name] = Field()
+
+        field_obj = self.all_fields[field_name]
+
+        # handle annotation
+        if annotation is not LN_UNDEFINED:
+            field_obj.annotation = annotation
+        if not field_obj.annotation:
+            field_obj.annotation = Any
+
+        # handle value
+        if value is LN_UNDEFINED:
+            if getattr(self, field_name, LN_UNDEFINED) is not LN_UNDEFINED:
+                value = getattr(self, field_name)
+
+            elif getattr(field_obj, "default") is not PydanticUndefined:
+                value = field_obj.default
+
+            elif getattr(field_obj, "default_factory"):
+                value = field_obj.default_factory()
+
+        setattr(self, field_name, value)
+        self._add_last_update(field_name)
+
+    def _add_last_update(self, field_name: str, /) -> None:
+        current_time = time()
+        self.metadata.set(["last_updated", field_name], current_time)
+
+    @override
+    def to_dict(self, **kwargs: Any) -> dict:
+        """
+        Convert the component to a dictionary representation.
+
+        Args:
+            **kwargs: Additional arguments to pass to model_dump.
+
+        Returns:
+            dict[str, Any]: A dictionary representation of the component.
+        """
+        dict_ = self.model_dump(**kwargs)
+        if isinstance(self.content, Note):
+            dict_["content"] = dict_["content"]["content"]
+        extra_fields = dict_.pop("extra_fields", {})
+        dict_ = {**dict_, **extra_fields, "lion_class": self.class_name()}
+        for i in list(dict_.keys()):
+            if dict_[i] is LN_UNDEFINED:
+                dict_.pop(i)
+        return dict_
+
+    def to_note(self, **kwargs: Any) -> Note:
+        return Note(**self.to_dict(**kwargs))
+
+    @override
+    @classmethod
+    def from_dict(cls, data: dict, /, **kwargs: Any) -> T:
+        """
+        Create a component instance from a dictionary.
+
+        Args:
+            data: The dictionary containing component data.
+            **kwargs: Additional arguments for Pydantic model validation.
+
+        Returns:
+            T: An instance of the Component class or its subclass.
+        """
+        input_data = copy(data)
+        if "lion_class" in input_data:
+            cls = get_class(input_data.pop("lion_class"))
+        if cls.from_dict.__func__ != Component.from_dict.__func__:
+            return cls.from_dict(input_data, **kwargs)
+
+        extra_fields = {}
+        for k, v in list(input_data.items()):
+            if k not in cls.model_fields:
+                extra_fields[k] = input_data.pop(k)
+        obj = cls.model_validate(input_data, **kwargs)
+        for k, v in extra_fields.items():
+            obj.update_field(k, value=v)
+
+        metadata = copy(data.get("metadata", {}))
+        last_updated = metadata.get("last_updated", None)
+        if last_updated is not None:
+            obj.metadata.set(["last_updated"], last_updated)
+        else:
+            obj.metadata.pop(["last_updated"], None)
+        return obj
+
+    @override
+    def __setattr__(self, field_name: str, value: Any) -> None:
+        if field_name == "metadata":
+            raise AttributeError("Cannot directly assign to metadata.")
+        elif field_name == "extra_fields":
+            raise AttributeError("Cannot directly assign to extra_fields")
+        if field_name in self.extra_fields:
+            object.__setattr__(self, field_name, value)
+        else:
+            super().__setattr__(field_name, value)
+
+        self._add_last_update(field_name)
+
+    @override
+    def __getattr__(self, field_name: str) -> Any:
+        if field_name in self.extra_fields:
+            default_ = self.extra_fields[field_name].default
+            if default_ is not PydanticUndefined:
+                return default_
+            return LN_UNDEFINED
+
+        cls_name = self.__class__.__name__
+        raise AttributeError(
+            f"'{cls_name}' object has no attribute '{field_name}'",
+        )
+
+    @override
+    def __str__(self) -> str:
+        """Return a concise string representation of the component."""
+        content_preview = str(self.content)[:50]
+        if len(content_preview) == 50:
+            content_preview += "..."
+
+        output_str = (
+            f"{self.__class__.__name__}("
+            f"ln_id={self.ln_id[:8]}..., "
+            f"timestamp={str(self.created_datetime)[:-6]}, "
+            f"content='{content_preview}', "
+            f"metadata_keys={list(self.metadata.keys())}, "
+        )
+
+        for i, j in self.model_dump().items():
+            if i not in DEFAULT_SERIALIZATION_INCLUDE:
+                if isinstance(j, dict):
+                    output_str += f"{i}={list(j.keys())}, "
+                elif isinstance(j, str):
+                    j_preview = j[:50]
+                    if len(j_preview) == 50:
+                        j_preview = j_preview + "..."
+                    output_str += f"{i}={j_preview}, "
+                else:
+                    output_str += f"{i}={j}, "
+
+        output_str += f"extra_fields_keys={list(self.extra_fields.keys())})"
+
+        return output_str
+
+    @override
+    def __repr__(self) -> str:
+        """Return a detailed string representation of the component."""
+
+        def truncate_dict(
+            d: dict[str, Any], max_items: int = 5, max_str_len: int = 50
+        ) -> dict[str, Any]:
+            items = list(d.items())[:max_items]
+            truncated = {
+                k: (
+                    v[:max_str_len] + "..."
+                    if isinstance(v, str) and len(v) > max_str_len
+                    else v
+                )
+                for k, v in items
+            }
+            if len(d) > max_items:
+                truncated["..."] = f"({len(d) - max_items} more items)"
+            return truncated
+
+        content_repr = repr(self.content)
+        if len(content_repr) > 100:
+            content_repr = content_repr[:97] + "..."
+
+        dict_ = self.model_dump()
+        extra_fields = dict_.pop("extra_fields", {})
+
+        repr_str = (
+            f"{self.class_name()}("
+            f"ln_id={repr(self.ln_id)}, "
+            f"timestamp={str(self.created_datetime)[:-6]}, "
+            f"content={content_repr}, "
+            f"metadata={truncate_dict(self.metadata.content)}, "
+        )
+
+        for i, j in dict_.items():
+            if i not in DEFAULT_SERIALIZATION_INCLUDE:
+                if isinstance(j, dict):
+                    repr_str += f"{i}={truncate_dict(j)}, "
+                elif isinstance(j, str):
+                    j_repr = j
+                    if len(j) > 100:
+                        j_repr = j[:97] + "..."
+                    repr_str += f"{i}={j_repr}, "
+                else:
+                    repr_str += f"{i}={j}, "
+
+        repr_str += f"extra_fields={truncate_dict(extra_fields)})"
+        return repr_str
+
+    # converter methods
+    @classmethod
+    def list_converters(cls) -> list[str]:
+        """List all registered converters."""
+        return cls._get_converter_registry().list_obj_keys()
+
+    @classmethod
+    def _get_converter_registry(cls) -> ComponentConverterRegistry:
+        """Get the converter registry for the class."""
+        if isinstance(cls._converter_registry, type):
+            cls._converter_registry = cls._converter_registry()
+        return cls._converter_registry
+
+    def convert_to(self, obj_key: str, /, **kwargs: Any) -> Any:
+        """Convert the component to a specified type"""
+        return self._get_converter_registry().convert_to(
+            self,
+            obj_key,
+            **kwargs,
+        )
+
+    @classmethod
+    def convert_from(
+        cls, obj: Any, obj_key: str = None, /, **kwargs: Any
+    ) -> T:
+        """Convert data to create a new component instance"""
+        data = cls._get_converter_registry().convert_from(
+            cls,
+            obj,
+            obj_key,
+            **kwargs,
+        )
+        return cls.from_dict(data)
+
+    @classmethod
+    def register_converter(cls, converter: type[Converter]) -> None:
+        """Register a new converter."""
+        cls._get_converter_registry().register(converter)
+
+    # field management methods
+    def field_setattr(
+        self,
+        field_name: str,
+        attr: Any,
+        value: Any,
+        /,
+    ) -> None:
+        """Set the value of a field attribute."""
+        all_fields = self.all_fields
+        if field_name not in all_fields:
+            raise KeyError(f"Field {field_name} not found in object fields.")
+        field_obj = all_fields[field_name]
+        if hasattr(field_obj, attr):
+            setattr(field_obj, attr, value)
+        else:
+            if not isinstance(field_obj.json_schema_extra, dict):
+                field_obj.json_schema_extra = {}
+            field_obj.json_schema_extra[attr] = value
+
+    def field_hasattr(
+        self,
+        field_name: str,
+        attr: str,
+        /,
+    ) -> bool:
+        """Check if a field has a specific attribute."""
+        all_fields = self.all_fields
+        if field_name not in all_fields:
+            raise KeyError(f"Field {field_name} not found in object fields.")
+        field_obj = all_fields[field_name]
+        if hasattr(field_obj, attr):
+            return True
+        elif isinstance(field_obj.json_schema_extra, dict):
+            if field_name in field_obj.json_schema_extra:
+                return True
+        else:
+            return False
+
+    def field_getattr(
+        self,
+        field_name: str,
+        attr: str,
+        default: Any = LN_UNDEFINED,
+        /,
+    ) -> Any:
+        """Get the value of a field attribute."""
+        if str(attr).strip("s").lower() == "annotation":
+            return self._field_annotation(field_name)
+
+        all_fields = self.all_fields
+        if field_name not in all_fields:
+            raise KeyError(f"Field {field_name} not found in object fields.")
+        field_obj = all_fields[field_name]
+
+        # check fieldinfo attr
+
+        value = getattr(field_obj, attr, LN_UNDEFINED)
+        if value is not LN_UNDEFINED:
+            return value
+        else:
+            if isinstance(field_obj.json_schema_extra, dict):
+                value = field_obj.json_schema_extra.get(attr, LN_UNDEFINED)
+                if value is not LN_UNDEFINED:
+                    return value
+
+        # undefined attr
+        if default is not LN_UNDEFINED:
+            return default
+        else:
+            raise AttributeError(
+                f"field {field_name} has no attribute {attr}",
+            )
+
+    def field_annotation(self, field_name: Any, /) -> dict[str, Any]:
+        """Get the annotation of a field."""
+        return self._field_annotation(field_name)
+
+    @singledispatchmethod
+    def _field_annotation(self, field_name: Any, /) -> dict[str, Any]:
+        """
+        Get field annotation for a given field.
+
+        Args:
+            field: The field to get annotation for.
+
+        Returns:
+            A dictionary containing the field annotation.
+        """
+        return {}
+
+    @_field_annotation.register(str)
+    def _(self, field_name: str, /) -> dict[str, Any]:
+        dict_ = {field_name: self.all_fields[field_name].annotation}
+        for _f, _anno in dict_.items():
+            if "|" in str(_anno):
+                _anno = str(_anno)
+                _anno = _anno.split("|")
+                dict_[_f] = [str(i).lower().strip() for i in _anno]
+            else:
+                dict_[_f] = [_anno.__name__] if _anno else None
+        return dict_
+
+    @_field_annotation.register(deque)
+    @_field_annotation.register(set)
+    @_field_annotation.register(list)
+    @_field_annotation.register(tuple)
+    def _(self, field_name, /) -> dict[str, Any]:
+        dict_ = {}
+        for f in field_name:
+            dict_.update(self._field_annotation(f))
+        return dict_
+
+
+__all__ = ["Component"]
+
+# File: lion_core/generic/component.py
+'''

lionagi/lions/judge/data/sample_rurbic.py

@@ -0,0 +1,48 @@
+from lionagi.lions.judge.rubric import Rubric, RubricItem
+
+functionality = RubricItem(
+    name="functionality",
+    prompt="Assess how well the code meets the functional requirements.",
+    weight=2.7,
+)
+
+readability = RubricItem(
+    name="readability",
+    prompt="Evaluate the readability and clarity of the code.",
+    weight=1,
+)
+
+efficiency = RubricItem(
+    name="efficiency",
+    prompt="Examine the efficiency of the algorithms used.",
+    weight=1.5,
+)
+
+style_compliance = RubricItem(
+    name="style_compliance",
+    prompt="Check adherence to coding style guidelines.",
+    weight=0.5,
+)
+
+error_handling = RubricItem(
+    name="error_handling",
+    prompt="Analyze the robustness of error handling mechanisms.",
+    weight=1,
+)
+
+code_quality_rubric = Rubric(
+    name="code_quality_rubric",
+    description="Used for assessing code submissions in programming challenges.",
+    items={
+        i.name: i
+        for i in [
+            functionality,
+            readability,
+            efficiency,
+            style_compliance,
+            error_handling,
+        ]
+    },
+)
+
+__all__ = ["code_quality_rubric"]

lionagi/lions/judge/forms/code_analysis_form.py

@@ -0,0 +1,126 @@
+from lionfuncs import to_num
+from pydantic import Field
+
+from lionagi import Form
+from lionagi.lions.judge.rubric import Rubric
+
+
+class CodeAnalysisForm(Form):
+    """
+    A structured form for analyzing code submissions based on a given rubric.
+    """
+
+    system_prompt: str = Field(
+        """
+        You are an AI code reviewer proficient in {language}.
+        Evaluate the following code submission based on the criteria below,
+        each independently scored from 0 to 100.
+        Note that you should be objective and fair in your evaluation, with
+        focus around sophistication, usability, and correctness.
+        """.strip(
+            "        "
+        )
+    )
+
+    code_submission: str | None = Field(
+        default=None,
+        description="The code_submission to be analyzed.",
+    )
+
+    overall_feedback: str | None = Field(
+        None, description="Overall feedback based on the evaluation."
+    )
+
+    rubric: Rubric
+    language: str = "Python"
+    assignment: str = "task, code_submission -> overall_feedback"
+
+    def __init__(
+        self,
+        code_submission,
+        rubric: Rubric,
+        instruction=None,
+        context=None,
+        language: str = "Python",
+    ):
+        super().__init__(
+            code_submission=code_submission, language=language, rubric=rubric
+        )
+        self.task = (
+            "Follow the prompt and provide the necessary output.\n"
+            f"- Additional instruction: {str(instruction or 'N/A')}\n"
+            f"- Additional context: {str(context or 'N/A')}\n"
+        )
+        self.system_prompt = self.system_prompt.format(language=language)
+
+        for item_name, item in rubric.items.items():
+            description = item.description or ""
+            description += item.prompt
+            description += (
+                "response format: {score: number 0-100, comments: string}"
+            )
+            self.add_field(
+                item_name, value=None, annotation=dict, description=description
+            )
+            self.append_to_request(item_name)
+
+    @property
+    def display_message(self) -> str:
+        """
+        Generates a human-readable message summarizing the evaluation.
+        """
+
+        _dict: dict = self.work_fields
+        overall_feedback = _dict.pop("overall_feedback")
+        ttl_score = 0
+        for i in self.rubric.analysis_types:
+            score = to_num(
+                _dict[i]["score"], upper_bound=100, lower_bound=0, num_type=int
+            )
+            weighted_score = score * self.rubric.normalized_weight[i]
+            ttl_score += weighted_score
+
+        rubric_msg = ""
+
+        message_lines = [
+            f"Evaluation Results ({self.timestamp[:-7]}):\n",
+            f"Language: {self.language}\n",
+            f"Total Score: {ttl_score:.1f}/100\n",
+            "----------------------------------------",
+            "",
+        ]
+
+        for i in message_lines:
+            rubric_msg += f"{i}\n"
+
+        for k, v in _dict.items():
+            if k in self.rubric.analysis_types:
+                t = k.replace("_", " ").title()
+                rubric_msg += f"{t}:\nScore: {v['score']}/100\nCriteria Weight: {self.rubric.normalized_weight[k]*100:.1f}%\nComments: {v['comments']}\n\n"
+
+        if overall_feedback:
+            rubric_msg += f"Overall Feedback:\n{overall_feedback}\n\n"
+
+        if ttl_score:
+            rubric_msg += f"Total Score: {ttl_score:.1f}/100\n\n"
+
+        if ttl_score:
+            if ttl_score < 30:
+                rubric_msg += "Baby Steps. Not an AI hacker yet. 😅\n"
+            elif ttl_score < 50:
+                rubric_msg += "There we go! You are a junior AI hacker! 🥳\n"
+            elif ttl_score < 70:
+                rubric_msg += "Great Work! You are a graduated AI hacker! 🤩\n"
+            elif ttl_score < 88:
+                rubric_msg += "A master AI hacker! 🤯\n"
+            else:
+                rubric_msg += "The Lion King of AI Hacking! 🚀🦁🚀\n"
+
+        message = f"""
+{rubric_msg}
+----------------------------------------
+"""
+        return message
+
+
+__all__ = ["CodeAnalysisForm"]

lionagi/lions/judge/rubric.py

@@ -0,0 +1,34 @@
+from pydantic import BaseModel
+
+
+class RubricItem(BaseModel):
+    name: str
+    prompt: str
+    description: str | None = None
+    weight: float | int = 1
+    metadata: dict = {}
+
+
+class Rubric(BaseModel):
+    name: str
+    description: str
+    items: dict[str, RubricItem]
+    metadata: dict = {}
+
+    @property
+    def analysis_types(self):
+        return list(self.items.keys())
+
+    @property
+    def normalized_weight(self):
+        return {
+            item.name: item.weight / self.ttl_weights
+            for item in self.items.values()
+        }
+
+    @property
+    def ttl_weights(self):
+        return sum([item.weight for item in self.items.values()])
+
+
+__all__ = ["Rubric", "RubricItem"]

lionagi/lions/judge/services/judge_code.py

@@ -0,0 +1,49 @@
+import asyncio
+
+from aiocache import cached
+
+from lionagi import Branch, iModel
+from lionagi.lions.judge.config import judge_model_config
+from lionagi.lions.judge.forms.code_analysis_form import CodeAnalysisForm
+from lionagi.lions.judge.rubric import Rubric
+
+
+@cached(ttl=3600)
+async def judge_code(
+    code_submission: str,
+    rubric: Rubric,
+    instruction: str = None,
+    context: str = None,
+    model_config: dict = None,
+    display_message: bool = True,
+    verbose: bool = True,
+    language: str = "Python",
+) -> CodeAnalysisForm:
+    branch = Branch(imodel=iModel(**(model_config or judge_model_config)))
+    form = CodeAnalysisForm(
+        code_submission=code_submission,
+        rubric=rubric,
+        instruction=instruction,
+        context=context,
+        language=language,
+    )
+    if verbose:
+        print("Evaluating code submission...")
+    form = await branch.chat(form=form)
+    if display_message:
+        print(form.display_message)
+    return form.to_dict()
+
+
+async def main():
+    from ..data.sample_codes import code1
+    from ..data.sample_rurbic import code_quality_rubric
+
+    return await judge_code(
+        code_submission=code1,
+        rubric=code_quality_rubric,
+    )
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

lionagi/version.py

@@ -1 +1 @@
-__version__ = "0.3.2"
+__version__ = "0.3.4"

{lionagi-0.3.2.dist-info → lionagi-0.3.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lionagi
-Version: 0.3.2
+Version: 0.3.4
 Summary: Towards automated general intelligence.
 Author: HaiyangLi
 Author-email: quantocean.li@gmail.com

{lionagi-0.3.2.dist-info → lionagi-0.3.4.dist-info}/RECORD

@@ -105,10 +105,10 @@ lionagi/core/unit/template/plan.py,sha256=i4FmKEB8eRsRCsTanvfoX-2RZ8SaM1qvLBluuY
 lionagi/core/unit/template/predict.py,sha256=-EIZQo0ZjGKy3MiM0AtqmbnJpbXcrwtSCON5n3jcyVo,3160
 lionagi/core/unit/template/score.py,sha256=ReUaIIr-NLjunSy4NNXQpIsH28NNceGBAUuPCRptzMc,3809
 lionagi/core/unit/template/select.py,sha256=VSpkphJl9bHSE8i0X6MMJD8LB5QwOj1UORHm8VDIRKE,3047
-lionagi/core/unit/unit.py,sha256=1kFz_rLM1f8OKn4pbwL2WiVyqTzyEPOmHL9OdIiwzHI,15252
+lionagi/core/unit/unit.py,sha256=5XJ8k401cqVNLOJpNcHul3IG6WflC--AlSg2IprlSkk,15600
 lionagi/core/unit/unit_form.py,sha256=zK_ij3Tod5FwMVdIIhdVoEFvD3br-YM9RPe7WsOIW2s,10980
 lionagi/core/unit/unit_mixin.py,sha256=c8GvHzgc65iJKQBKv71ET3afLPsIz5-Ce-4Eo6_bZiw,38823
-lionagi/core/unit/util.py,sha256=yEIf4ksWLB4X0IZNmwvIphvXiRbtWtGqbWCPnIt1u-s,2048
+lionagi/core/unit/util.py,sha256=WN2Jop-LUwQNYJNubFPhOZrisQ6SQq-XMhD_KhzLkgE,2707
 lionagi/core/validator/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/core/validator/validator.py,sha256=901wwmqL92XNi25ajv57bNKIKZhmu-KprNLArMUiGqg,12255
 lionagi/core/work/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -213,14 +213,24 @@ lionagi/lions/coder/base_prompts.py,sha256=SLpC442nZm2cEkB8o9j28kpkB-WzKLjH6sOTS
 lionagi/lions/coder/code_form.py,sha256=xW66cWCsrZu2qGu-wGUGSIPL1uZevGQVCE_vBRH9Kmc,384
 lionagi/lions/coder/coder.py,sha256=u-n_7PVdKCAz28SAA2bO4oy1qxGIzEl1PX6iqz7oSoI,5829
 lionagi/lions/coder/util.py,sha256=m9H18JrePpuP1VyjxVXQaLXCGBed04jZIkfNXvF7_gU,2751
+lionagi/lions/judge/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/lions/judge/config.py,sha256=hJNMI-07zf5cqU2tr22fzkGvhR7RdtckkYg8UhLTKec,185
+lionagi/lions/judge/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/lions/judge/data/sample_codes.py,sha256=LfXQ6eiwcR_bkFOURPgZZVE7ShllcS2k6nnC82W75Gc,17500
+lionagi/lions/judge/data/sample_rurbic.py,sha256=H-wS8KliqI3e8XdBcT0hZFi_RdFxAyz2aCxCsR5x6YQ,1123
+lionagi/lions/judge/forms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/lions/judge/forms/code_analysis_form.py,sha256=JK2I0TfeZwpeYolkVlOr-cPFhTXjdyqH9-DmwPztTb4,4129
+lionagi/lions/judge/rubric.py,sha256=NCk06pJd86lbSQNavBYEvzV4WORN746A5J_1qsL4DD4,700
+lionagi/lions/judge/services/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+lionagi/lions/judge/services/judge_code.py,sha256=CRfecySGpLw8ceKJwgHWgxorMgjOs_aRAjONJZ6PrE0,1267
 lionagi/lions/researcher/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/lions/researcher/data_source/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lionagi/lions/researcher/data_source/finhub_.py,sha256=W63daXgIwHJQ6TDMR2ALQIDk1mV3msoDQ9RgOYXsGoE,8783
 lionagi/lions/researcher/data_source/google_.py,sha256=401SKHQaSpxiOUoXl7stadl4qeF7SIX72lUNK7bKesg,6797
 lionagi/lions/researcher/data_source/wiki_.py,sha256=UPoa2dk_y5sELu7_rkdme2auDpUmc_Dn0Avgjwr2X2g,3145
 lionagi/lions/researcher/data_source/yfinance_.py,sha256=snAf897J69MyAc6fcFjF0irrMjbAh81EZ3RvaFT3hxE,977
-lionagi/version.py,sha256=vNiWJ14r_cw5t_7UDqDQIVZvladKFGyHH2avsLpN7Vg,22
-lionagi-0.3.2.dist-info/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
-lionagi-0.3.2.dist-info/METADATA,sha256=7DrVUgP-AuWQaUBz_bfuAEvjRRRPw-yAmeX7349rf40,3149
-lionagi-0.3.2.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-lionagi-0.3.2.dist-info/RECORD,,
+lionagi/version.py,sha256=oYLGMpySamd16KLiaBTfRyrAS7_oyp-TOEHmzmeumwg,22
+lionagi-0.3.4.dist-info/LICENSE,sha256=VXFWsdoN5AAknBCgFqQNgPWYx7OPp-PFEP961zGdOjc,11288
+lionagi-0.3.4.dist-info/METADATA,sha256=VM0JO4wP1qKYkLZ7Al0lLiOi0ZaWreAjxbJmkyhdaOo,3149
+lionagi-0.3.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+lionagi-0.3.4.dist-info/RECORD,,