Create the readable name for the pipeline name.
2062
function prettyName(name, sidebar) {
  var adjustedName = name;
  if (sidebar) {
    var adjustedName = name;
    var parts = name.split('.');
    if (parts.length > 0) {
      adjustedName = parts[parts.length - 1];
    }
  }
  return adjustedName.replace(/\./, '.<wbr>');
}
327177
def _setOutputNames(self,rootname,suffix='_drz'):
        
        # Define FITS output filenames for intermediate products

        # Build names based on final DRIZZLE output name
        # where 'output' normally would have been created
        #   by 'process_input()'
        #
        outFinal = rootname+suffix+'.fits'
        outSci = rootname+suffix+'_sci.fits'
        outWeight = rootname+suffix+'_wht.fits'
        outContext = rootname+suffix+'_ctx.fits'
        outMedian = rootname+'_med.fits'

        # Build names based on input name
        origFilename = self._filename.replace('.fits','_OrIg.fits')
        outSky = rootname + '_sky.fits'
        outSingle = rootname+'_single_sci.fits'
        outSWeight = rootname+'_single_wht.fits'
        crCorImage = rootname+'_crclean.fits'

        # Build outputNames dictionary
        fnames={
            'origFilename': origFilename,
            'outFinal': outFinal,
            'outMedian': outMedian,
            'outSci': outSci,
            'outWeight': outWeight,
            'outContext': outContext,
            'outSingle': outSingle,
            'outSWeight': outSWeight,
            'outSContext': None,
            'outSky': outSky,
            'crcorImage': crCorImage,
            'ivmFile': None
        }

        return fnames
356194
def name_from_path(self):
        """"""
        name = os.path.splitext(os.path.basename(self.path))[0]
        if name == 'catalog':
            name = os.path.basename(os.path.dirname(self.path))
        return name.replace('.', '_')
1110131
def make_name(self):
        """"""
        if self.title:
            self.name = six.text_type(make_name(self.title_for_name, maxlength=self.__name_length__))
461404
def make_unique_name(name, existing_names, name_format="{name}_{index}", start=2):
    """"""
    index = start
    new_name = name
    while new_name in existing_names:
        new_name = name_format.format(name=name, index=index)
        index += 1

    return new_name
382221
def get_pipe(self, name):
        
        for pipe_name, component in self.pipeline:
            if pipe_name == name:
                return component
        raise KeyError(Errors.E001.format(name=name, opts=self.pipe_names))
1128999
def _make_unique(name, idx):
    """"""
    p = re.compile(".[aA-zZ]+_x[0-9]+")
    if p.match(name):
        tags = name[1:].split("_x")
        return ">%s_%s_x%s" % (tags[0], idx, tags[1])
    return name.replace("@", ">")
817857
def make_entity_name(name):
    """"""
    invalid_chars = "-=!#$%^&*[](){}/~'`<>:;"
    for char in invalid_chars:
        name = name.replace(char, "_")
    return name
178917
def _process_name(name):
    """"""

    # Unescape HTML entities
    name = unescape(name)

    # Remove bracketed stuff on the end
    name = NG_RE.sub('', name).strip()  # Nomenclature groups
    name = END_RE.sub('', name).strip(', ')  # Words
    name = RATIO_RE.sub('', name).strip(', ')  # Ratios

    # Remove stuff off start
    name = START_RE.sub('', name).strip()

    # Remove balanced start and end brackets if none in between
    name = BRACKET_RE.sub('\g<1>', name)

    # Un-invert CAS style names
    comps = name.split(', ')
    if len(comps) == 2:
        if comps[1].endswith('-'):
            name = comps[0]
            name = '%s%s' % (comps[1], name)
    elif len(comps) > 2:
        name = comps[0]
        for i in range(1, len(comps)):
            if comps[i].endswith('-'):
                name = '%s%s' % (comps[i], name)
            else:
                name = '%s %s' % (name, comps[i])
    return name
812404
private String createName(String producerId, String statName) {
		String appName = encodeAppName(MoskitoConfigurationHolder.getConfiguration().getApplicationName());
		return "MoSKito."+(appName.length()>0 ? appName+ '.' :"")+"producers:type="+producerId+ '.' +statName;
	}
819234
def set_name(self, new_name):
        

        yield from self._hypervisor.send('nio_bridge rename "{name}" "{new_name}"'.format(name=self._name,
                                                                                          new_name=new_name))

        self._name = new_name
1031941
def _pipeline(self, name):
        
        if name == self.connection_name:
            return self

        try:
            return self._pipelines[name]
        except KeyError:
            pipe = Pipeline(name=name, autoexec=True)
            self._pipelines[name] = pipe
            return pipe
278089
def set_name(self, name):
        
        path = self._filename.split("/")
        parts = path[-1].split(".")
        if len(parts) == 1:
            path[-1] = name
        else:
            path[-1] = name + "." + parts[-1]
        return File("/".join(path))
855556
def set_process_name():
        
        proc = multiprocessing.current_process()
        for offset in range(0, len(sys.argv)):
            if sys.argv[offset] == '-c':
                name = sys.argv[offset + 1].split('/')[-1]
                proc.name = name.split('.')[0]
                break
247436
def _format_key_name(self) -> str:
        """"""
        key_name = 'ld:{0}:{1}:features'.format(
            self.project_key,
            self.environment_key
        )
        return key_name
203138
def _make_name(current, new):
    '''
    
    '''

    current_tokens = current.split()
    new_tokens = new.split()

    new = ' '.join(
        new_token for new_token in new_tokens
        if new_token not in current_tokens
    )

    return '/'.join((current, new))
129931
def create_pipeline_stage(self, pipeline_key, name, **kwargs):
		'''
		'''
		#req sanity check
		if not (pipeline_key and name):
			return requests.codes.bad_request, None

		uri = '/'.join([
						self.api_uri,
						self.pipelines_suffix,
						pipeline_key,
						self.stages_suffix])
		
		kwargs.update({'name':name})

		new_box = StreakStage(**kwargs)
		
		code, data = self._req('put', uri, new_box.to_dict(rw = True))
		
		return code, data