Do extra work to fetch a complete set of attributes for this entity.

        For more information, see `Bugzilla #1232855
        <https://bugzilla.redhat.com/show_bug.cgi?id=1232855>`_.
481626
def create(self, create_missing=None):
        
        return Realm(
            self._server_config,
            id=self.create_json(create_missing)['id'],
        ).read()
1290548
def get_attribute_datasets(attr_id, scenario_id, **kwargs):
    

    user_id = kwargs.get('user_id')

    scenario_i = _get_scenario(scenario_id, user_id)

    try:
        a = db.DBSession.query(Attr).filter(Attr.id == attr_id).one()
    except NoResultFound:
        raise HydraError("Attribute %s not found"%(attr_id,))

    rs_qry = db.DBSession.query(ResourceScenario).filter(
                ResourceAttr.attr_id==attr_id,
                ResourceScenario.scenario_id==scenario_i.id,
                ResourceScenario.resource_attr_id==ResourceAttr.id
            ).options(joinedload_all('dataset'))\
            .options(joinedload_all('resourceattr'))\
            .options(joinedload_all('resourceattr.node'))\
            .options(joinedload_all('resourceattr.link'))\
            .options(joinedload_all('resourceattr.resourcegroup'))\
            .options(joinedload_all('resourceattr.network'))

    resourcescenarios = rs_qry.all()

    json_rs = []
    #Load the metadata too
    for rs in resourcescenarios:
        rs.dataset.metadata
        tmp_rs = JSONObject(rs)
        tmp_rs.resourceattr=JSONObject(rs.resourceattr)
        if rs.resourceattr.node_id is not None:
            tmp_rs.resourceattr.node = JSONObject(rs.resourceattr.node)
        elif rs.resourceattr.link_id is not None:
            tmp_rs.resourceattr.link = JSONObject(rs.resourceattr.link)
        elif rs.resourceattr.group_id is not None:
            tmp_rs.resourceattr.resourcegroup = JSONObject(rs.resourceattr.resourcegroup)
        elif rs.resourceattr.network_id is not None:
            tmp_rs.resourceattr.network = JSONObject(rs.resourceattr.network)

        json_rs.append(tmp_rs)


    return json_rs
552530
def __get_entities(self, etype):
        """"""
        r = fapi.get_entities(self.namespace, self.name,
                              etype, self.api_url)
        fapi._check_response_code(r, 200)
        return [Entity(e['entityType'], e['name'], e['attributes'])
                for e in r.json()]
1242363
def get_bug_report():
        
        platform_info = BugReporter.get_platform_info()
        module_info = {
            'version': hal_version.__version__,
            'build': hal_version.__build__
        }

        return {
            'platform': platform_info,
            'pyhal': module_info
        }
996420
private static String getHelp()
	{
		StringBuffer sb = new StringBuffer();

		// SRE
		sb.append("\njSRE: Simple Relation Extraction V1.10\t 30.08.06\n");
		sb.append("developed by Claudio Giuliano (giuliano@itc.it)\n\n");

		// License
		sb.append("Copyright 2005 FBK-irst (http://www.fbk.eu)\n");
		sb.append("\n");
		sb.append("Licensed under the Apache License, Version 2.0 (the \"License\");\n");
		sb.append("you may not use this file except in compliance with the License.\n");
		sb.append("You may obtain a copy of the License at\n");
		sb.append("\n");
		sb.append("    http://www.apache.org/licenses/LICENSE-2.0\n");
		sb.append("\n");
		sb.append("Unless required by applicable law or agreed to in writing, software\n");
		sb.append("distributed under the License is distributed on an \"AS IS\" BASIS,\n");
		sb.append("WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n");
		sb.append("See the License for the specific language governing permissions and\n");
		sb.append("limitations under the License.\n\n");

		// Usage
		sb.append("Usage: java org.itc.irst.tcc.sre.SentenceSet2VectorSet [options] example-file model-file output-file\n\n");

		// Arguments
		sb.append("Arguments:\n");
		sb.append("\ttest-file\t-> file with test data (SRE format)\n");
		sb.append("\tmodel-file\t-> file from which to load the learned model\n");
		sb.append("\toutput-file\t-> file in which to store resulting output\n");

		sb.append("Options:\n");
		sb.append("\t-h\t\t-> this help\n");

		return sb.toString();
	}
1041298
def get_attributes(name, region=None, key=None, keyid=None, profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    try:
        url = conn.get_queue_url(QueueName=name)['QueueUrl']
        r = conn.get_queue_attributes(QueueUrl=url, AttributeNames=['All'])
        return {'result': r['Attributes']}
    except botocore.exceptions.ClientError as e:
        return {'error': __utils__['boto3.get_error'](e)}
1128188
def create_bug(self, request):
        
        if settings.BUGFILER_API_KEY is None:
            return Response({"failure": "Bugzilla API key not set!"},
                            status=HTTP_400_BAD_REQUEST)

        params = request.data

        # Arbitrarily cap crash signatures at 2048 characters to prevent perf issues on bmo
        crash_signature = params.get("crash_signature")
        if crash_signature and len(crash_signature) > 2048:
            return Response({"failure": "Crash signature can't be more than 2048 characters."},
                            status=HTTP_400_BAD_REQUEST)

        description = u"**Filed by:** {}\n{}".format(
            request.user.email.replace('@', " [at] "),
            params.get("comment", "")
        ).encode("utf-8")
        summary = params.get("summary").encode("utf-8").strip()
        url = settings.BUGFILER_API_URL + "/rest/bug"
        headers = {
            'x-bugzilla-api-key': settings.BUGFILER_API_KEY,
            'Accept': 'application/json'
        }
        data = {
            'product': params.get("product"),
            'component': params.get("component"),
            'summary': summary,
            'keywords': params.get("keywords"),
            'blocks': params.get("blocks"),
            'depends_on': params.get("depends_on"),
            'see_also': params.get("see_also"),
            'version': params.get("version"),
            'cf_crash_signature': params.get("crash_signature"),
            'severity': params.get("severity"),
            'priority': params.get("priority"),
            'description': description,
            'comment_tags': "treeherder",
        }

        try:
            response = make_request(url, method='POST', headers=headers, json=data)
        except requests.exceptions.HTTPError as e:
            try:
                message = e.response.json()['message']
            except (ValueError, KeyError):
                message = e.response.text
            return Response({"failure": message}, status=HTTP_400_BAD_REQUEST)

        return Response({"success": response.json()["id"]})
671005
def get_bugs_simple(self, bugids):
        
        payload = {'ids': bugids}
        d = self.call('Bug.get', payload)
        d.addCallback(self._parse_bugs_callback)
        return d
65866
def retrieve(self, request, project, pk=None):
        
        job_id, bug_id = map(int, pk.split("-"))
        job = Job.objects.get(repository__name=project, id=job_id)
        try:
            bug_job_map = BugJobMap.objects.get(job=job, bug_id=bug_id)
            serializer = BugJobMapSerializer(bug_job_map)

            return Response(serializer.data)
        except BugJobMap.DoesNotExist:
            return Response("Object not found", status=HTTP_404_NOT_FOUND)
611690
def get_bugs_summaries(self, bugids):
        
        payload = {'ids': bugids, 'include_fields': ['id', 'summary']}
        d = self.call('Bug.get', payload)
        d.addCallback(self._parse_bugs_callback)
        return d
1233663
def get_entity(self, etype, entity_id):
        
        r = fapi.get_entity(self.namespace, self.name, etype,
                               entity_id, self.api_url)
        fapi._check_response_code(r, 200)
        dresp = r.json()
        return Entity(etype, entity_id, dresp['attributes'])
999344
def get_match_details(self, match_id=None, **kwargs):
        
        if 'match_id' not in kwargs:
            kwargs['match_id'] = match_id
        url = self.__build_url(urls.GET_MATCH_DETAILS, **kwargs)
        req = self.executor(url)
        if self.logger:
            self.logger.info('URL: {0}'.format(url))
        if not self.__check_http_err(req.status_code):
            return response.build(req, url, self.raw_mode)
563204
def getbugs(self, idlist,
                include_fields=None, exclude_fields=None, extra_fields=None,
                permissive=True):
        
        data = self._getbugs(idlist, include_fields=include_fields,
            exclude_fields=exclude_fields, extra_fields=extra_fields,
            permissive=permissive)
        return [(b and Bug(self, dict=b,
                           autorefresh=self.bug_autorefresh)) or None
                for b in data]
429415
def has_bug?(name, _options = {})
      unless self.respond_to?(:version) && version
        puts 'To test for the presence of a bug the object must implement an attribute'
        puts "called 'version' which returns the IP version represented by the the object."
        fail 'Version undefined!'
      end
      name = name.to_s.downcase.to_sym
      if bugs[name]
        bugs[name].present_on_version?(version)
      else
        false
      end
    end
653136
public List<Attribute> getAttributes(String domain, String beanName, String[] attributes) throws Exception {
		checkClientConnected();
		return getAttributes(ObjectNameUtil.makeObjectName(domain, beanName), attributes);
	}
933652
def get_any_entity(self, id=None, uri=None, match=None):
        

        if not id and not uri and not match:
            return None

        if type(id) == type("string"):
            uri = id
            id = None
            if not is_http(uri):
                match = uri
                uri = None
        if match:
            if type(match) != type("string"):
                return []
            res = []
            if ":" in match:  # qname
                for x in self.all_classes:
                    if match.lower() in x.qname.lower():
                        res += [x]
                for x in self.all_properties:
                    if match.lower() in x.qname.lower():
                        res += [x]
            else:
                for x in self.all_classes:
                    if match.lower() in x.uri.lower():
                        res += [x]
                for x in self.all_properties:
                    if match.lower() in x.uri.lower():
                        res += [x]
            return res
        else:
            for x in self.all_classes:
                if id and x.id == id:
                    return x
                if uri and x.uri.lower() == uri.lower():
                    return x
            for x in self.all_properties:
                if id and x.id == id:
                    return x
                if uri and x.uri.lower() == uri.lower():
                    return x
            return None
292229
def get_attributes(**kwargs):
    

    attrs = db.DBSession.query(Attr).order_by(Attr.name).all()

    return attrs