Get a specific info.

    Both the node and info id must be specified in the url.
173136
def get_info(node_id, info_id):
    
    exp = experiment(session)

    # check the node exists
    node = models.Node.query.get(node_id)
    if node is None:
        return error_response(error_type="/info, node does not exist")

    # execute the experiment method:
    info = models.Info.query.get(info_id)
    if info is None:
        return error_response(error_type="/info GET, info does not exist",
                              participant=node.participant)
    elif (info.origin_id != node.id and
          info.id not in
            [t.info_id for t in node.transmissions(direction="incoming",
                                                   status="received")]):
        return error_response(error_type="/info GET, forbidden info",
                              status=403,
                              participant=node.participant)

    try:
        # ping the experiment
        exp.info_get_request(node=node, infos=info)
        session.commit()
    except:
        return error_response(error_type="/info GET server error",
                              status=403,
                              participant=node.participant)

    # return the data
    return success_response(field="info",
                            data=info.__json__(),
                            request_type="info get")
1038356
def get(self, item):
        """"""
        uri = "/%s/%s" % (self.uri_base, utils.get_id(item))
        return self._get(uri)
137023
public NodeInfo getNode(String name) {
    final URI uri = uriWithPath("./nodes/" + encodePathSegment(name));
    return this.rt.getForObject(uri, NodeInfo.class);
  }
502952
def _get_info(self, layout):
        """"""
        info = str(self.tk.call(layout, 'info', self._w)).split("-")
        dic = {}
        for i in info:
            if i:
                key, val = i.strip().split()
                dic[key] = val
        return dic
1186855
function obtainInfo(id, action, cb) {
    request.get({
        url: action,
        timeout: 10000,
        maxAttempts: 2
    }, function (error, response, body) {
        if (error || response.statusCode != 200) {
            cb(utils.errorDown())
            return
        }

        const data = JSON.parse(body)
        if (data.errors != undefined) {
            cb(utils.errorNoData())
            return
        }

        let entity = null
        try {
            entity = createTrackerEntity(data)
        } catch (error) {
            return cb(utils.errorParser(id, error.message))
        }

        if(entity != null) cb(null, entity)
    })
}
809140
def info(self, name):
        """"""
        r = requests.get('{}/{}'.format(self.url_service, name))
        return r.json()
370614
def _hook_id(self, info):
        
        if isinstance(info, dict) and 'id' in info.keys():
            self.id = info['id']
1209807
def get_wiki(self, section):
        

        doc = self._request(self.ws_prefix + ".getInfo", True)

        if len(doc.getElementsByTagName("wiki")) == 0:
            return

        node = doc.getElementsByTagName("wiki")[0]

        return _extract(node, section)
594245
def get_node_description(self, node: BaseEntity) -> Optional[str]:
        """"""
        return self._get_node_attr(node, DESCRIPTION)
1239597
def get_node_by_id(self, node_id):
        
        tmp_nodes = self.diagram_graph.nodes(data=True)
        for node in tmp_nodes:
            if node[0] == node_id:
                return node
712685
def get_info(self, params={}):
        
        res = self.invoke(zconstant.NS_ZIMBRA_ACC_URL,
                          sconstant.GetInfoRequest,
                          params)

        return res
1244616
def getinfo(self, name):
        """"""
        info = self.NameToInfo.get(name)
        if info is None:
            raise KeyError(
                'There is no item named %r in the archive' % name)

        return info
1047411
def get_node(request):
    """"""
    api_major_int = 2 if d1_gmn.app.views.util.is_v2_api(request) else 1
    node_pretty_xml = d1_gmn.app.node.get_pretty_xml(api_major_int)
    return django.http.HttpResponse(node_pretty_xml, d1_common.const.CONTENT_TYPE_XML)
707182
def get(url):
    """"""
    writeln("Getting data from url", url)
    response = requests.get(url)
    if response.status_code == 200:
        writeln(response.text)
    else:
        writeln(str(response.status_code), response.reason)
309953
def blog_info(self, blogname):
        
        url = "/v2/blog/{}/info".format(blogname)
        return self.send_api_request("get", url, {}, ['api_key'], True)
1008837
def get_info(self, key=None, Id=None) -> dict:
        """"""
        if key is not None:
            Id = self[key].Id
        return self.infos.get(Id,{})
57777
def info(request, message, extra_tags='', fail_silently=False, async=False):
    """"""
    if ASYNC and async:
        messages.info(_get_user(request), message)
    else:
        add_message(request, constants.INFO, message, extra_tags=extra_tags,
                    fail_silently=fail_silently)