def _load_profile(self): if not os.path.exists(self.profile_path): self.profile_fail_details = FILE_NOT_FOUND self.messages.append(MISSING_PROFILE_MESSAGE.format( path=self.profile_path, url=ProfileConfigDocs )) return red('ERROR not found') try: raw_profile_data = load_yaml_text( dbt.clients.system.load_file_contents(self.profile_path) ) except Exception: pass # we'll report this when we try to load the profile for real else: if isinstance(raw_profile_data, dict): self.raw_profile_data = raw_profile_data self.profile_name = self._choose_profile_name() self.target_name = self._choose_target_name() try: self.profile = Profile.from_args(self.args, self.profile_name, self.cli_vars) except dbt.exceptions.DbtConfigError as exc: self.profile_fail_details = str(exc) return red('ERROR invalid') return green('OK found and valid')
def _load_profile(self): if not os.path.exists(self.profile_path): self.profile_fail_details = FILE_NOT_FOUND self.messages.append( MISSING_PROFILE_MESSAGE.format(path=self.profile_path, url=ProfileConfigDocs)) return red('ERROR not found') try: raw_profile_data = load_yaml_text( dbt.clients.system.load_file_contents(self.profile_path)) except Exception: pass # we'll report this when we try to load the profile for real else: if isinstance(raw_profile_data, dict): self.raw_profile_data = raw_profile_data self.profile_name = self._choose_profile_name() self.target_name = self._choose_target_name() try: self.profile = Profile.from_args(self.args, self.profile_name) except dbt.exceptions.DbtConfigError as exc: self.profile_fail_details = str(exc) return red('ERROR invalid') return green('OK found and valid')
def get_credentials(profile_yml): "Render a YAML string profiles.yml into credentials" dicty_thing = load_yaml_text(profile_yml) renderer = dbt.config.renderer.ProfileRenderer(generate_base_context({})) profile = dbt.config.Profile.from_raw_profiles(dicty_thing, 'default', renderer) return profile.credentials
def selector_data_from_root(project_root: str) -> Dict[str, Any]: selector_filepath = resolve_path_from_base('selectors.yml', project_root) if path_exists(selector_filepath): selectors_dict = load_yaml_text(load_file_contents(selector_filepath)) else: selectors_dict = None return selectors_dict
def _yaml_from_file(self, source_file: SourceFile) -> Optional[Dict[str, Any]]: """If loading the yaml fails, raise an exception. """ path: str = source_file.path.relative_path try: return load_yaml_text(source_file.contents) except ValidationException as e: reason = validator_error_message(e) raise CompilationException('Error reading {}: {} - {}'.format( self.project.project_name, path, reason)) return None
def read_profile(profiles_dir): path = os.path.join(profiles_dir, 'profiles.yml') contents = None if os.path.isfile(path): try: contents = load_file_contents(path, strip=False) return load_yaml_text(contents) except ValidationException as e: msg = INVALID_PROFILE_MESSAGE.format(error_string=e) raise ValidationException(msg) return {}
def parse_vars(vars: Optional[Union[str, dict[str, Any]]]) -> dict[str, Any]: """Parse CLI vars as dbt would. This means: - When vars is a string, we treat it as a YAML dict str. - If it's already a dictionary, we just return it. - Otherwise (it's None), we return an empty dictionary. """ if isinstance(vars, str): return yaml_helper.load_yaml_text(vars) elif isinstance(vars, dict): return vars else: return {}
def parse_cli_vars(var_string): try: cli_vars = yaml_helper.load_yaml_text(var_string) var_type = type(cli_vars) if var_type == dict: return cli_vars else: type_name = var_type.__name__ dbt.exceptions.raise_compiler_error( "The --vars argument must be a YAML dictionary, but was " "of type '{}'".format(type_name)) except dbt.exceptions.ValidationException as e: logger.error( "The YAML provided in the --vars argument is not valid.\n") raise
def read_profile(profiles_dir: str) -> Dict[str, Any]: path = os.path.join(profiles_dir, 'profiles.yml') contents = None if os.path.isfile(path): try: contents = load_file_contents(path, strip=False) yaml_content = load_yaml_text(contents) if not yaml_content: msg = f'The profiles.yml file at {path} is empty' raise DbtProfileError( INVALID_PROFILE_MESSAGE.format(error_string=msg)) return yaml_content except ValidationException as e: msg = INVALID_PROFILE_MESSAGE.format(error_string=e) raise ValidationException(msg) from e return {}
def from_path( cls, path: Path, renderer: SelectorRenderer, ) -> 'SelectorConfig': try: data = load_yaml_text(load_file_contents(str(path))) except (ValidationError, RuntimeException) as exc: raise DbtSelectorsError( f'Could not read selector file: {exc}', result_type='invalid_selector', path=path, ) from exc try: return cls.render_from_dict(data, renderer) except DbtSelectorsError as exc: exc.path = path raise
def _load_profile(self): if not os.path.exists(self.profile_path): self.profile_fail_details = FILE_NOT_FOUND self.messages.append(MISSING_PROFILE_MESSAGE.format( path=self.profile_path, url=ProfileConfigDocs )) return red('ERROR not found') try: raw_profile_data = load_yaml_text( dbt.clients.system.load_file_contents(self.profile_path) ) except Exception: pass # we'll report this when we try to load the profile for real else: if isinstance(raw_profile_data, dict): self.raw_profile_data = raw_profile_data profile_errors = [] profile_names = self._choose_profile_names() renderer = ProfileRenderer(generate_base_context(self.cli_vars)) for profile_name in profile_names: try: profile: Profile = QueryCommentedProfile.render_from_args( self.args, renderer, profile_name ) except dbt.exceptions.DbtConfigError as exc: profile_errors.append(str(exc)) else: if len(profile_names) == 1: # if a profile was specified, set it on the task self.target_name = self._choose_target_name(profile_name) self.profile = profile if profile_errors: self.profile_fail_details = '\n\n'.join(profile_errors) return red('ERROR invalid') return green('OK found and valid')
def _load_yaml(path): contents = load_file_contents(path) return load_yaml_text(contents)