liddlmZddlZddlZddlmZmZddlmZm Z m Z m Z m Z m Z mZddlmZddlmZmZddlmZmZeZGdd eZGd d eZGd d eZeddeZeddZGddee eZy)) annotationsN)ABCabstractmethod)AnyCallableClassVar GeneratorGenericTypeTypeVar)ParsingException)PARSING_CONTEXT_KEYParsingContext) BaseModelroot_validatorceZdZdZddZy)HashableBaseModelz/Extends BaseModel with a generic hash function.cbttj|jddS)NT) sort_keys)hashjsondumpsselfs q/var/www/html/strategist-ai/venv_dbt/lib/python3.12/site-packages/dbt_semantic_interfaces/implementations/base.py__hash__zHashableBaseModel.__hash__s#DJJtyy4y8DIJJN)returnint)__name__ __module__ __qualname____doc__rrrrrs 9Krrc4eZdZdZGddZddZddZy)FrozenBaseModelz0Similar to HashableBaseModel but faux immutable.ceZdZdZdZy)FrozenBaseModel.ConfigzPydantic feature.FN)r r!r"r#allow_mutationr$rrConfigr(s rr*cz|j}tj|}tj|dS)z(Convert to a pretty JSON representation.)indent)rloadsr)r raw_json_strjson_objs rto_pretty_jsonzFrozenBaseModel.to_pretty_json"s,yy{ ::l+zz(1--rc"|jS)N)__repr__rs r__str__zFrozenBaseModel.__str__(s}}rN)rstr)r r!r"r#r*r1r4r$rrr&r&s: . rr&cJeZdZUdZdZded<eded dZy) ModelWithMetadataParsingaIPydantic model object with a root validator for converting ParsingContext into Metadata]. To use this validator the model class in question MUST have a field with the following base specification: metadata: Optional[Metadata] This class does NOT define the metadata itself because Pydantic's parsing and validation can be dependent on the order in which the model properties are listed in the class definition. Therefore, we prefer to keep this generic and allow callers to add the metadata field wherever we encounter parsing context information. metadataz ClassVar[str]__METADATA_KEY__T)prect|tstd|d||j}|j|vr|St |vr|S|j t }t|tstdt|d|d||jtjj|jd|j|j|j dd||j<|S) aTakes info from parsing context and converts it to a Metadata model object. Per Pydantic's processing logic, this runs on the collection of input data for whatever model object is doing its parser walk. Since we set pre to True this should happen before any of the properties in the model is allowed to access the input values, which allows us to update them to include the appropriate inputs for defined Metadata object properties. z;Input values should be an object (dict) type, but got type(z) with value: zGParsing context should always be a ParsingContext object, but we got a z with value: z inside payload: )filenamecontentstart_line_numberend_line_number)repo_file_path file_slice) isinstancedict ValueErrorkeysr9rpoprr typer=ospathsplitr> start_lineend_line)clsvaluesrFcontexts r%extract_metadata_from_parsing_contextz>ModelWithMetadataParsing.extract_metadata_from_parsing_context<s&$'MfXUcdjckl  {{}   4 'M d *M**01'>2"YZ^_fZgYhi&i'8B  &..GGMM'*:*:;B?"??%,%7%7#*#3#3 ( s##$ rN)rOPydanticParseableValueTyperrR) r r!r"r#r9__annotations__r classmethodrQr$rrr7r7,s3 '1m0((rr7ModelObjectT_coT) covariantbound SelfTypeTPydanticCustomInputParser)rWcpeZdZdZe ddZe ddZee ddZy)rYaImplements required methods for enabling custom parsing for Pydantic BaseModel objects. This abstract class helper is for the specific case where model object classes need to do custom parsing prior to object initialization, meaning that the inputs to the initializer itself must be parsed in a manner custom to the object, but without updating the input values for the rest of the model hierarchy. This class will NOT allow for custom handling of dict or object type inputs, assuming that they should be processed and validated in the standard Pydantic way. Any subclass needing to mutate the inputs from a dict or object type in a subclass-specific way should still be able to do so via the standard Pydantic approach of adding a method decorated with @validator or @root_validator, which will work internally to initialization and validation of that model object itself. c#(K|jyw)azPydantic magic method for allowing parsing of arbitrary input on parse_obj invocation. This allows for parsing and validation prior to object initialization. Most classes implementing this interface in our model are doing so because the input value from user-supplied YAML will be a string representation rather than the structured object type. N)6_PydanticCustomInputParser__parse_with_custom_handling)rNs r__get_validators__z,PydanticCustomInputParser.__get_validators__|s...scpt|tr|di|St||r|S|j|S)aCore method for handling common valid - or easily validated - input types. Pydantic objects can commonly appear as JSON object types (from, e.g., deserializing a Pydantic-serialized model) or direct instances of the model object class (from, e.g., initializing an object and passing it in to the initializer of a containing model object). This internal wrapper handles both of these cases in the standard Pydantic way of either validating the object type input on initialization, or passing the already-validated instance along as the output. Note this will also pass any Pydantic instance initialized via the `construct` method, which means it is possible for a caller to thread an unvalidated - and therefore improperly initialized - instance through. However, this is part of the contract with `construct` - it is only to be used when the inputs are known to the caller to be pre-validated, and so we do not bother guarding against that here. r$)rCrD_from_yaml_valuerNinputs r__parse_with_custom_handlingz6PydanticCustomInputParser.__parse_with_custom_handlings:" eT "<<  s #L''. .rct)zrls" #MMM;8!K K'$:y:z+t9M K'B C 8$W_%=8$r