lia ddlmZddlZddlZddlZddlZddlZddlZddlm Z m Z m Z m Z m Z mZmZmZmZddlZddlmZddlmZddlmZmZddlmZddlmZmZm Z m!Z!m"Z"ddl#m$Z$m%Z%ddl&m'Z'dd l(m)Z)m*Z*dd l+m,Z,m-Z-m.Z.m/Z/m0Z0dd lm1Z1dd l2m3Z4dd l5m6Z6ddl7m8Z8ddl9m:Z:ddl;mm?Z?ddl@mAZAd$dZBd$dZCd$dZDd$dZEd%dZFGddZGd&d'dZHd&d'dZIGddeJZKGddZLGd d!eK"ZMd(d#ZNy))) annotationsN) AnyCallableDictIterableListMappingNoReturnOptionalSet)trackingutils) get_rendered)DumperLoader SafeLoader safe_loadyaml)DEFAULT_ENV_PLACEHOLDERSECRET_PLACEHOLDER)Resource) JinjaLogDebug JinjaLogInfo)EnvVarMissingErrorRequiredVarNotFoundErrorSecretEnvVarLocationErrorSetStrictWrongTypeErrorZipStrictWrongTypeError) get_flags) __version__)SECRET_ENV_PREFIX)get_invocation_context) get_node_info) fire_eventget_invocation_id) PrintEvent MacroReturncjtj}|Dcic]}|tt|c}Scc}wN)pytz__all__getattrcontext_exportsnames U/var/www/html/strategist-ai/venv_dbt/lib/python3.12/site-packages/dbt/context/base.pyget_pytz_module_contextr20s+llO2A B$D'$% % BB B0cRgd}|Dcic]}|tt|c}Scc}w)N)datedatetimetime timedeltatzinfo)r-r6r.s r1get_datetime_module_contextr:6s'IO6E FdD'(D) ) FF Fs$cjtj}|Dcic]}|tt|c}Scc}wr*)rer,r-r.s r1get_re_module_contextr=<s+jjO0? @D'"d# # @@ @r3c dgd}d}|Dcic]}||tt|c}Scc}w)N)countcyclerepeat accumulatechaincompressislicestarmaptee zip_longestproduct permutations combinationscombinations_with_replacementcfd}|S)Nc>tjd|i|S)Nz#modules-itertools-usage-deprecation) deprecationswarn)argskwargsfns r1deprecation_wrapper_innerz\get_itertools_module_context..deprecation_wrapper..deprecation_wrapper_innerXs"   C Dt&v& &)rSrTs` r1deprecation_wrapperz9get_itertools_module_context..deprecation_wrapperWs ')(rU)r- itertools)r/rWr0s r1get_itertools_module_contextrYCs8O")M\ \DD%gi&>? ? \\ \s-cPttttdS)N)r+r6r<rX)r2r:r=rYrVrUr1get_context_modulesr[as$')/1#%13  rUceZdZdddZddZy) ContextMemberNc ||_||_yr*)r0inner)selfvaluer0s r1__init__zContextMember.__init__ks  rUc6|j|S|jSr*r0)r`defaults r1keyzContextMember.keyos 99 NyyrUr*)rarr0 Optional[str]returnNone)restrrhrj)__name__ __module__ __qualname__rbrfrVrUr1r]r]js rUr]cfdS)Nct|SNrd)r]vras r1zcontextmember..vs]151rUrVras`r1 contextmemberruus 11rUcfdS)Nc0tt|Srp)r]propertyrqs r1rsz!contextproperty..zs]8A;U;rUrVrts`r1contextpropertyryys ;;rUceZdZddZy) ContextMetaci}i}i}|D]:}|jt|di|jt|di<|jD]K\}} t| tr1| j |} | j || <||| <| j } | ||<M||d<||d<tj||||S)N_context_members__context_attrs_) updater-items isinstancer]rfr_type__new__) mclsr0basesdctcontext_members context_attrsnew_dctbaserfra context_keys r1rzContextMeta.__new__~s*,(* "$ GD  " "741Db#I J  /@"!E F G))+ !JC%/#iin /4{{ ,-0 k*  GCL  !(7#$%2!"||D$w77rUN)rDict[str, Any]rhr{)rkrlrmrrVrUr1r{r{}s8rUr{cxeZdZeZ d d dZd dZed dZd dZ ddZ ddZ efddZ y)VarNcf||_||_||_||_|j |_yr*)_context _cli_vars_node _require_vars_generate_merged_merged)r`contextcli_varsnode require_varss r1rbz Var.__init__s1,3 ,4)- #/*.*?*?*A rUc|jSr*)rr`s r1rzVar._generate_mergeds ~~rUcH|j|jjSy)Nz)rr0rs r1 node_namez Var.node_names :: !::?? "$rUcp|jr*t|t|j|jyr*)rrdictrrr`var_names r1get_missing_varzVar.get_missing_vars,   *8T$,,5GT T rUc||jvSr*)rrs r1has_varz Var.has_vars4<<''rUc|j|}t|ts|St|t |j Sr*)rrrjrrr)r`rraws r1get_rendered_varzVar.get_rendered_vars5ll8$#s#JCdmm!455rUc|j|r|j|S||jur|S|j|Sr*)rr _VAR_NOTSETr)r`rres r1__call__z Var.__call__sC << !((2 2 D,, ,N''1 1rU)NT) rMapping[str, Any]rrrzOptional[Resource]rboolrhri)rhrrhrj)rrjrhri)rrjrhr)rrjrhr)rrjrerrhr) rkrlrmobjectrrbrrxrrrrrrVrUr1rrs(K $(! B" B$ B! B  B  B%% U (66A2rUrceZdZUded<ded<d#d$dZd%dZd%dZed&dZed'd Z e d(d)d Z e jjd re ed Ze ded*dZe ed(d+dZe ed,d-dZe ed(d.dZe e d, d/dZe ded(d0dZe ed1dZe ded dd2dZe ed3dZe ed4d5dZed6dZed7dZed&dZed%dZed8dZe ed9d Z e e d:d!Z!e ed;d"Z"y )< BaseContextrr}r~rhc<i|_||_i|_||_yr*)_ctxrenv_varsr)r`rrs r1rbzBaseContext.__init__s$& (0 (* ".rUci}|jjD]'\}}t|dr|j|}|||<)|S)N__get__)r}rhasattrr)r`builtinsrfras r1generate_builtinszBaseContext.generate_builtinssQ#%00668 "JCui( d+!HSM  " rUc|j|jd<|j}||jd<|jj||jS)Nrr)rrr)r`rs r1to_dictzBaseContext.to_dictsL#yy )))+ ( * "yyrUctS)aThe `dbt_version` variable returns the installed version of dbt that is currently running. It can be used for debugging or auditing purposes. > macros/get_version.sql {% macro get_version() %} {% set msg = "The installed version of dbt is: " ~ dbt_version %} {% do log(msg, info=true) %} {% endmacro %} Example output: $ dbt run-operation get_version The installed version of dbt is 0.16.0 ) dbt_versionrs r1rzBaseContext.dbt_versions $rUcZt|j|j|jS)ar Variables can be passed from your `dbt_project.yml` file into models during compilation. These variables are useful for configuring packages for deployment in multiple environments, or defining values that should be used across multiple models within a package. To add a variable to a model, use the `var()` function: > my_model.sql: select * from events where event_type = '{{ var("event_type") }}' If you try to run this model without supplying an `event_type` variable, you'll receive a compilation error that looks like this: Encountered an error: ! Compilation error while compiling model package_name.my_model: ! Required var 'event_type' not found in config: Vars supplied to package_name.my_model = { } To supply a variable to a given model, add one or more `vars` dictionaries to the `models` config in your `dbt_project.yml` file. These `vars` are in-scope for all models at or below where they are defined, so place them where they make the most sense. Below are three different placements of the `vars` dict, all of which will make the `my_model` model compile. > dbt_project.yml: # 1) scoped at the model level models: package_name: my_model: materialized: view vars: event_type: activation # 2) scoped at the package level models: package_name: vars: event_type: activation my_model: materialized: view # 3) scoped globally models: vars: event_type: activation package_name: my_model: materialized: view ## Variable default values The `var()` function takes an optional second argument, `default`. If this argument is provided, then it will be the default value for the variable if one is not explicitly defined. > my_model.sql: -- Use 'activation' as the event_type if the variable is not -- defined. select * from events where event_type = '{{ var("event_type", "activation") }}' )r)rrrrrs r1varzBaseContext.vars"F499dmm$:K:KLLrUNcd}|jtr t|tj}||vr||}n||}|||vr|nt |j |<|St|)zThe env_var() function. Return the environment variable named 'var'. If there is no such environment variable set, return the default. If the default is None, raise an exception for an undefined variable. N) startswithr!rr"envrrr)r`rre return_valuers r1env_varzBaseContext.env_var=sz >>+ ,+C0 0$&** #:s8L  "L  # 25AXDMM#  $S) )rUDBT_MACRO_DEBUGGINGcXddl}ddl}|jd}|j|y)z9Enter a debugger at this line in the compiled jinja code.rN)sysipdb _getframe set_trace)rrframes r1debugzBaseContext.debugZs'  MM!$E NN5 !rUct|)afThe `return` function can be used in macros to return data to the caller. The type of the data (`dict`, `list`, `int`, etc) will be preserved through the return call. :param data: The data to return to the caller > macros/example.sql: {% macro get_data() %} {{ return([1,2,3]) }} {% endmacro %} > models/my_model.sql: select -- getdata() returns a list! {% for i in getdata() %} {{ i }} {% if not loop.last %},{% endif %} {% endfor %} r')datas r1_returnzBaseContext._returnfs4$rUcP tj|S#t$r|cYSwxYw)aThe `fromjson` context method can be used to deserialize a json string into a Python object primitive, eg. a `dict` or `list`. :param value: The json string to deserialize :param default: A default value to return if the `string` argument cannot be deserialized (optional) Usage: {% set my_json_str = '{"abc": 123}' %} {% set my_dict = fromjson(my_json_str) %} {% do log(my_dict['abc']) %} )jsonloads ValueError)stringres r1fromjsonzBaseContext.fromjsons*  ::f% % N s  %%cT tj||S#t$r|cYSwxYw)aThe `tojson` context method can be used to serialize a Python object primitive, eg. a `dict` or `list` to a json string. :param value: The value serialize to json :param default: A default value to return if the `value` argument cannot be serialized :param sort_keys: If True, sort the keys. Usage: {% set my_dict = {"abc": 123} %} {% set my_json_string = tojson(my_dict) %} {% do log(my_json_string) %} ) sort_keys)rdumpsrrarers r1tojsonzBaseContext.tojsons,$ ::ey9 9 N s  ''cf t|S#tttjf$r|cYSwxYw)aThe fromyaml context method can be used to deserialize a yaml string into a Python object primitive, eg. a `dict` or `list`. :param value: The yaml string to deserialize :param default: A default value to return if the `string` argument cannot be deserialized (optional) Usage: {% set my_yml_str -%} dogs: - good - bad {%- endset %} {% set my_dict = fromyaml(my_yml_str) %} {% do log(my_dict['dogs'], info=true) %} -- ["good", "bad"] {% do my_dict['dogs'].pop() } {% do log(my_dict['dogs'], info=true) %} -- ["good"] )rAttributeErrorrr YAMLErrorrares r1fromyamlzBaseContext.fromyamls10 U# # DNN; N s 00ct tj||S#ttjf$r|cYSwxYw)aThe `tojson` context method can be used to serialize a Python object primitive, eg. a `dict` or `list` to a yaml string. :param value: The value serialize to yaml :param default: A default value to return if the `value` argument cannot be serialized :param sort_keys: If True, sort the keys. Usage: {% set my_dict = {"abc": 123} %} {% set my_yaml_string = toyaml(my_dict) %} {% do log(my_yaml_string) %} )rr)r safe_dumprrrs r1toyamlzBaseContext.toyamls5( >>u B BDNN+ N s 77setc< t|S#t$r|cYSwxYw)aThe `set` context method can be used to convert any iterable to a sequence of iterable elements that are unique (a set). :param value: The iterable :param default: A default value to return if the `value` argument is not an iterable Usage: {% set my_list = [1, 2, 2, 3] %} {% set my_set = set(my_list) %} {% do log(my_set) %} {# {1, 2, 3} #} )r TypeErrorrs r1_setzBaseContext._sets% u:  N s cR t|S#t$r}t|d}~wwxYw)aThe `set_strict` context method can be used to convert any iterable to a sequence of iterable elements that are unique (a set). The difference to the `set` context method is that the `set_strict` method will raise an exception on a TypeError. :param value: The iterable Usage: {% set my_list = [1, 2, 2, 3] %} {% set my_set = set_strict(my_list) %} {% do log(my_set) %} {# {1, 2, 3} #} N)rrr)raes r1 set_strictzBaseContext.set_stricts, -u:  -)!, , -s & !&zip)rec6 t|S#t$r|cYSwxYw)a1The `zip` context method can be used to used to return an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument iterables. :param *args: Any number of iterables :param default: A default value to return if `*args` is not iterable Usage: {% set my_list_a = [1, 2] %} {% set my_list_b = ['alice', 'bob'] %} {% set my_zip = zip(my_list_a, my_list_b) | list %} {% do log(my_set) %} {# [(1, 'alice'), (2, 'bob')] #} )rr)rerQs r1_zipzBaseContext._zips%" :  N s  cL t|S#t$r}t|d}~wwxYw)aiThe `zip_strict` context method can be used to used to return an iterator of tuples, where the i-th tuple contains the i-th element from each of the argument iterables. The difference to the `zip` context method is that the `zip_strict` method will raise an exception on a TypeError. :param *args: Any number of iterables Usage: {% set my_list_a = [1, 2] %} {% set my_list_b = ['alice', 'bob'] %} {% set my_zip = zip_strict(my_list_a, my_list_b) | list %} {% do log(my_set) %} {# [(1, 'alice'), (2, 'bob')] #} N)rrr)rQrs r1 zip_strictzBaseContext.zip_strict$s," -:  -)!, , -s # #cXdt|vr^dtd}tj|j dd}t j ||}|rt j|d|}|rtt|tytt|ty) aLogs a line to either the log file or stdout. :param msg: The message to log :param info: If `False`, write to the log file. If `True`, write to both the log file and stdout. > macros/my_log_macro.sql {% macro some_macro(arg1, arg2) %} {{ log("Running some_macro: " ~ arg1 ~ ", " ~ arg2) }} {% endmacro %}" DBT_SECRET_START(z(.*))$z\$z*****)msg node_infor) rjr!rformatreplacer<searchsubr$rr#r)rinfo search_grouppatternms r1logzBaseContext.log:s" S )017L(// =EEc5QG AffWgs3  |}G H } H IrUcXtjtjjSy)a`run_started_at` outputs the timestamp that this run started, e.g. `2017-04-21 01:23:45.678`. The `run_started_at` variable is a Python `datetime` object. As of 0.9.1, the timezone of this variable defaults to UTC. > run_started_at_example.sql select '{{ run_started_at.strftime("%Y-%m-%d") }}' as date_day from ... To modify the timezone of this variable, use the the `pytz` module: > run_started_at_utc.sql {% set est = modules.pytz.timezone("America/New_York") %} select '{{ run_started_at.astimezone(est) }}' as run_started_est from ... N)r active_userrun_started_atrs r1rzBaseContext.run_started_at[s%.    +''66 6rUctS)z^invocation_id outputs a UUID generated for this dbt run (useful for auditing) )r%rs r1 invocation_idzBaseContext.invocation_idws !""rUc>tjjS)zDthread_id outputs an ID for the current thread (useful for auditing)) threadingcurrent_threadr0rs r1 thread_idzBaseContext.thread_id~s'')...rUctS)a.The `modules` variable in the Jinja context contains useful Python modules for operating on data. # datetime This variable is a pointer to the Python datetime module. Usage: {% set dt = modules.datetime.datetime.now() %} # pytz This variable is a pointer to the Python pytz module. Usage: {% set dt = modules.datetime.datetime(2002, 10, 27, 6, 0, 0) %} {% set dt_local = modules.pytz.timezone('US/Eastern').localize(dt) %} {{ dt_local }} )r[rs r1moduleszBaseContext.moduless .#$$rUc*tjS)aVThe `flags` variable contains true/false values for flags provided on the command line. > flags.sql: {% if flags.FULL_REFRESH %} drop table ... {% else %} -- no-op {% endif %} This supports all flags defined in flags submodule (core/dbt/flags.py) ) flags_module get_flag_objrs r1flagszBaseContext.flagss((**rUcVtjrtt|y)aPrints a line to stdout. :param msg: The message to print > macros/my_log_macro.sql {% macro some_macro(arg1, arg2) %} {{ print("Running some_macro: " ~ arg1 ~ ", " ~ arg2) }} {% endmacro %}" rr)rPRINTr$r&rs r1printzBaseContext.prints ;   zc* +rUc i}|jDcic]2\}}|j|Dcgc]}|jc}4}}}}|D]}|j|jvrXg}||D]7}|j||jvs'|j|9|sg|j ||i{|j |||i|Scc}wcc}}}w)a Given two dictionaries of type Dict[str, List[str]]: dict_a = {'key_x': ['value_1', 'VALUE_2'], 'KEY_Y': ['value_3']} dict_b = {'key_x': ['value_1'], 'key_z': ['value_4']} Return the same dictionary representation of dict_a MINUS dict_b, performing a case-insensitive comparison between the strings in each. All keys returned will be in the original case of dict_a. returns {'key_x': ['VALUE_2'], 'KEY_Y': ['value_3']} )rcasefoldkeysappendr)dict_adict_b dict_diffkrrxdict_b_lowereddiffs r1diff_of_two_dictszBaseContext.diff_of_two_dictss NTlln]]da!**,q(A!(AA]] 1Azz|~2244'Azz|>!**,+GG A'$$aY/  !VAY0 1)B]sC.C) C.)C.c,tj|S)a!Calculates an MD5 hash of the given string. It's called "local_md5" to emphasize that it runs locally in dbt (in jinja context) and not an MD5 SQL command. :param value: The value to hash Usage: {% set value_hash = local_md5("hello world") %} )rmd5rts r1 local_md5zBaseContext.local_md5syyrU)T)rrrrrhrirhrr)rhrr*)rrjrergrhrj)rrrhr )rrjrerrhr)NF)rarrerrrrhr)rarjrerrhr)rarrergrrrhrg)ra Iterable[Any]rerrhzOptional[Set[Any]])rar"rhzSet[Any])rQr"rerrhzOptional[Iterable[Any]])rQr"rhr")F)rrjrrrhrj)rhzOptional[datetime.datetime])rhrg)rhr)rrjrhrj)rDict[str, List[str]]rr#rhr#)rarjrhrj)#rkrlrm__annotations__rbrrryrrrurosenvironget staticmethodrrrrrrrrrrrrrrr r rrr rVrUr1rrs%%##/ &BMBMH_**4 zz~~+,      8  4_&_*_:_EJ*>B .5$_--$526(_--(_>6## //%%0++ _"_$.B 6_    rUr) metaclassc8t|}|jSr*)rr)rctxs r1generate_base_contextr,s h C ;;=rUr!)rhzDict[str, Dict[str, Any]]r*)rargrhr)rrrhr)O __future__rr6rXrr%r<rtypingrrrrrr r r r r+dbt.deprecationsrO dbt.flagsr r dbtr rdbt.clients.jinjardbt.clients.yaml_helperrrrrr dbt.constantsrrdbt.contracts.graph.nodesrdbt.events.typesrrdbt.exceptionsrrrrrr dbt.versionr rdbt_common.constantsr!dbt_common.contextr"dbt_common.events.contextvarsr#dbt_common.events.functionsr$r%dbt_common.events.typesr&dbt_common.exceptions.macrosr(r2r:r=rYr[r]ruryrr{rrr,rVrUr1r?s" XXX ' *F.8 2257E.4 C G A]<2<8$8,1212ha Ka HrU