ZTh/*ddlmZddlZddlmZddlmZmZmZm Z m Z m Z ddl Z ddl mZmZddlmZddlmZddlmZmZdd lmZmZej4d Zdd Zdd Zdd ZddZddZ ddZ!GddeZ"GddeZ#GddeZ$y)) annotationsN)Path)AnyDictListLiteralUnioncast) NotRequired TypedDict)YamlConfigError)RuleActionAnnotationKind)ChannelConfigYamlSpec_validate_channel_reference)_handle_subdir _type_fqnz^\$[a-zA-Z_]+$ci}|D]=}t|}|jD]\}}||vrtd|d|||<?|S)a Takes in a list of paths to YAML files which contains named expressions and processes them into a `dict`. The key is the name of the expression and the value is the expression itself. For more information on named expression modules see `sift_py/yaml/rule.py`. ztD+113 +JD$((%RSWRXXZ['+ d #  ++ cgdfd }|D]8}|jr t|| |js1||:S)z Takes in a list of paths which may either be directories or files containing rule module YAML files, and processes them into a `list`. For more information on rule modules see RulemoduleYamlSpec in `sift_py/yaml/rule.py`. c>t|}j|y)N)_read_rule_module_yamlextend)rule_module_path rule_module rule_moduless rupdate_rule_modulesz.load_rule_modules..update_rule_modules4s,-=> K(r)r$r)is_dirris_file)rr'rr&s @rload_rule_modulesr*+sM(*L)& ;;= 4!4 5 \\^  % & rc t|d5}ttttft j |j }|jD]I\}}t|tstd|d|dt|tr9td|d|dttttf|cdddS#1swYyxYw)Nr Expected 'z-' to be a string in named expression module 'rzExpected expression of ') openr rryaml safe_loadreadr isinstancestrr )rfrkeyvalues rrrAs dC 7A c3h1IJ+113 JCc3'% %RSWRXXZ[eS)%.se3`ae`ffhi  DcN$56 7 7 7sBC/CCc t|d5}ttttft j |j }|jd}t|ts!td|d|dttttt|D] }t|ttt|cdddS#1swYyxYw)Nr,rulesr-z%' to be a list in rule module yaml: '')r.r rrr/r0r1getr2listr r RuleYamlSpecr_validate_rule)rr4 module_rulesr8rules rr"r"Rs dC /ADcNDNN1668,DE   )%&!UG#Ha\*+-  cE* !D 4  !D&. / / /s B>CCcttttf|}|jd}t |t st j|dddg|jd}|at |ts*t j|ddttddgttt|D] }t||jd }|Yt |tst j|d d dg|D]+}t |t rt j|d ddg|jd }|jd}|jd} |jd} |jd} |jd} |jd} |jd}|jd}|)t |t st j|dddg|)t |t st j|dddgt | trVttttf| jd}t |t sCt j|ddddgt | t st j| dddgtDcgc]}|j}}| |vr(t j| ddj!|dg| )t | t st j| dddg| )t | tst j| dd dg| Pt |tst j|dddgttt| D] }t#||)t |tst j|d d dg|*t |tst j|d!d dgyycc}w)"Nrz- namer3r8channel_referencesz- channel_referenceszList[Dict[str, z]]contextual_channelsz- contextual_channelsz List[str]z- contextual_channels[]rule_client_key description expressiontypeassigneetagssub_expressions asset_names tag_namesz- rule_client_keyz - descriptionz - expressionz | z- typez | z - assigneez- tags- sub_expressionsz%List[Dict[str, List[Dict[str, str]]]]z - asset_namesz - tag_names)r rrr:r2r3r _invalid_propertyr;rrrrdictrr6join_validate_sub_expression)valr?rrAchannel_referencerBchannelrCrDrE rule_typerGrHrIrJrKexpression_namekindvalid_rule_typessub_expressions rr=r=bs S#X $D 88F D dC //hyQQ"67%,d3!33"&!),A"B!C2F  "&d3i1C!D ;  '(9 : ;((#89&-t4!33#'  + Ggs+%77-I  hh01O((=)K,'J Ixx #H 88F Dhh01O((=)K%I":os+K// 0%'  z+s'C// _eV]U^__*d#tCH~z:>>vF/3/!33.)   C (//   , I   0HHt HH((//   JJ' ( I   Jx$=//    I     4 6//    I   ",d3!33"#7  #49o> 5N $^ 4 5z+t'D//    I   Z 4%@//    I   &A]Is>O?cttttf|}|jD]P}t |t st j|ddddgtj|Ct d|dy)Nz- zDict[str, Any]r8rLzInvalid sub-expression key, 'zM'. Characters must be in the character set [a-zA-Z_] and prefixed with a '$'.) r rrkeysr2r3r rM_SUB_EXPRESSION_REGEXmatch)rQrXr5s rrPrPs$sCx.#.N""$ #s#!33 -.   ! & &s + 3!/u5BC  rceZdZUdZded<y)RuleModuleYamlSpecz The formal definition of what a rule module looks like in YAML. `rules`: A list of rules that belong to the module. List[RuleYamlSpec]r8N__name__ __module__ __qualname____doc____annotations__rrr^r^s rr^ceZdZUdZded<ded<ded<ded<d ed <ded <d ed <ded<d ed<ded<d ed<d ed<y)r<a The formal definition of what a single rule looks like in YAML. `name`: Name of the rule. `rule_client_key`: User-defined string-key that uniquely identifies this rule config. `description`: Description of rule. `expression`: Either an expression-string or a `sift_py.ingestion.config.yaml.spec.NamedExpressionYamlSpec` referencing a named expression. `type`: Determines the action to perform if a rule gets evaluated to true. `assignee`: If `type` is `review`, determines who to notify. Expects an email. `tags`: Tags to associate with the rule. `channel_references`: A list of channel references that maps to an actual channel. More below. `contextual_channels`: A list of channel configs that provide context but aren't directly used in the expression. `sub_expressions`: A list of sub-expressions which is a mapping of place-holders to sub-expressions. Only used if using named expressions. `asset_names`: A list of asset names that this rule should be applied to. ONLY VALID if defining rules outside of a telemetry config. `tag_names`: A list of tag names that this rule should be applied to. ONLY VALID if defining rules outside of a telemetry config. Channel references: A channel reference is a string containing a numerical value prefixed with "$". Examples include "$1", "$2", "$11", and so on. The channel reference is mapped to an actual channel config. In YAML it would look something like this: ```yaml channel_references: - $1: *vehicle_state_channel - $2: *voltage_channel contextual_channels: - name: log ``` Sub-expressions: A sub-expression is made up of two components: A reference and the actual sub-expression. The sub-expression reference is a string with a "$" prepended to another string comprised of characters in the following character set: `[a-zA-Z0-9_]`. This reference should be mapped to the actual sub-expression. For example, say you have kinematic equations in `kinematics.yml`, and the equation you're interested in using looks like the following: ```yaml kinetic_energy_gt: 0.5 * $mass * $1 * $1 > $threshold ``` To properly use `kinetic_energy_gt` in your rule, it would look like the following: ```yaml rules: - name: kinetic_energy description: Tracks high energy output while in motion type: review assignee: bob@example.com expression: name: kinetic_energy_gt channel_references: - $1: *velocity_channel sub_expressions: - $mass: 10 - $threshold: 470 tags: - nostromo ``` r3rzNotRequired[str]rCrDz#Union[str, NamedExpressionYamlSpec]rEz*Union[Literal['phase'], Literal['review']]rFrGzNotRequired[List[str]]rHz3NotRequired[List[Dict[str, ChannelConfigYamlSpec]]]rArBz!NotRequired[List[Dict[str, str]]]rIrJrKNr`rfrrr<r<sQ:x I%%!!33 44  KK//66''%%rr<ceZdZUdZded<y)NamedExpressionYamlSpecah A named expression. This class is the formal definition of what a named expression should look like in YAML. The value of `name` may contain a mix of channel references and channel identifiers. For a formal definition of channel references and channel identifiers see the following: `sift_py.ingestion.config.yaml.spec.RuleYamlSpec`. r3rNr`rfrrririNs Irri)r List[Path]returnDict[str, str])rrjrkr_)rrrkrl)rrrkr_)rQr)% __future__rrepathlibrtypingrrrrr r r/typing_extensionsr r #sift_py.ingestion.config.yaml.errorr sift_py.rule.configrsift_py.yaml.channelrrsift_py.yaml.utilsrrcompiler[rr*rr"r=rPr^r<rirfrrrws" 88 4?89" #45,,7" / B J$H&9H&V i r