def new_project(self, project_root: str) -> 'RuntimeConfig': """Given a new project root, read in its project dictionary, supply the existing project's profile info, and create a new project file. :param project_root: A filepath to a dbt project. :raises DbtProfileError: If the profile is invalid. :raises DbtProjectError: If project is missing or invalid. :returns: The new configuration. """ # copy profile profile = Profile(**self.to_profile_info()) profile.validate() # load the new project and its packages. Don't pass cli variables. renderer = DbtProjectYamlRenderer(generate_target_context(profile, {})) project = Project.from_project_root( project_root, renderer, verify_version=getattr(self.args, 'version_check', False), ) cfg = self.from_parts( project=project, profile=profile, args=deepcopy(self.args), ) # force our quoting back onto the new project. cfg.quoting = deepcopy(self.quoting) return cfg
def collect_parts( cls: Type['RuntimeConfig'], args: Any ) -> Tuple[Project, Profile]: # profile_name from the project project_root = args.project_dir if args.project_dir else os.getcwd() version_check = getattr(args, 'version_check', False) partial = Project.partial_load( project_root, verify_version=version_check ) # build the profile using the base renderer and the one fact we know cli_vars: Dict[str, Any] = parse_cli_vars(getattr(args, 'vars', '{}')) profile_renderer = ProfileRenderer(generate_base_context(cli_vars)) profile_name = partial.render_profile_name(profile_renderer) profile = cls._get_rendered_profile( args, profile_renderer, profile_name ) # get a new renderer using our target information and render the # project ctx = generate_target_context(profile, cli_vars) project_renderer = DbtProjectYamlRenderer(ctx) project = partial.render(project_renderer) return (project, profile)
def get_project(git_path): phony_profile = Profile.from_raw_profiles(raw_profiles=PHONY_PROFILE, profile_name='hubcap', renderer=ProfileRenderer({})) ctx = generate_target_context(phony_profile, cli_vars={}) renderer = DbtProjectYamlRenderer(ctx) return Project.from_project_root(git_path, renderer)
def project_from_dict(project, profile, packages=None, cli_vars='{}'): from dbt.context.target import generate_target_context from dbt.config import Project, ConfigRenderer from dbt.utils import parse_cli_vars if not isinstance(cli_vars, dict): cli_vars = parse_cli_vars(cli_vars) renderer = ConfigRenderer(generate_target_context(profile, cli_vars)) project_root = project.pop('project-root', os.getcwd()) return Project.render_from_dict(project_root, project, packages, renderer)
def __init__( self, results, project, root_project, macro_manifest, ) -> None: super().__init__(results, project, root_project, macro_manifest) all_v_2 = (self.root_project.config_version == 2 and self.project.config_version == 2) if all_v_2: ctx = generate_schema_yml(self.root_project, self.project.project_name) else: ctx = generate_target_context(self.root_project, self.root_project.cli_vars) self.raw_renderer = SchemaYamlRenderer(ctx) self.config_generator = ContextConfigGenerator(self.root_project)
def resolve_packages( packages: List[PackageContract], config: RuntimeConfig ) -> List[PinnedPackage]: pending = PackageListing.from_contracts(packages) final = PackageListing() ctx = generate_target_context(config, config.cli_vars) renderer = DbtProjectYamlRenderer(ctx, config.config_version) while pending: next_pending = PackageListing() # resolve the dependency in question for package in pending: final.incorporate(package) target = final[package].resolved().fetch_metadata(config, renderer) next_pending.update_from(target.packages) pending = next_pending resolved = final.resolved() _check_for_duplicate_project_names(resolved, config, renderer) return resolved
def run(self): system.make_directory(self.config.modules_path) packages = self.config.packages.packages if not packages: logger.info('Warning: No packages were found in packages.yml') return with downloads_directory(): final_deps = resolve_packages(packages, self.config) renderer = DbtProjectYamlRenderer( generate_target_context(self.config, self.config.cli_vars)) for package in final_deps: logger.info('Installing {}', package) package.install(self.config, renderer) logger.info(' Installed from {}\n', package.nice_version_name()) self.track_package_install(package_name=package.name, source_type=package.source_type(), version=package.get_version())
def _load_project(self): if not os.path.exists(self.project_path): self.project_fail_details = FILE_NOT_FOUND return red('ERROR not found') if self.profile is None: ctx = generate_base_context(self.cli_vars) else: ctx = generate_target_context(self.profile, self.cli_vars) renderer = DbtProjectYamlRenderer(ctx) try: self.project = Project.from_project_root( self.project_dir, renderer, verify_version=getattr(self.args, 'version_check', False), ) except dbt.exceptions.DbtConfigError as exc: self.project_fail_details = str(exc) return red('ERROR invalid') return green('OK found and valid')
def __init__( self, project, manifest, root_project, ) -> None: super().__init__(project, manifest, root_project) all_v_2 = (self.root_project.config_version == 2 and self.project.config_version == 2) if all_v_2: ctx = generate_schema_yml(self.root_project, self.project.project_name) else: ctx = generate_target_context(self.root_project, self.root_project.cli_vars) self.raw_renderer = SchemaYamlRenderer(ctx) internal_package_names = get_adapter_package_names( self.root_project.credentials.type) self.macro_resolver = MacroResolver(self.manifest.macros, self.root_project.project_name, internal_package_names)
def _parse_generic_test( self, target: Testable, test: Dict[str, Any], tags: List[str], column_name: Optional[str], ) -> ParsedSchemaTestNode: render_ctx = generate_target_context(self.root_project, self.root_project.cli_vars) try: builder = TestBuilder( test=test, target=target, column_name=column_name, package_name=target.package_name, render_ctx=render_ctx, ) except CompilationException as exc: context = _trimmed(str(target)) msg = ('Invalid test config given in {}:' '\n\t{}\n\t@: {}'.format(target.original_file_path, exc.msg, context)) raise CompilationException(msg) from exc original_name = os.path.basename(target.original_file_path) compiled_path = get_pseudo_test_path( builder.compiled_name, original_name, 'schema_test', ) fqn_path = get_pseudo_test_path( builder.fqn_name, original_name, 'schema_test', ) # the fqn for tests actually happens in the test target's name, which # is not necessarily this package's name fqn = self.get_fqn(fqn_path, builder.fqn_name) config = self.initial_config(fqn) metadata = { 'namespace': builder.namespace, 'name': builder.name, 'kwargs': builder.args, } tags = sorted(set(itertools.chain(tags, builder.tags()))) if 'schema' not in tags: tags.append('schema') node = self.create_test_node( target=target, path=compiled_path, config=config, fqn=fqn, tags=tags, name=builder.fqn_name, raw_sql=builder.build_raw_sql(), column_name=column_name, test_metadata=metadata, ) self.render_update(node, config) return node
def test_target_context(): profile = profile_from_dict(PROFILE_DATA, 'test') ctx = target.generate_target_context(profile, {}) assert_has_keys(REQUIRED_TARGET_KEYS, MAYBE_KEYS, ctx)