return building name
542235
def buildingname(ddtt):
    """"""
    idf = ddtt.theidf
    building = idf.idfobjects['building'.upper()][0]
    return building.Name
652928
function getSortingPropertyName(property) {
  if (property.type === 'ExperimentalSpreadProperty') {
    return `...${property.argument.name}`;
  }

  if (property.key.type === 'Literal') {
    return property.key.value;
  }

  if (property.key.type === 'Identifier') {
    return `${property.key.name}`;
  }
}
1374471
function buildName(obj) {
        if (!obj) {
          return parts.join('.');
        }

        if (obj.property && obj.property.name) {
          parts.unshift(obj.property.name);
        }

        if (obj.object && obj.object.name) {
          parts.unshift(obj.object.name);
        }

        return buildName(obj.object);
      }
1342189
def _get_archive_name(self, archname=None):
        '''
        
        '''
        archname = re.sub('[^a-z0-9]', '', (archname or '').lower()) or 'support'
        for grain in ['fqdn', 'host', 'localhost', 'nodename']:
            host = __grains__.get(grain)
            if host:
                break
        if not host:
            host = 'localhost'

        return os.path.join(tempfile.gettempdir(),
                            '{hostname}-{archname}-{date}-{time}.bz2'.format(archname=archname,
                                                                             hostname=host,
                                                                             date=time.strftime('%Y%m%d'),
                                                                             time=time.strftime('%H%M%S')))
355215
def name(self):
        
        if self.site_name:
            return "Int_{}_{}_mult{}".format(self.site.specie, self.site_name, self.multiplicity)
        else:
            return "Int_{}_mult{}".format(self.site.specie, self.multiplicity)
1244039
def address(obj):
    """'"""
    return "<%s @ %s>" % (obj.__class__.__name__,
                          hex(id(obj)).upper().replace('X', 'x'))
257340
def name(self):
        """"""
        # pylint:disable=E1101
        return next((self.names.get(x) for x in self._locales if x in
                     self.names), None)
215172
private static String getterName(String propertyName) {
        if ((propertyName == null) || (propertyName.length() == 0)) {
            return propertyName;
        }
        return "get" + Character.toUpperCase(propertyName.charAt(0))
                + propertyName.substring(1);
    }
253950
def get_name(self, name):
        """"""
        if name not in self.get_names():
            raise exceptions.NameNotFoundError('name %s not found' % name)
        return self.get_names()[name]
164160
def get_grp_name(self, code):
        """"""
        nt_code = self.code2nt.get(code.strip(), None)
        if nt_code is not None:
            return nt_code.group, nt_code.name
        return "", ""
690470
def get_name(self):
        
        self.name = self.name or graceful_get(self.inspect(refresh=False), "Name")
        return self.name
1003343
function getFuncName(func) {
      var result = (func.name + ''),
          array = realNames[result],
          length = hasOwnProperty.call(realNames, result) ? array.length : 0;

      while (length--) {
        var data = array[length],
            otherFunc = data.func;
        if (otherFunc == null || otherFunc == func) {
          return data.name;
        }
      }
      return result;
    }
604413
def _FormatPropertyName(self, property_name):
    
    # TODO: Add Unicode support.
    fix_key = re.sub(r'(.)([A-Z][a-z]+)', r'\1_\2', property_name)
    return re.sub(r'([a-z0-9])([A-Z])', r'\1_\2', fix_key).lower()
913445
public static String getEntryNameForMapValue(String property, Integer index) {
        return getEntryNameForMap(property, false, index);
    }
754498
def get_instance_property(instance, property_name):
  """"""

  name = get_name(instance)
  while True:
    try:
      value = getattr(instance, property_name)
      if value is not None:
        break
      print(f"retrieving {property_name} on {name} produced None, retrying")
      time.sleep(RETRY_INTERVAL_SEC)
      instance.reload()
      continue
    except Exception as e:
      print(f"retrieving {property_name} on {name} failed with {e}, retrying")
      time.sleep(RETRY_INTERVAL_SEC)
      try:
        instance.reload()
      except Exception:
        pass
      continue

  return value
1126044
function getName(name, width, separator) {

        // handle empty separator as no separator
        if (typeof separator === 'undefined') {
            separator = '';
        }

        if (name) {
            return separator + name;
        } else {
            return separator + width;
        }
    }
579514
function findname(error, response, body) {
		if (error){
                        return error
                }
              	if (body){
			try{
				var info = JSON.parse(body)
			}
			catch(err){
				console.log(body)
				return
			}			
			if (info.items){
		        	var ilen=info.items.length
		        	while(ilen--){
		                	var it=info.items[ilen]
		                	var thename=it['properties']['name']
		                	if (thename.match(srchfor)){
		         			console.log(it) // <---- print json for server(s) that match srchfor
		                	}
                                }
                        }
                }
}