Get the actor's fullname of the snapshot
170795
def get_fullname(snapshot):
    
    actor = get_actor(snapshot)
    properties = api.get_user_properties(actor)
    return properties.get("fullname", actor)
1121196
def getFullPathToSnapshot(self, n):
		""""""
		return os.path.join(self.snapDir, str(n))
441013
def _filename(self, name=None, suffix=None, prefix=None):
        

        filename = ''

        if prefix:
            filename += str(prefix) + '_'

        if name:
            filename += str(name)
        else:
            filename += str(self.scene)

        if suffix:
            filename += '_' + str(suffix)

        if self.clipped:
            bounds = [tuple(self.bounds[0:2]), tuple(self.bounds[2:4])]
            polyline = PolylineCodec().encode(bounds)
            filename += '_clipped_' + polyline

        filename += '.TIF'

        return filename
476738
function snapshotToHash(snap, idProp = "id") {
    const hash = snap.val() || {};
    Object.keys(hash).forEach(key => typeof hash[key] === "object"
        ? (hash[key][idProp] = key)
        : (hash[key] = { [idProp]: key, value: hash[key] }));
    return hash;
}
465887
def get_full_name(self):
        """"""
        if self.first_name and self.last_name:
            return "{} {}".format(self.first_name, self.last_name)
        return self.email
75561
def get_actor_by_ain(self, ain):
        
        for actor in self.get_actors():
            if actor.actor_id == ain:
                return actor
603097
def _name(self):
        """"""
        return "{0} {1} {2}".format(
            self._camera.name,
            pretty_timestamp(self.created_at),
            self._attrs.get('mediaDuration'))
847469
protected String getSnapshotIdFromProperties(String spaceId) {
        Properties props = new Properties();
        try (InputStream is = this.snapshotProvider.getContent(spaceId, Constants.SNAPSHOT_PROPS_FILENAME)
                                                   .getContentStream()) {
            props.load(is);
            return props.getProperty(Constants.SNAPSHOT_ID_PROP);
        } catch (NotFoundException ex) {
            return null;
        } catch (Exception e) {
            throw new TaskException(
                MessageFormat.format("Call to create snapshot failed, unable to determine existence of " +
                                     "snapshot properties file in {0}. Error: {1}", spaceId, e.getMessage()));
        }
    }
741704
def full_name(self):
        """"""
        if self.requested_version is not None:
            return '%s-%s' % (self.name, self.requested_version)
        return self.name
893895
public com.google.protobuf.ByteString
      getSnapshotNameBytes() {
    java.lang.Object ref = snapshotName_;
    if (ref instanceof java.lang.String) {
      com.google.protobuf.ByteString b = 
          com.google.protobuf.ByteString.copyFromUtf8(
              (java.lang.String) ref);
      snapshotName_ = b;
      return b;
    } else {
      return (com.google.protobuf.ByteString) ref;
    }
  }
72873
def snapshot_agent(self):
        ''''''
        protocols = [i.get_agent_side() for i in self._protocols.values()]
        return (self.agent, protocols, )
3966
def full_name(self):
    """"""
    names = [self._builder.name]
    if self._builder.builder_config:
      names.append(self._builder.builder_config.name)
    names.append(str(self.version))
    return posixpath.join(*names)
638973
def to_dict(self):
        
        result = super(Actor, self).to_dict()
        result["type"] = "Actor"
        result["name"] = self.name
        return result
997013
def snapshot(gandi, name, resource, background):
    
    name = name or randomstring('snp')

    source_info = gandi.disk.info(resource)
    datacenter = source_info['datacenter_id']
    result = gandi.disk.create(name, None, None, None, datacenter, resource,
                               'snapshot', background)

    if background:
        gandi.pretty_echo(result)
    return result
222471
private Map<File, File> getDataMap(int vcode, String[] dataDirs, String snapshotName) {
		Map<File, File> map = new HashMap<File, File>();

		Map<File, File[]> src = vcode==0 ? getDataMap_1_0(dataDirs) : getDataMap_1_1(dataDirs);
		for (File ks : src.keySet()) {
			File[] sn = src.get(ks);

			if (sn != null) {
				for (int i = 0; i < sn.length; i++) {
					if (snapshotName.equals(sn[i].getName())) {
						map.put(ks, sn[i]);
						break;
					}
				}
			}
		}

		return map;
	}
1208673
def full_name(self):
        
        name, parameters, _ = self.signature
        return name+'('+','.join(parameters)+')'
742559
def unique_name(self, name):
        
        result = name

        if self.parent is not None:
            index = self.index
            bname = re.sub(r'-[0-9]+$', '', name)
            names = []
            for idx, actor in enumerate(self.parent.actors):
                if idx != index:
                    names.append(actor.name)
            result = bname
            count = 0
            while result in names:
                count += 1
                result = bname + "-" + str(count)

        return result