v0.6.2.dev - ComponentBase

[cobycloud]

Adjustments to the ComponentBase incoming:

1. Inclusion of a _type: ClassVar[str] = "ComponentBase" attribute

Motivation: class attribute is required to determine a class' type during runtime, prior instantiation.

2. Inclusion of __init__subclass__ hook to set instance attribute type

    def __init_subclass__(cls, **kwargs):
        super().__init_subclass__(**kwargs)
        # Dynamically update _type to the subclass's name.
        cls._type = cls.__name__
        # Change the annotation for `type` to a Literal of the subclass's name.
        cls.__annotations__["type"] = Literal[cls.__name__]
        # Set the default value for the `type` field.
        cls.type = cls.__name__

First Motivation: currently subclasses of ComponentBase are required to declare an instance attribute. This feels redundant as it has become standard for the type to always be the name of the class.

class Prompt(PromptBase):
    type: Literal["Prompt"] = "Prompt"

Second Motivation: Instance attribute is required for serialization and deserialization, whereas class attribute is required to determine a class' type during runtime, prior instantiation.

3. Introduction of Global logger

glogger = logging.getLogger(__name__)
glogger.setLevel(level=logging.INFO)
glogger.propagate = False
if not glogger.handlers:
    console_handler = logging.StreamHandler()
    formatter = logging.Formatter("[%(name)s][%(levelname)s] %(message)s")
    console_handler.setFormatter(formatter)
    glogger.addHandler(console_handler)

4. Introduction of unified component-level logging

    logger: Optional[Any] = Field(exclude=True, default=None)

    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        # Initialize a logger for the instance using its class name.
        self.logger = logging.getLogger(self.__class__.__name__)
        self.logger.setLevel(logging.INFO)
        self.logger.propagate = False  # Stops propagation to root
        if not self.logger.handlers:
            console_handler = logging.StreamHandler()
            formatter = logging.Formatter("[%(name)s][%(levelname)s] %(message)s")
            console_handler.setFormatter(formatter)
            self.logger.addHandler(console_handler)

5. updated ComponentBase.register_type() to support registration of multiple types, without supplying a type_name (which will deprecate rapidly).

example usage of deprecating tuple

@ComponentBase.register_type(LLMBase)

or now available

@ComponentBase.register_type([LLMBase, ParserBase])

6. Introduction of Intersection dynamic typing

@register_type(Example)
class Test(Example):
        type: Literal["ComponentBase"] = "ComponentBase"

@register_type(Example)
class Test2(Example):
        type: Literal["ComponentBase"] = "ComponentBase"

@register_type([Example, Example2])
class Test3(Example):
        type: Literal["ComponentBase"] = "ComponentBase"
        
        
 Intersection[Example, Example2]

typing.Annotated[main.Test3, FieldInfo(annotation=NoneType, required=True, discriminator='type'), <main.IntersectionMetadata object at 0x000001C09B73D880>]

Motivation: to enable dynamic typing based on Intersections of Parent Classes

7. Export ComponentBase.register_model and ComponentBase.register_type() classmethods to enable convenient method calling.

example:

from swarmauri_core.ComponentBase import register_type, register_model

---

Work to be done:

1. Enable Union[ List[ Type[BaseModel] ], Type[BaseModel]] on ComponentBase.register_model

Motivation: To enable models to register themselves as a model or list of models ( in the case of a convergent class or mixins )

2. Aggregating MODEL_REGISTRY and TYPE_REGISTRY into a single REGISTRY ( )

Motivation: To reduce redundancy before we create static types to ensure consistency of model:type registration.

3. Implementing _fields_contains_intersection method

Motivation: to detect Intersection or IntersectionMetadata for dynamic processing. This is required so that we can determine if a type is rendered to its static form.

4. Updating ComponentBase logger implementation

Motivation: As a user, I want to inject a list of logging.handlers on a global or per ComponentBasis.

[cobycloud]

• 1. Enable Union[ List[ Type[BaseModel] ], Type[BaseModel]] on ComponentBase.register_model
• 2. Aggregating MODEL_REGISTRY and TYPE_REGISTRY into a single REGISTRY ( )
• 3. Implementing _fields_contains_intersection method
• 4. Updating ComponentBase logger implementation