Add all `src_paths` as artifact of type `artifact_type`.
764743
def extend(self, artifact_type: ArtifactType, src_paths: list):
        """"""
        for src_path in src_paths:
            self.add(artifact_type, src_path, src_path)
506597
def _add_path(dir_name, payload_info_list):
    """"""
    for payload_info_dict in payload_info_list:
        file_name = payload_info_dict['filename'] or payload_info_dict['pid']
        payload_info_dict['path'] = d1_common.utils.filesystem.gen_safe_path(
            dir_name, 'data', file_name
        )
939718
protected void setupMavenPaths() {

		if (getAddCompileSourceRoot()) {
			getProject().addCompileSourceRoot(getGenerateDirectory().getPath());
		}
		if (getAddTestCompileSourceRoot()) {
			getProject().addTestCompileSourceRoot(getGenerateDirectory().getPath());
		}
		if (getEpisode() && getEpisodeFile() != null) {
			final String episodeFilePath = getEpisodeFile().getAbsolutePath();
			final String generatedDirectoryPath = getGenerateDirectory().getAbsolutePath();

			if (episodeFilePath.startsWith(generatedDirectoryPath + File.separator)) {
				final String path = episodeFilePath.substring(generatedDirectoryPath.length() + 1);

				final Resource resource = new Resource();
				resource.setDirectory(generatedDirectoryPath);
				resource.addInclude(path);
				if (getAddCompileSourceRoot()) {
					getProject().addResource(resource);
				}
				if (getAddTestCompileSourceRoot()) {
					getProject().addTestResource(resource);

				}
			}
		}
	}
1127559
def install(cls, type_, name, src, *args, **kwargs):
        """"""
        data = kwargs.pop('data', None)
        if data is None:
            data = {
                'addon': {
                    'type': type_,
                    'name': name,
                    'src': src,
                }
            }
        cls.create(data=data, *args, **kwargs)
1025780
private void addRelevantPluginDependenciesToClasspath(Set<URL> path) throws MojoExecutionException {
        if (hasCommandlineArgs()) {
            arguments = parseCommandlineArgs();
        }

        try {
            Iterator<Artifact> iter = this.determineRelevantPluginDependencies().iterator();
            while (iter.hasNext()) {
                Artifact classPathElement = iter.next();

                // we must skip org.osgi.core, otherwise we get a
                // java.lang.NoClassDefFoundError: org.osgi.vendor.framework property not set
                if (classPathElement.getArtifactId().equals("org.osgi.core")) {
                    getLog().debug("Skipping org.osgi.core -> " + classPathElement.getGroupId() + "/" + classPathElement.getArtifactId() + "/" + classPathElement.getVersion());
                    continue;
                }

                getLog().debug("Adding plugin dependency artifact: " + classPathElement.getArtifactId()
                    + " to classpath");
                path.add(classPathElement.getFile().toURI().toURL());
            }
        } catch (MalformedURLException e) {
            throw new MojoExecutionException("Error during setting up classpath", e);
        }

    }
503716
function(src, buildPath) {
    src = Array.isArray(src) ? src : [src];

    return new Elixir.GulpPaths()
        .src(src, config.publicPath)
        .output(buildPath || config.get('public.versioning.buildFolder'));
}
717620
def _upload_artifacts_to_path(self, mirror=False):
        
        if not os.listdir(self.artifact_path) or not self.artifact_path:
            raise S3ArtifactNotFound

        uploaded = False
        if self.s3props.get("content_metadata"):
            LOG.info("Uploading in multiple parts to set metadata")
            uploaded = self.content_metadata_uploads(mirror=mirror)

        if not uploaded:
            cmd = self._get_upload_cmd(mirror=mirror)
            result = subprocess.run(cmd, check=True, shell=True, stdout=subprocess.PIPE)
            LOG.debug("Upload Command Ouput: %s", result.stdout)

        LOG.info("Uploaded artifacts to %s bucket", self.bucket)
442347
def build_flags(library, type_, path):
    """"""

    pkg_config_path = [path]
    if "PKG_CONFIG_PATH" in os.environ:
        pkg_config_path.append(os.environ['PKG_CONFIG_PATH'])
    if "LIB_DIR" in os.environ:
        pkg_config_path.append(os.environ['LIB_DIR'])
        pkg_config_path.append(os.path.join(os.environ['LIB_DIR'], "pkgconfig"))

    options = [
        "--static",
        {
            'I': "--cflags-only-I",
            'L': "--libs-only-L",
            'l': "--libs-only-l"
        }[type_]
    ]

    return [
        flag.strip("-{}".format(type_))
        for flag
        in subprocess.check_output(
            ["pkg-config"] + options + [library],
            env=dict(os.environ, PKG_CONFIG_PATH=":".join(pkg_config_path))
        ).decode("UTF-8").split()
    ]
413559
function fetchFilePathsByType(distFiles, basePath, type) {
  return distFiles
    .filter(function(filePath) {
      return new RegExp('assets/.*\\.' + type + '$').test(filePath);
    })
    .map(function(filePath) {
      return path.join(basePath, filePath);
    });
}
830853
private static void setupPaths( PathsType paths) {
        File voltDbRoot;
        // Handles default voltdbroot (and completely missing "paths" element).
        voltDbRoot = getVoltDbRoot(paths);
        //Snapshot
        setupSnapshotPaths(paths.getSnapshots(), voltDbRoot);
        //export overflow
        setupExportOverflow(paths.getExportoverflow(), voltDbRoot);
        // only use these directories in the enterprise version
        setupCommandLog(paths.getCommandlog(), voltDbRoot);
        setupCommandLogSnapshot(paths.getCommandlogsnapshot(), voltDbRoot);
        setupDROverflow(paths.getDroverflow(), voltDbRoot);
        setupLargeQuerySwap(paths.getLargequeryswap(), voltDbRoot);
    }
162287
def add(self, src):
        
        if not audio.get_type(src):
            raise TypeError('The type of this file is not supported.')

        return super().add(src)
714483
def add_paths(self, paths):
        
        if paths:
            # Use new paths in priority
            self._paths = list(paths) + self._paths
1229142
def _add_asset_bundle(cls, path):
        
        f = "%s/assets.yml" % path
        if os.path.isfile(f):
            cls._asset_bundles.add(f)
190680
def artifact_path(cls, project, incident, artifact):
        """"""
        return google.api_core.path_template.expand(
            "projects/{project}/incidents/{incident}/artifacts/{artifact}",
            project=project,
            incident=incident,
            artifact=artifact,
        )
1097310
def append_rez_path(self):
        """"""
        if system.rez_bin_path:
            self.env.PATH.append(system.rez_bin_path)
960880
public void addBuildArtifact(String notation, String path, String pom) {
        Artifact artifact = new DefaultArtifact(notation);
        artifact = artifact.setFile( new File(path) );
        
        this.buildArtifacts.add( artifact );
        
        String pomNotation = new StringBuilder( artifact.getGroupId() ).append(":")
            .append( artifact.getArtifactId() ).append(":")
            .append( Const.POM).append(":").append( artifact.getBaseVersion() ).toString();
        
        artifact = new DefaultArtifact(pomNotation);
        artifact = artifact.setFile( new File(pom) );
        
        this.buildArtifacts.add( artifact );
    }
1094627
def add_path(self, path):
        # type: (_BaseSourcePaths, str) -> None
        
        if isinstance(path, pathlib.Path):
            self._paths.append(path)
        else:
            self._paths.append(pathlib.Path(path))