Get the revision history for the given brain or context.

    :param brain_or_object: A single catalog brain or content object
    :type brain_or_object: ATContentType/DexterityContentType/CatalogBrain
    :returns: Workflow history
    :rtype: obj
170738
def get_revision_history(brain_or_object):
    
    obj = get_object(brain_or_object)
    chv = ContentHistoryView(obj, safe_getattr(obj, "REQUEST", None))
    return chv.fullHistory()
422579
def icon_cache_key(method, self, brain_or_object):
    
    url = api.get_url(brain_or_object)
    modified = api.get_modification_date(brain_or_object).millis()
    key = "{}?modified={}".format(url, modified)
    logger.debug("Generated Cache Key: {}".format(key))
    return key
316035
def _api_history(self, plugin, nb=0):
        
        response.content_type = 'application/json; charset=utf-8'

        if plugin not in self.plugins_list:
            abort(400, "Unknown plugin %s (available plugins: %s)" % (plugin, self.plugins_list))

        # Update the stat
        self.__update__()

        try:
            # Get the JSON value of the stat ID
            statval = self.stats.get_plugin(plugin).get_stats_history(nb=int(nb))
        except Exception as e:
            abort(404, "Cannot get plugin history %s (%s)" % (plugin, str(e)))
        return statval
346920
def get_catalog_for(self, brain_or_object):
        
        if not api.is_object(brain_or_object):
            raise TypeError("Invalid object type %r" % brain_or_object)
        catalogs = api.get_catalogs_for(brain_or_object, default="uid_catalog")
        return catalogs[0]
208385
def get_version(self):
        
        return Version.objects.get(
            content_type=self.content_type,
            object_id=self.object_id,
            version_number=self.publish_version,
        )
165933
def get_task_history(last_task):
    """"""
    if hasattr(last_task, 'branch') and last_task.branch:
        return
    elif hasattr(last_task, 'hide') and last_task.hide:
        return
    else:
        return get_func_info(last_task)
102107
def get_parent(brain_or_object):
    

    if is_root(brain_or_object):
        return get_portal()

    if is_brain(brain_or_object):
        parent_path = get_parent_path(brain_or_object)
        return get_object_by_path(parent_path)

    return brain_or_object.aq_parent
1212238
def get_uid(brain_or_object):
    
    if is_portal(brain_or_object):
        return '0'
    if is_brain(brain_or_object) and base_hasattr(brain_or_object, "UID"):
        return brain_or_object.UID
    return get_object(brain_or_object).UID()
148617
def past(self, rev=None):
        
        if rev is not None:
            self.seek(rev)
        return WindowDictPastView(self._past)
596775
def evaluate(self, brain_info):
        
        feed_dict = {self.model.batch_size: len(brain_info.vector_observations),
                     self.model.sequence_length: 1}
        epsilon = None
        if self.use_recurrent:
            if not self.use_continuous_act:
                feed_dict[self.model.prev_action] = brain_info.previous_vector_actions.reshape(
                    [-1, len(self.model.act_size)])
            if brain_info.memories.shape[1] == 0:
                brain_info.memories = self.make_empty_memory(len(brain_info.agents))
            feed_dict[self.model.memory_in] = brain_info.memories
        if self.use_continuous_act:
            epsilon = np.random.normal(
                size=(len(brain_info.vector_observations), self.model.act_size[0]))
            feed_dict[self.model.epsilon] = epsilon
        feed_dict = self._fill_eval_dict(feed_dict, brain_info)
        run_out = self._execute_model(feed_dict, self.inference_dict)
        if self.use_continuous_act:
            run_out['random_normal_epsilon'] = epsilon
        return run_out
1053934
public static ns_conf_revision_history[] get(nitro_service client) throws Exception
	{
		ns_conf_revision_history resource = new ns_conf_revision_history();
		resource.validate("get");
		return (ns_conf_revision_history[]) resource.get_resources(client);
	}
578524
def _get_state(self, output: UnityRLOutput) -> (AllBrainInfo, bool):
        
        _data = {}
        global_done = output.global_done
        for brain_name in output.agentInfos:
            agent_info_list = output.agentInfos[brain_name].value
            _data[brain_name] = BrainInfo.from_agent_proto(agent_info_list,
                                                           self.brains[brain_name])
        return _data, global_done
112943
def get_path(brain_or_object):
    
    if is_brain(brain_or_object):
        path = brain_or_object.getPath()
        portal_path = get_path(get_portal())
        if portal_path not in path:
            return "{}/{}".format(portal_path, path)
        return path
    return "/".join(get_object(brain_or_object).getPhysicalPath())
1269794
def history(self):
        
        if self.changeset is None:
            raise NodeError('Unable to get changeset for this FileNode')
        return self.changeset.get_file_history(self.path)
825646
def get_brain(brain_or_object):
    
    if is_brain(brain_or_object):
        return brain_or_object
    if is_root(brain_or_object):
        return brain_or_object

    # fetch the brain by UID
    uid = get_uid(brain_or_object)
    uc = get_tool("uid_catalog")
    results = uc({"UID": uid}) or search(query={'UID': uid})
    if len(results) == 0:
        return None
    if len(results) > 1:
        fail(500, "More than one object with UID={} found in portal_catalog".format(uid))
    return results[0]
665772
def is_folderish(brain_or_object):
    
    if hasattr(brain_or_object, "is_folderish"):
        if callable(brain_or_object.is_folderish):
            return brain_or_object.is_folderish()
        return brain_or_object.is_folderish
    return IFolderish.providedBy(get_object(brain_or_object))
1017548
def get_behaviors(brain_or_object):
    
    obj = get_object(brain_or_object)
    if not is_dexterity_content(obj):
        fail(400, "Only Dexterity contents can have assigned behaviors")
    assignable = IBehaviorAssignable(obj, None)
    if not assignable:
        return {}
    out = {}
    for behavior in assignable.enumerateBehaviors():
        for name, field in getFields(behavior.interface).items():
            out[name] = field
    return out