o 6d9@sddlmZmZmZmZddlmZddlZddlZddl Z dZ e r&ddl Z ddl Z e edZddlmZmZmZmZmZmZmZmZmZmZmZmZmZmZmZm Z m!Z!m"Z"m#Z#m$Z$m%Z%m&Z&m'Z'm(Z(m)Z)m*Z*m+Z+m,Z,m-Z-m.Z.m/Z/m0Z0m1Z1m2Z2m3Z3m4Z4m5Z5m6Z6m7Z7m8Z8m9Z9m:Z:m;Z;mZ>m?Z?m@Z@mAZAdd lBmCZCdd lDmEZEmFZFmGZGmHZHmIZImJZJmKZKmLZLmMZMmNZNmOZOmPZPmQZQmRZRd d ZSdd dZTddZU dddZVeWdZXeWdZYee0e1e3e4dZZGddde[Z\Gddde]Z^dS))absolute_importdivisionprint_functionunicode_literals) defaultdictNFre)1AliasAnnotationTypeAnnotationTypeParamApi ApiNamespaceApiRouteApiRoutesByVersionBooleanBytesCustomAnnotationDataType DeprecatedDeprecationInfoFloat32Float64Int32Int64is_aliasis_composite_type is_field_type is_list_type is_map_typeis_nullable_typeis_primitive_typeis_struct_typeis_user_defined_type is_union_type is_void_typeListMapNullableOmittedPreviewParameterError RedactedBlot RedactedHashStringStruct StructFieldTagRef TimestampUInt32UInt64Union UnionField UserDefinedVoidunwrap_aliasesunwrap_nullable) InvalidSpec)AstAliasAstAnnotationDefAstAnnotationTypeDef AstImport AstNamespace AstRouteDef AstStructDefAstStructPatch AstTagRef AstTypeDef AstTypeRef AstUnionDef AstUnionPatch AstVoidFieldcCs0|ddddddsJdd|S)N_./z,Only use quote() with names or IDs in Stone.z'%s')replaceisalnumsrRrC:\Users\jesus\OneDrive\Desktop\erpjis_fastapi\backend\jisbackend\Lib\site-packages\stone/frontend/ir_generator.pyquote[s"rTc Csg}t||||d\}}|D]}||q|D])\}} z|j|} | D]} | | D]}||q-q&WqtyC|sAYqw|S)a5 Given a documentation string, parse it and return all references to other data types. If there are references to routes, include also the data types of those routes. Args: - api: The API containing this doc ref. - doc: The documentation string to parse. - namespace_context: The namespace name relative to this documentation. - ignore_missing_entries: If set, this will skip references to nonexistent data types instead of raising an exception. Returns: - a list of referenced data types )ignore_missing_entries)(parse_data_types_and_routes_from_doc_refappenditems namespaces!get_route_io_data_types_for_routeKeyError) apidocnamespace_contextrUoutput data_types routes_by_nsdZns_nameroutesnsrrRrRrSparse_data_types_from_doc_ref`s(     rfcCsXd|vr$|dd\}}z t|}W||fSty#td|w|}d}||fS)z Parse a route representation string and return the route name and version number. :param route_repr: Route representation string. :return: A tuple containing route name and version number. :r:z Invalid route representation: {})splitint ValueErrorformat) route_repr route_nameversionrRrRrSparse_route_name_and_versions  roc Cs~|dusJt}tt}t|D]}z|d}|d}|j|} |dkrAd|vr?|dd\} } | j| } || nn nl|dkrd|vrW|dd\} }|j| }n| }zt |\}}Wnt ys}zt t |d}~ww|j |j|}||j|n(|dkrd|vr|dd\} }|j| j|} || n | j|} || Wqt y|sYqw||fS) a Given a documentation string, parse it and return all references to other data types and routes. Args: - api: The API containing this doc ref. - doc: The documentation string to parse. - namespace_context: The namespace name relative to this documentation. - ignore_missing_entries: If set, this will skip references to nonexistent data types instead of raising an exception. Returns: - a tuple of referenced data types and routes NtagvalfieldrLr:routetype)setr doc_ref_refinditergrouprYrhdata_type_by_nameaddrorjr[strroutes_by_name at_versionname)r\r]r^rUr`rcmatchrprqZsupplied_namespace type_name__Zdoc_typenamespace_name namespacermrnexrsrRrRrSrVsR            rVz:(?P[A-z]+):`(?P.*?)`z4^(null|true|false|-?\d+(\.\d*)?(e-?\d+)?|"[^\\"]*")$)rr(r)r+r,c@seZdZdZdS) EnvironmentN)__name__ __module__ __qualname__rrRrRrRrSrsrc @seZdZeeeeeee e e e e eeg ZedYiddeDZdZddZddZd d Zd d Zd[d dZeddZddZddZddZddZddZddZddZ dd Z!d!d"Z"d#d$Z#d%d&Z$d'd(Z%d)d*Z&d+d,Z'd-d.Z(d/d0Z)d1d2Z*d3d4Z+d5d6Z,d7d8Z-d[d9d:Z.d;d<Z/d=d>Z0d?d@Z1dAdBZ2dCdDZ3dEdFZ4dGdHZ5d\dIdJZ6dKdLZ7dMdNZ8dOdPZ9dQdRZ:dSdTZ;dUdVZ< d\dWdXZ=dS)] IRGeneratorcCi|]}|j|qSrR)r).0 data_typerRrRrS zIRGenerator.FNcCsH||_||_td|_t|d|_i|_t|_ i|_ i|_ ||_ dS)aCreates a new tower of stone. :type specs: List[Tuple[path: str, text: str]] :param specs: `path` is never accessed and is only used to report the location of a bad spec to the user. `spec` is the text contents of a spec (.stone) file. z stone.idl)rnN) _partial_asts_debuglogging getLogger_loggerr r\_env_by_namespaceru_resolution_in_progress_item_by_canonical_name_patch_data_by_canonical_name_routes)selfZ partial_astsrndebugZroute_whitelist_filterrRrRrS__init__s    zIRGenerator.__init__cCsg}|jD]3}||}|j|j}||j|j}||j|<|jdur+||j| ||f| ||q| || | ||||||||jdurk||j|jS)z}Parses the text of each spec and returns an API description. Returns None if an error was encountered during parsing.N)r_extract_namespace_ast_noder\ensure_namespacer~_get_base_namerr]Zadd_docrW!_add_data_types_and_routes_to_api_add_imports_to_env_merge_patches_populate_type_attributes_populate_field_defaults_populate_enumerated_subtypes_populate_route_attributes&_populate_recursive_custom_annotations_populate_examples_validate_doc_refs_validate_annotationsr%_filter_namespaces_by_route_whitelist normalize)rraw_apiZ partial_astZnamespace_ast_noder base_namerRrRrS generate_IRs0        zIRGenerator.generate_IRcCst|dks t|dts#|jr|jd|td|dj|dj|ddD]}t|tr_create_annotation_typeZadd_annotation_typeAssertionError __class__r) rrrenvrapi_typerrsalias annotationannotation_typerRrRrSrPs>                 z-IRGenerator._add_data_types_and_routes_to_apicCs||j|}||jvr||j|<dS|j|}|j|jk}|r"|s>d|||j|||j|j|jf}t||j|jdS)Nz7Name of %s '%s' conflicts with name of %s '%s' (%s:%s).)rr~rr&_get_user_friendly_item_type_as_stringrrr;)rrrrrZ stored_itemZis_conflict_between_same_typemsgrRrRrSrs    z+IRGenerator._check_canonical_name_availablecCsRt|trdSt|trdSt|trdSt|trdSt|tr#dStd|)Nzuser-defined typersrrzannotation typezunhandled type %r)rrErAr<r@r>r)clsrrRrRrSrs      z2IRGenerator._get_user_friendly_item_type_as_stringcCs(|dddd|ddS)NrJrKrM)rNlower)rZ input_strrrRrRrSrszIRGenerator._get_base_namecCs|D]X\}}|D]Q}t|trY|j|jkrtd|j|j|j|jjvr1tdt |j|j|j| |j}| |j}|j|vrTtdt |jt |jf|j|j|||j<qqdS)aH Scans raw parser output for import declarations. Checks if the imports are valid, and then creates a reference to the namespace in the environment. Args: raw_api (Tuple[Namespace, List[stone.stone.parser._Element]]): Namespace paired with raw parser output. z Cannot import current namespace.z(Namespace %s is not defined in any spec.z1Circular import of namespaces %s and %s detected.N) rr?r~targetr;rrr\rYrTr)rrrrrrZ imported_envrRrRrSrs6       zIRGenerator._add_imports_to_envcCsf|j|vr||j}tdt|j|jj|jjf|j|j|j|j}t |j||}|||j<|S)N"Symbol %s already defined (%s:%d).) r~r;rT _ast_noderrr\rrr )rrr existing_dtrrrRrRrSrs   zIRGenerator._create_aliascCs|j|vr||j}tdt|j|jj|jjf|j|j|j|j}|j r3|j r3td|j|j|j durS|j t vrSt |j }||j||g|j Ri|j }n |j durd|j|j|j ddt|j|||j |j |j |j }|||j<|S)NrzCAnnotations accept either positional or keyword arguments, not bothTZimported_annotation_type)r~r;rTrrrr\rrargskwargsannotation_type_nsr"BUILTIN_ANNOTATION_CLASS_BY_STRINGadd_imported_namespacer)rrrrrZannotation_classrrRrRrSrs>      "     zIRGenerator._create_annotationc Csb|j|vr||j}tdt|j|jj|jjf|j|j|j|j}|jt vr8tdt|jf|j|jg}|j D]c}|j rJtd|j|j| ||j d}t|\}} t|trktdt|j|j|j| r~|jr~tdt|j|j|jt|stdt|j|j|j|t|j||j|j|j|q=t|j||j|} | ||j<| S)Nrz,Cannot redefine built-in annotation type %s.z?Annotations cannot be applied to parameters of annotation typesTzParameter {} cannot be Void.zDParameter {} cannot be a nullable type and have a default specified.z      zIRGenerator._create_typecCs|jD]N\}}||j|j}||jvr$tdt|j|j|j |j|}| ||t |t t frK||||j|j7_|||qtd|jjdS)z>Injects object patches into their original object definitions.z5Patch {} must correspond to a pre-existing data_type.Unknown Patch Object Type {}N)rvaluesrr~rr;rkrTrr_check_patch_type_mismatchrrCrH_check_field_names_uniquefields_inject_patched_examplesrrr)r patched_itemZpatched_namespaceZpatched_item_base_name existing_itemrRrRrSrEs$    zIRGenerator._merge_patchescCsdd}t|trt|ts|||ddSdSt|tr?t|ts*|||ddS|j|jkr=||||jr8dnddSdStd|jj )zHEnforces that each patch has a corresponding, already-defined data type.c Ss6d}t|t|jt|j|j|jt||j|j)NzeType mismatch. Patch {} corresponds to pre-existing data_type {} ({}:{}) that has type other than {}.)r;rkrTr~rr)rrZdata_type_name error_msgrRrRrSraise_mismatch_error[szDIRGenerator._check_patch_type_mismatch..raise_mismatch_errorstructunionZ union_closedrN) rrCrBrHrGrrrkrr)rrrrrRrRrSrYs"      z&IRGenerator._check_patch_type_mismatchcCsddd|jD}|jD]$}|j|vr/||j}tdt|jt|j|j|j|j|jq dS)z1Enforces that patched fields don't already exist.cSrrRr~)rfrRrRrSrvrz9IRGenerator._check_field_names_unique..zz9IRGenerator._populate_type_attributes..zUnhandled type: %rrN)#r\rYrrr~rrrrrrrr;rTrZannotation_type_namer set_attributesaliasesrrr]set_annotationsr`_is_forward_refrrzr. _populate_struct_type_attributesr4_populate_union_type_attributesrrtremover) rrrlocZannotation_type_envrrrrrRrrSrs~                  z%IRGenerator._populate_type_attributescCsd}|jj}|rA|||d}t|trtd|jj|jjt|tr-td|jj|jjt|t sAtdt |j |jj|jjg}|jj D] }| ||}||qG||jj||dS)zV Converts a forward reference of a struct into a complete definition. NTz@A struct cannot extend an alias. Use the canonical name instead.z'A struct cannot extend a nullable type.z.recurse..cr rRrRr)rrRrSrIr )rruZrecursive_custom_annotationsrzr!r#rrrZcustom_annotationsrrrvalue_data_typer)rrZdata_types_seenrecurse)rrrrSr/s8     zCIRGenerator._populate_recursive_custom_annotations..recurseTrN)rur\rYrr`rrrc arg_data_typeresult_data_typeerror_data_typerrr~r)rrZnamespace_annotationsrrrsrJrrRrrSr's*'    z2IRGenerator._populate_recursive_custom_annotationsc Cs|jjD]m}|jD]g}t|tsq |jD][}|jjsqt|jj t r.t |j |jj j }n|jj }|jjjr;|duslz|j jdvrFt|}|j |Wntyk}ztdt|jj|f|jj|jjd}~ww||qq qdS)z Populate the defaults of each field. This is done in a separate pass because defaults that specify a union tag require the union to have been defined. N)rrz#Field %s has an invalid default: %s)r\rYrr`rr.rrrrrDr0rrprnullabler~floatcheckrjr;rTrr set_default)rrrrr default_valuerrRrRrSrls<       z$IRGenerator._populate_field_defaultscCsP|}|j||jjD]}||j}|jD] }||||qqdS)zV Converts all routes from forward references to complete definitions. N) _validate_stone_cfgr\Zadd_route_schemarYrrr~rc!_populate_route_attributes_helper)rZ route_schemarrrsrRrRrSrs   z&IRGenerator._populate_route_attributesc Cs|||jj}|||jj}|||jj}|jj}|r|ds$J|d}|d} |r~| s2Jd} d} ||vrNt||trK| ||jvrJd} nd} nd} | rbt dt || f|jj |jj | rrt dt ||jj |jj ||j| } t | } nt } nd} i}|jjD]}|||j<qz||}Wnty}zt d |jd|jj |jj d}~ww|j| |jj||||d dS) z\ Converts a single forward reference of a route into a complete definition. rr:rFTz!Undefined route %s at version %d.z%s must be a route.Nz$Route does not define attr key '%s'.) deprecatedr]rrrattrs)rrZ arg_type_refZresult_type_refZerror_type_refrrrr}r;rTrrrrr~Zcheck_attr_reprr[rrr])rrrsZschemaZarg_dtZ result_dtZerror_dtZast_deprecatedZnew_route_nameZnew_route_versionZis_not_definedZ is_not_routeZ new_routerZ attr_by_nameattrZvalidated_attrsrrRrRrSrsn          z-IRGenerator._populate_route_attributes_helpercst|trtdt|j|j|j|j}fdd|j D}t|t r6tdt|j|j|jt|t rK|j rKtdt|j|j|jt |j||j|d}|||S)a This function resolves symbols to objects that we've instantiated in the current environment. For example, a field with data type named "String" is pointed to a String() object. The caller needs to ensure that this stone_field is for a Struct and not for a Union. Returns: stone.data_type.StructField: A field of a struct. z(Struct field %s cannot have a Void type.crrRrrrrRrSrrz4IRGenerator._create_struct_field..z@Field %s cannot be a nullable type and have a default specified.r~rr]r)rrIr;rTr~rrrrrr7r'rr/r]r)rrrrrr rRrrSrs@    z IRGenerator._create_struct_fieldcsfdd|jD}t|trt|jt|j|d}n#|j}t|tr5t dt |j|j |j t|j||j|d}| ||S)a This function resolves symbols to objects that we've instantiated in the current environment. For example, a field with data type named "String" is pointed to a String() object. The caller needs to ensure that this stone_field is for a Union and not for a Struct. Returns: stone.data_type.UnionField: A field of a union. crrRrrrrRrSrrz3IRGenerator._create_union_field..rzBUnion member %s cannot have Void type explicit, omit Void instead.)rrrIr5r~r7r]rrr;rTrrr)rrrrr rrRrrSr s*     zIRGenerator._create_union_fieldc Cst|ts Jd|t|j}|jdt|j}t|jp!d}|\}}||t|krEt dt |jt|t |j fg|R||t|krZt dt |j g|Ri} t |jD] \} } | ||k| | <qa|D]*} | | vrt dt | t |j fg|R| | st dt | g|R| | =qpz||i|WSt y} zt dt |j | jd fg|Rd } ~ ww) a Responsible for instantiating a data type with additional attributes. This method ensures that the specified attributes are valid. Args: data_type_class (DataType): The class to instantiate. data_type_attrs (dict): A map from str -> values of attributes. These will be passed into the constructor of data_type_class as keyword arguments. Returns: stone.data_type.DataType: A parameterized instance. z)Expected stone.data_type.DataType, got %rrrRz*Missing positional argument %s for %s typez)Too many positional arguments for %s typezUnknown argument %s to %s type.zAPositional argument %s cannot be specified as a keyword argument.zBad argument to %s type: %srN) issubclassrinspect getargspecrrrrdefaultsr;rTr enumerater*) rZdata_type_classZdata_type_argsrZargspecnum_args num_defaultspos_argskw_argsrirrrRrRrS_instantiate_data_type$sn    z"IRGenerator._instantiate_data_typec CsR|j|jf}|j}|jr5|j|vrtdt|jg|R||j}t|ts5tdt|jg|R|j|vrGtdt|jg|R||j}|t ur[|j r[tdg|Rt |rs| ||j}||||j|jf}n)t|trtdg|R|jds|jdrtdt|jg|R||j}|jr|j|} t|tr| j|j|jd d nt|tr| j|j|jd d |r t|tr |jr ||jvrtd t|jg|R|j|t|tr|||n t|tr||||j||j r't|\} } t| tr#td g|Rt|}|S)z Resolves the data type referenced by type_ref. If `enforce_fully_defined` is True, then the referenced type must be fully populated (fields, parent_type, ...), and not simply a forward reference. rrzSymbol %s is undefined.zVoid cannot be marked nullable.z"A route cannot be referenced here.rr:z8Attributes cannot be specified for instantiated type %s.T)Zimported_data_type)Zimported_aliasz,Unresolvable circular reference for type %s.z3Cannot mark reference to nullable type as nullable.) rrrrdr;rTrrr~r7rr isclass _resolve_argsrr)rr\rr6rr rrrzr.rr4rrr8r') rrrZenforce_fully_definedrZorig_namespace_nameobjZresolved_data_type_argsrrZ unwrapped_dtrJrRrRrSrgs                         zIRGenerator._resolve_typecCs|j|jf}|jr2|j|vrtdt|jg|R||j}t|ts2tdt|jg|R|j|vrDtdt|jg|R||jS)zL Resolves the annotation type referenced by annotation_ref. rrzAnnotation %s does not exist.)rrrdr;rTrrr)rrZannotation_refrrRrRrSrs,         z$IRGenerator._resolve_annotation_typecsF|\}}fddfdd|D}fdd|D}||fS)zk Resolves type references in data type arguments to data types in the environment. cst|tr |S|SN)rrFr)vrrRrS check_values  z.IRGenerator._resolve_args..check_valuecsg|]}|qSrRrR)rZpos_argr/rRrSrrz-IRGenerator._resolve_args..csi|] \}}||qSrRrR)rkr.r0rRrSrsz-IRGenerator._resolve_args..)rX)rrrr&r'Z new_pos_argsZ new_kw_argsrR)r/rrrSr+s zIRGenerator._resolve_argscCs|j|vrOt||jtr6|j||jjvr5||jj|j}tdt|j|j|jj|jj f|j |jn||j}tdt|j|jj|jj f|j |jt||j<t |j|j|d}|||jj|j<|S)a Constructs a route and adds it to the environment. Args: env (dict): The environment of defined symbols. A new key is added corresponding to the name of this new route. item (AstRouteDef): Raw route definition from the parser. Returns: stone.api.ApiRoutesByVersion: A group of fully-defined routes indexed by versions. z/Route %s at version %d already defined (%s:%d).r)r~rnr) r~rrrnr}r;rTrrrr)rrrrrsrRrRrSrs8   zIRGenerator._create_routecCs8||jvr |j|}|St|j}||_||j|<|Sr-)rcopy default_envr)rrrrRrRrSrs    zIRGenerator._get_or_create_envc CsT|jjD]}||j}|jD]a}t|tr|jj sqg}|jj dD]B}|j j}|j j }|j j }|j j|vrCt dt||||||j d} t| tsZt dt|||t|j| d|} || q%|||jj dq|jD]0}t|tr|sqv|D]}|jst|jj dkrt d|jj|jjj |jjj qqvqdS)NrzUndefined type %s.Tz'Enumerated subtype %s must be a struct.r:z Subtype '%s' cannot be extended.)r\rYrrr~r`rr.rsubtypesrrrr;rTrr5rWZset_enumerated_subtypeshas_enumerated_subtypesget_enumerated_subtypesrr) rrrrZsubtype_fieldsZ subtype_fieldZ subtype_namerrsubtyperrRrRrSrsj             z)IRGenerator._populate_enumerated_subtypescCsd|jjD]}|jD]}|jjD]}||qq q|jjD] }|jD]}|q(q#dS)aWConstruct every possible example for every type. This is done in two passes. The first pass assigns examples to their associated types, but does not resolve references between examples for different types. This is because the referenced examples may not yet exist. The second pass resolves references. N)r\rYrr`rrZ _add_exampleZ_compute_examples)rrrZexamplerRrRrSr@s    zIRGenerator._populate_examplesc Cs|jjD]U}||j}|jD]0}|jr'|||j|jj d|jj f||j D]}|jr@|||j|jj d|jj f|q*q|j D]}|jrZ|||j|jj d|jj fqEqdS)z Validates that all the documentation references across every docstring in every spec are formatted properly, have valid values, and make references to valid symbols. r:N) r\rYrrr~r`r]_validate_doc_refs_helperrrrrrc)rrrrrrrsrRrRrSrQs<    zIRGenerator._validate_doc_refsc sXt|D]}|d}|d|dkrdvrdd\}||vr4tdt|fg|Rt||trKtdtt|fg|Rt||trbdd\}}|||} nt||t ro||j } n||} t fd d | j Dstd tg|Rq|d usJt fd d |j Dstd tg|Rq|dkrd dkrtdksntdtg|Rq|dkr8dvrdd\}||vrtd|g|R||} n|} t\} } | | vr tdt| g|Rt| | ts!tdt| g|R| | | jvr7tdt| | g|Rq|dkrdvr^dd\}||vrYtd|g|R||} n|} | vrotdg|Rt| ttfstdtg|Rq|dkrtstdtg|Rqtdt|g|Rd S)a Validates that all the documentation references in a docstring are formatted properly, have valid values, and make references to valid symbols. Args: env (dict): The environment of defined symbols. doc (str): The docstring to validate. lineno (int): The line number the docstring begins on in the spec. type_context (stone.data_type.UserDefined): If the docstring belongs to a user-defined type (Struct or Union) or one of its fields, set this to the type. This is needed for "field" doc refs that don't name a type to be validated. rprqrrrLr:z1Bad doc reference to field %s of unknown type %s.z*Bad doc reference to field %s of route %s.rc3|]}|jkVqdSr-rrrr) field_namerRrS z8IRGenerator._validate_doc_refs_helper..z&Bad doc reference to unknown field %s.Nc3r9r-rr:)rqrRrSr<r=link zJBad doc reference to link (need a title and uri separated by a space): %s.rsz(Unknown doc reference to namespace '%s'.z"Unknown doc reference to route {}.z(Doc reference to type {} is not a route.z3Doc reference to route {} has undefined version {}.rtz#Unknown doc reference to type '%s'.z2Doc reference to type %s is not a struct or union.zBad doc reference value %s.zUnknown doc reference tag %s.)rvrwrxrhr;rTrrrr rany all_fieldsrfindrrorkr}r.r4doc_ref_val_rer) rrr]r type_contextrrprrZdata_type_to_checkZ env_to_checkrmrnrR)r;rqrSr8os        $               z%IRGenerator._validate_doc_refs_helpercCsZ|jjD]$}|jD]}|jD] }|jr||qq |jD] }|jr)||qqdS)a Validates that all annotations are attached to proper types and that no field has conflicting inherited or direct annotations. We need to go through all reference chains to make sure we don't override a redactor set on a parent alias or type N) r\rYrr`rredactor+_validate_field_can_be_tagged_with_redactorr,_validate_object_can_be_tagged_with_redactor)rrrrrrrRrRrSrs     z!IRGenerator._validate_annotationscCs,t|jrtd|jj|jj||dS)z~ Validates that the field type can be annotated and that alias does not have conflicting annotations. zLRedactors can only be applied to alias definitions, not to alias references.N)rrr;rrrrG)rrrrRrRrSrFs  z7IRGenerator._validate_field_can_be_tagged_with_redactorcCs|j}|j}|jj|jjf}|}t|tst|tr@t|dr3|j r3t dt |t |jfg|R|j}t|tst|tst|dr~|j rt |sPt |rn t |rY|j}n|j}t |pgt |pgt|}|durmnqQt|svt|rt dg|RdSdSdS)z{ Validates that the object type can be annotated and object does not have conflicting annotations. rEz5A redactor has already been defined for '%s' by '%s'.TFz9Redactors can't be applied to user-defined or void types.N)rr~rrrrr r'hasattrrEr;r{rrrrr"r$)rZannotated_objectrr~rZcurr_data_typeZshould_continuerRrRrSrGs: z8IRGenerator._validate_object_can_be_tagged_with_redactorcCsdd}z |jjd}Wn ty|YSw|jr,|jd}td|jj|jj|j s2|S|j D]}|j dkrFtd|jj|jjq5|S)zN Returns: Struct: A schema for route attributes. cSs"tdtdd}|dgd|S)NRoute stone_cfg)r.r rrPrRrRrSmk_route_schema&sz8IRGenerator._validate_stone_cfg..mk_route_schemarJrz4No routes can be defined in the stone_cfg namespace.rIzFOnly a struct named 'Route' can be defined in the stone_cfg namespace.) r\rYrr[rcr;rrrr`r~)rrKrJrsrrRrRrSr!s0      zIRGenerator._validate_stone_cfgcCs6|jdus Jdd|jvsJd|jvsJi}|jdD]<\}}g}|dgkr:|jj|}dd|jD}n|D]}t|\}}|dkrR|d ||q<||q<|||<q g} |D]l\}}||jjvrstd ||jj|}|j dur| t |j|j |d|vsJ|D]=} t| \}}||j vs||j |j vrtd ||f|j |j |} | || | j dur| t |j| j |qqc|jdD]I\}} ||jjvrtd ||jj|}|j dur| t |j|j || D] } | |jj|jvrtd | |jj|j| }| |qq|| \}}|jjD]j}tt||j}||_d d|D|_dd||jD}|j|vrb||j}tt||}n|}g}|D]}t|\}}|j |j |} || qhg|_i|_i|_ ||D]} || qq.dS)z Given a parsed API in IR form, filter the user-defined datatypes so that they include only the route datatypes and their direct dependencies. NzMissing route whitelistroute_whitelistZdatatype_whitelist*cSg|]}|qSrRZname_with_version)rrsrRrRrSrWrzEIRGenerator._filter_namespaces_by_route_whitelist..r:z{}:{}zNamespace %s is not defined!z&Route %s at version %d is not defined!zDatatype %s is not defined!cSrrRr)rrbrRrRrSrrzEIRGenerator._filter_namespaces_by_route_whitelist..cSrNrRrO)rZ output_routerRrRrSrr )rrXr\rYrcrorWrkrr]extendrfr|r}rZry_find_dependenciesrlistrur~r`Z route_by_namesortr)rrLrZ route_reprsZnew_route_reprsrrlrmrnZroute_data_typesZ routes_reprrsZdatatype_namesZ datatype_namerZoutput_types_by_nsZoutput_routes_by_nsr`Zoutput_route_reprsZwhitelisted_route_reprsrcrRrRrSrHs                      z1IRGenerator._filter_namespaces_by_route_whitelistcCs8tt}tt}t}|D] }|||||q ||fSr-)rrRru_find_dependencies_recursive)rr` output_types output_routesseentrRrRrSrQs zIRGenerator._find_dependenciesc Cs||vrdSt|r dSt|st|r||||jj||jD] }|j|||||dq%|j dur@||j ||||j durt |j |j |jj\}}|D] } || |||qS| D](\} } |j j| } | D]} || | | | }|D] }|||||q~qnqbt|r|r|D]}|j|||||dqdSdSdSt|st|r(t||duksJt|r|jj}n|jj}||||j||||j dur$t |j |j |\}}|D] } || |||q| D],\} } |j j| } | D]} || | | | }|D] }|||||qqqdSdSt|s2t|rB||||j|||dSt|r`||||j|||||j|||dSJd|)N)rDFzUnexpected type in: %s)r r!r#rzrr~rWrArTrr]rVr\rXrYrZr5r6rrrrrrZ key_data_typer)rrrWrUrVrDrrZ doc_typesrarXrrcZroute_namespacersZ route_typesZ route_typer7r^rRrRrSrTs                          z(IRGenerator._find_dependencies_recursiverR)FNFr-)>rrrrrrrrrr%r&r-r1r2r3r7r`rr3rrrrr classmethodrrrrrrrrrrrrrrrrrrrr r)rrr+rrrrrr8rrFrGrrrQrTrRrRrRrSrs|    / !!.  @#8E$ @) CR' 0 r #'k rrY)_ __future__rrrr collectionsrr2r rZ_MYPYtyping importlib import_moduler{rZirr r r r r rrrrrrrrrrrrrrrrrrr r!r"r#r$r%r&r'r(r)r*r+r,r-r.r/r0r1r2r3r4r5r6r7r8r9 exceptionr;astr<r=r>r?r@rArBrCrDrErFrGrHrIrTrfrorVcompilervrCrdictrobjectrrRrRrRrSs<  4@   @