Movie Actors.

        :return:
            A list of actors names.
328296
def actors(self):
        
        result = []
        actors = self._safe_get_element('ItemAttributes.Actor') or []
        for actor in actors:
            result.append(actor.text)
        return result
1337408
def fnames(self, names):
        """"""
        names = list(names[:len(self._fnames)])
        self._fnames = names + self._fnames[len(names):]
642028
def get_checkpoints_for_actor(actor_id):
    
    checkpoint_info = ray.worker.global_state.actor_checkpoint_info(actor_id)
    if checkpoint_info is None:
        return []
    checkpoints = [
        Checkpoint(checkpoint_id, timestamp) for checkpoint_id, timestamp in
        zip(checkpoint_info["CheckpointIds"], checkpoint_info["Timestamps"])
    ]
    return sorted(
        checkpoints,
        key=lambda checkpoint: checkpoint.timestamp,
        reverse=True,
    )
354381
def _get_names(node, result):
    """"""
    if isinstance(node, ast.Name):
        return node.id + result
    elif isinstance(node, ast.Subscript):
        return result
    elif isinstance(node, ast.Starred):
        return _get_names(node.value, result)
    else:
        return _get_names(node.value, result + '.' + node.attr)
1006774
def feature_names(self, names):
        ""

        if len(names) != self.num_features:
            raise ValueError("Number of names do not match the number of features!")
        if not isinstance(names, (Sequence, np.ndarray, np.generic)):
            raise ValueError("Input is not a sequence. "
                             "Ensure names are in the same order "
                             "and length as features.")

        self.__feature_names = np.array(names)
1239730
def WhatActorsArePresent(self):
        '''
        '''
        results = []
        for E in self.header_elements:
            a = _find_actor(E)
            if a not in [ None, SOAP.ACTOR_NEXT ]: results.append(a)
        return results
945887
def get_names(infos):
    
    names = []
    for x in infos:
        for y in x:
            names.append(y["name"][0])
    return names
579324
async def movies(self):
    '''
    '''
    items = []
    for i in await self.items:
      if i.type == 'Movie':
        items.append(i)
      elif hasattr(i, 'movies'):
        items.extend(await i.movies)
    return items
221103
def get_feature_names(self):
        
        feature_names = []
        for name, trans, weight in self._iter():
            if not hasattr(trans, 'get_feature_names'):
                raise AttributeError("Transformer %s (type %s) does not "
                                     "provide get_feature_names."
                                     % (str(name), type(trans).__name__))
            feature_names.extend([name + "__" + f for f in
                                  trans.get_feature_names()])
        return feature_names
155385
def to_list(self):
        
        return [self.i, self.Ω, self.e, self.ω, self.M, self.n]
336648
def actors(context):
    """"""
    fritz = context.obj
    fritz.login()

    for actor in fritz.get_actors():
        click.echo("{} ({} {}; AIN {} )".format(
            actor.name,
            actor.manufacturer,
            actor.productname,
            actor.actor_id,
        ))
        if actor.has_temperature:
            click.echo("Temp: act {} target {}; battery (low): {}".format(
                actor.temperature,
                actor.target_temperature,
                actor.battery_low,
            ))

            click.echo("Temp (via get): act {} target {}".format(
                actor.get_temperature(),
                actor.get_target_temperature(),
            ))
715496
def get_actor(self, name):
        
        return next((x for x in self.actors if x.name == name), None)
1282431
def _get_input_names(spec):
    
    retval = [feature.name for feature in spec.description.input]
    return retval
1280266
def get_names():
    """"""
    res = list(cmaps.keys())
    res = sorted(res, key=lambda s: s.lower())
    return res
347814
def names(self):
        
        found_names = []
        with open(self.filename) as f:
            content = f.readlines()
        for line in content:
            line = line.strip()
            if " " in line:
                attribute, value = line.split(" ", 1)
                attribute = attribute.strip()
                value = value.strip()
                if attribute.lower() in ['host']:
                    found_names.append(value)
        return found_names
244886
def add_actors(self, actor):
        
        if isinstance(actor, list):
            self.actors.extend(actor)
        elif isinstance(actor, Actor):
            self.actors.append(actor)
        return self
638973
def to_dict(self):
        
        result = super(Actor, self).to_dict()
        result["type"] = "Actor"
        result["name"] = self.name
        return result