U DA·fàã @sddlmZmZmZmZmZmZmZddlm Z m Z ddl m Z m Z ddlmZddlmZmZdeeeeeeeeedfeeeefeedœd d „Zdeeeeefeeeefeeeefeeedfeeeefee d œd d „ZdS)é)ÚAnyÚDictÚListÚOptionalÚTupleÚTypeÚUnion)Ú ComponentÚ component)Údefault_from_dictÚdefault_to_dict)ÚDocument)Ú DocumentStoreÚDuplicatePolicyN.)ÚnameÚ documentsÚdocuments_countÚbasesÚ extra_fieldsÚreturnc sðˆdk rˆdkrtˆƒ‰n ˆdkr&d‰ttdfdœ‡fdd„ }dttttfttdœ‡fdd„ }t j fttt dd œd d „}ttdd œd d„}tttfdœdd„} ||||| t t ƒdœ} |dk rÒ| |–} |dkràt f}t||| ƒ} | S)aë Utility function to create a DocumentStore class with the given name and list of documents. If `documents` is set but `documents_count` is not, `documents_count` will be the length of `documents`. If both are set explicitly they don't influence each other. `write_documents()` and `delete_documents()` are no-op. You can override them using `extra_fields`. ### Usage Create a DocumentStore class that returns no documents: ```python MyFakeStore = document_store_class("MyFakeComponent") document_store = MyFakeStore() assert document_store.documents_count() == 0 assert document_store.filter_documents() == [] ``` Create a DocumentStore class that returns a single document: ```python doc = Document(id="fake_id", content="Fake content") MyFakeStore = document_store_class("MyFakeComponent", documents=[doc]) document_store = MyFakeStore() assert document_store.documents_count() == 1 assert document_store.filter_documents() == [doc] ``` Create a DocumentStore class that returns no document but returns a custom count: ```python MyFakeStore = document_store_class("MyFakeComponent", documents_count=100) document_store = MyFakeStore() assert document_store.documents_count() == 100 assert document_store.filter_documents() == [] ``` Create a DocumentStore class that returns a document and a custom count: ```python doc = Document(id="fake_id", content="Fake content") MyFakeStore = document_store_class("MyFakeComponent", documents=[doc], documents_count=100) document_store = MyFakeStore() assert document_store.documents_count() == 100 assert document_store.filter_documents() == [doc] ``` Create a DocumentStore class with a custom base class: ```python MyFakeStore = document_store_class( "MyFakeStore", bases=(MyBaseClass,) ) document_store = MyFakeStore() assert isinstance(store, MyBaseClass) ``` Create a DocumentStore class with an extra field `my_field`: ```python MyFakeStore = document_store_class( "MyFakeStore", extra_fields={"my_field": 10} ) document_store = MyFakeStore() assert document_store.my_field == 10 ``` Nr)rcsˆS©N©©Úself)rrú.count_documents)Úfiltersrcsˆdk r ˆSgSrr)rr)rrrÚfilter_documents^sz.document_store_class..filter_documents)rÚpolicyrcSsdSrr)rrrrrrÚwrite_documentscsz-document_store_class..write_documents)Ú document_idsrcSsdSrr)rr rrrÚdelete_documentsfsz.document_store_class..delete_documentscSst|ƒSr©r rrrrÚto_dictisz%document_store_class..to_dict)rrrr!r#Ú from_dict)N)ÚlenrÚintrrÚstrrrr rÚFAILÚ classmethodr ÚobjectÚtype) rrrrrrrrr!r#ÚfieldsÚclsr)rrrÚdocument_store_class s,I &ú  r.)rÚ input_typesÚ output_typesÚoutputrrrc sƈdkrdti‰ˆdkr4ˆdk r4dd„ˆ ¡Dƒ‰nˆdkrHdtdƒi‰‡‡fdd„}‡‡fdd„}d d „}tttfd œd d „} |||t| ƒdœ} |dk r¤| |–} |dkr²tf}t||| ƒ} t| ƒS)aÖ Utility class to create a Component class with the given name and input and output types. If `output` is set but `output_types` is not, `output_types` will be set to the types of the values in `output`. Though if `output_types` is set but `output` is not the component's `run` method will return a dictionary of the same keys as `output_types` all with a value of None. ### Usage Create a component class with default input and output types: ```python MyFakeComponent = component_class_factory("MyFakeComponent") component = MyFakeComponent() output = component.run(value=1) assert output == {"value": None} ``` Create a component class with an "value" input of type `int` and with a "value" output of `10`: ```python MyFakeComponent = component_class_factory( "MyFakeComponent", input_types={"value": int}, output={"value": 10} ) component = MyFakeComponent() output = component.run(value=1) assert output == {"value": 10} ``` Create a component class with a custom base class: ```python MyFakeComponent = component_class_factory( "MyFakeComponent", bases=(MyBaseClass,) ) component = MyFakeComponent() assert isinstance(component, MyBaseClass) ``` Create a component class with an extra field `my_field`: ```python MyFakeComponent = component_class_factory( "MyFakeComponent", extra_fields={"my_field": 10} ) component = MyFakeComponent() assert component.my_field == 10 ``` Args: name: Name of the component class input_types: Dictionary of string and type that defines the inputs of the component, if set to None created component will expect a single input "value" of Any type. Defaults to None. output_types: Dictionary of string and type that defines the outputs of the component, if set to None created component will return a single output "value" of NoneType and None value. Defaults to None. output: Actual output dictionary returned by the created component run, is set to None it will return a dictionary of string and None values. Keys will be the same as the keys of output_types. Defaults to None. bases: Base classes for this component, if set to None only base is object. Defaults to None. extra_fields: Extra fields for the Component, defaults to None. :return: A class definition that can be used as a component. NÚvaluecSsi|]\}}|t|ƒ“qSr)r+)Ú.0Úkeyr2rrrÚ Ësz#component_class..cs tj|fˆŽtj|fˆŽdSr)r Zset_input_typesZset_output_typesr)r/r0rrÚinitÏszcomponent_class..initcsˆdk r ˆSdd„ˆ ¡DƒS)NcSsi|] }|d“qSrr)r3rrrrr5Ùsz0component_class..run..)Úkeys)rÚkwargs)r1r0rrÚrunÖszcomponent_class..runcSst|ƒSrr"rrrrr#Ûsz component_class..to_dict)ÚdatacSs t||ƒSr)r )r-r:rrrr$Þsz"component_class..from_dict)Ú__init__r9r#r$)rÚitemsr+rr'r)r*r ) rr/r0r1rrr6r9r#r$r,r-r)r/r1r0rÚcomponent_classs"I  r=)NNNN)NNNNN)ÚtypingrrrrrrrZhaystack.core.componentr r Zhaystack.core.serializationr r Zhaystack.dataclassesr Zhaystack.document_stores.typesrrr'r&r+r.r=rrrrÚs<$ û ú túù