:source_data": Data from data.get('SearchResults:searchresults', None)['response']['results']['result']['localRealEstate']
        :return:
961439
def set_data(self, source_data):
        
        self.region_name = source_data['region']['@name']
        self.region_id = source_data['region']['@id']
        self.region_type =  source_data['region']['@type']
        self.zillow_home_value_index = source_data.get('zindexValue', None)
        self.overview_link =  source_data['region']['links']['overview']
        self.fsbo_link =  source_data['region']['links']['forSaleByOwner']
        self.sale_link =  source_data['region']['links']['forSale']
64517
def _get_data_from_table(source, fields='*', first_row=0, count=-1, schema=None):
  
  if not source.exists():
    return _get_data_from_empty_list(source, fields, first_row, count)
  if schema is None:
    schema = source.schema
  fields = get_field_list(fields, schema)
  gen = source.range(first_row, count) if count >= 0 else source
  rows = [{'c': [{'v': row[c]} if c in row else {} for c in fields]} for row in gen]
  return {'cols': _get_cols(fields, schema), 'rows': rows}, source.length
1282521
def get_data(self):
        
        if self.handle is None:
            raise Exception("Cannot get data before construct Dataset")
        if self.data is not None and self.used_indices is not None and self.need_slice:
            if isinstance(self.data, np.ndarray) or scipy.sparse.issparse(self.data):
                self.data = self.data[self.used_indices, :]
            elif isinstance(self.data, DataFrame):
                self.data = self.data.iloc[self.used_indices].copy()
            elif isinstance(self.data, DataTable):
                self.data = self.data[self.used_indices, :]
            else:
                warnings.warn("Cannot subset {} type of raw data.\n"
                              "Returning original raw data".format(type(self.data).__name__))
            self.need_slice = False
        return self.data
290761
def _do_search(self):
        
        if self._results_cache is None:
            response = self.raw()
            results = self.to_python(response.get('hits', {}).get('hits', []))
            self._results_cache = DictSearchResults(
                self.type, response, results, None)
        return self._results_cache
368956
private String getSearchResultsSource(SearchResults portletSearchResults) {
        // Return the first source in the result.
        List<SearchResult> portletResults = portletSearchResults.getSearchResult();
        String source = "unknown";
        if (portletResults.size() > 0
                && portletResults.get(0).getType() != null
                && !portletResults.get(0).getType().isEmpty()) {
            source = portletResults.get(0).getType().get(0);
        }
        return source;
    }
15873
def get_data
      response = proxy.get_data(handle)
      update_properties(response)
      self.partial = false
      self.persisted = true
    end
170079
def get_py_source(file):
    
    try:
        response = None
        pysource = ""

        if regexp_py.search(file) is None:
            response = {"error": "Only Python source files are allowed. (*.py)"}
        else:
            with open(file, 'r') as pyfile:
                pysource = pyfile.read()

            response = {"data": pysource}

    except Exception as e:
        response = {"error": str(e)}
    finally:
        return response
813313
def source_index(self):
        
        return self.get(property_name='source_index',
                        default=os.path.join(self.data_directory, 'sources'))
210180
def data(self):
        """"""
        if self._resources is None:
            self.__init()
        if "data" in self._resources:
            url = self._url + "/data"
            return _data.Data(url=url,
                              securityHandler=self._securityHandler,
                              initialize=True,
                              proxy_url=self._proxy_url,
                              proxy_port=self._proxy_port)
        else:
            return None
918359
def get_data(search_string, search_by='ip'):
    
    r_details = requests.get('https://talosintelligence.com/sb_api/query_lookup',
            headers={
                'Referer':'https://talosintelligence.com/reputation_center/lookup?search=%s'%search_string,
                'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0'
                },
            params = {
                'query':'/api/v2/details/ip/',
                'query_entry':search_string
                }).json()

    r_wscore = requests.get('https://talosintelligence.com/sb_api/remote_lookup',
            headers={
                'Referer':'https://talosintelligence.com/reputation_center/lookup?search=%s'%search_string,
                'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0'
                },
            params = {'hostname':'SDS', 'query_string':'/score/wbrs/json?url=%s' % search_string}).json()

    r_talos_blacklist = requests.get('https://www.talosintelligence.com/sb_api/blacklist_lookup',
            headers={
                'Referer':'https://talosintelligence.com/reputation_center/lookup?search=%s'%search_string,
                'User-Agent':'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:64.0) Gecko/20100101 Firefox/64.0'
                },
            params = {'query_type':'ipaddr', 'query_entry':search_string}).json()

    # would be nice to plot this values
    #r_volume = requests.get('https://talosintelligence.com/sb_api/query_lookup',
    #        params = {
    #            'query':'/api/v2/volume/ip/',
    #            'query_entry':search_string
    #            }).json()

    # No used for now
    #r_related_ips = requests.get('https://talosintelligence.com/sb_api/query_lookup',
    #        params = {
    #            'query':'/api/v2/related_ips/ip/',
    #            'query_entry':search_string
    #            }).json()

    
    talos_blacklisted = {'status':False}
    if 'classifications' in r_talos_blacklist['entry']:
        talos_blacklisted['status'] = True
        talos_blacklisted['classifications'] = ", ".join(r_talos_blacklist['entry']['classifications'])
        talos_blacklisted['first_seen'] = r_talos_blacklist['entry']['first_seen'] + "UTC"
        talos_blacklisted['expiration'] = r_talos_blacklist['entry']['expiration'] + "UTC"

    data = {
        'address':search_string,
        'hostname':r_details['hostname'] if 'hostname' in r_details else "nodata",
        'volume_change':r_details['daychange'] if 'daychange' in r_details else "nodata",
        'lastday_volume':r_details['daily_mag'] if 'daily_mag' in r_details else "nodata",
        'month_volume':r_details['monthly_mag'] if 'monthly_mag' in r_details else "nodata",
        'email_reputation':r_details['email_score_name'] if 'email_score_name' in r_details else "nodata",
        'web_reputation':r_details['web_score_name'] if 'web_score_name' in r_details else "nodata",
        'weighted_reputation_score':r_wscore['response'],
        'talos_blacklisted':"Yes" if talos_blacklisted['status'] else "No"
        #'weighted_reputation_score':r_wscore[0]['response']['wbrs']['score'],
        #'volumes':zip(*r_volume['data'])
    }

    return data
493073
def get_data(url, gallery_dir):
    """"""

    # shelve keys need to be str in python 2
    if sys.version_info[0] == 2 and isinstance(url, unicode):
        url = url.encode('utf-8')

    cached_file = os.path.join(gallery_dir, 'searchindex')
    search_index = shelve.open(cached_file)
    if url in search_index:
        data = search_index[url]
    else:
        data = _get_data(url)
        search_index[url] = data
    search_index.close()

    return data
448394
def get(self):
        
        keys = r_kv.keys()
        keys.sort()
        return build_response(dict(data=keys, code=200))
599996
def get_results(self, client):
        
        data = self._request('GET', '/results/{}'.format(client))
        return data.json()
1301131
def datasource(self):
        
        import ns1.rest.data
        return ns1.rest.data.Source(self.config)
1023470
def _get_result_paths(self,data):
        
        result = {}
        result['Tree'] = ResultPath(Path=splitext(self._input_filename)[0] + \
                                                  '.tree')
        return result
8910
def to_api_data(self, restrict_keys=None):
        
        cc = self._cc  # alias
        data = {
            cc('column_hidden'): self._column_hidden,
            cc('row_hidden'): self._row_hidden,
            cc('formulas'): self._formulas,
            cc('formulas_local'): self._formulas_local,
            cc('formulas_r1_c1'): self._formulas_r1_c1,
            cc('number_format'): self._number_format,
            cc('values'): self._values,
        }

        if restrict_keys:
            for key in list(data.keys()):
                if key not in restrict_keys:
                    del data[key]
        return data
760183
def _init_datasource(self, data):
        
        data = self._postprocess_data(data)
        return ColumnDataSource(data=data)