Search zipcode information by land area / sq miles range.
966823
def by_land_area_in_sqmi(self,
                             lower=-1,
                             upper=2 ** 31,
                             zipcode_type=ZipcodeType.Standard,
                             sort_by=SimpleZipcode.land_area_in_sqmi.name,
                             ascending=False,
                             returns=DEFAULT_LIMIT):
        
        return self.query(
            land_area_in_sqmi_lower=lower,
            land_area_in_sqmi_upper=upper,
            sort_by=sort_by, zipcode_type=zipcode_type,
            ascending=ascending, returns=returns,
        )
1360253
def by_median_home_value(self,
                             lower=-1,
                             upper=2 ** 31,
                             zipcode_type=ZipcodeType.Standard,
                             sort_by=SimpleZipcode.median_home_value.name,
                             ascending=False,
                             returns=DEFAULT_LIMIT):
        
        return self.query(
            median_home_value_lower=lower,
            median_home_value_upper=upper,
            sort_by=sort_by, zipcode_type=zipcode_type,
            ascending=ascending, returns=returns,
        )
1228647
def do_search(self, string):
        """"""
        results = self.n.doSearch(string, full_path = self.current_path)

        if results:
            for r in results:
                self.stdout.write("%s\n" % r['path'])
171484
public OvhAsyncTaskArray<OvhCity> eligibility_search_cities_POST(String zipCode) throws IOException {
		String qPath = "/connectivity/eligibility/search/cities";
		StringBuilder sb = path(qPath);
		HashMap<String, Object>o = new HashMap<String, Object>();
		addBody(o, "zipCode", zipCode);
		String resp = execN(qPath, "POST", sb.toString(), o);
		return convertTo(resp, t4);
	}
815567
def get_dataset(self, key, info):
        """"""
        res = super(HRITGOMSFileHandler, self).get_dataset(key, info)

        res = self.calibrate(res, key.calibration)
        res.attrs['units'] = info['units']
        res.attrs['standard_name'] = info['standard_name']
        res.attrs['wavelength'] = info['wavelength']
        res.attrs['platform_name'] = self.platform_name
        res.attrs['sensor'] = 'msu-gs'
        res.attrs['satellite_longitude'] = self.mda['projection_parameters']['SSP_longitude']
        res.attrs['satellite_latitude'] = 0
        res.attrs['satellite_altitude'] = 35785831.00

        return res
1139361
public function find($zipcode)
    {
        $this->setZipCode($zipcode)
            ->buildXMLBody()
            ->sendWebServiceRequest()
            ->parseXMLFromResponse();

        if ($this->hasErrorMessage()) {
            return $this->fetchErrorMessage();
        }

        return $this->fetchZipCodeAddress();
    }
207904
def search_product(self, limit=100, offset=0, with_price=0, with_supported_software=0,
                       with_description=0):
        """"""

        response = self.request(E.searchProductSslCertRequest(
            E.limit(limit),
            E.offset(offset),
            E.withPrice(int(with_price)),
            E.withSupportedSoftware(int(with_supported_software)),
            E.withDescription(int(with_description)),
        ))
        return response.as_models(SSLProduct)
670628
def _fetch(self, searchtype, fields, **kwargs):
        ''''''
        fields['vintage'] = self.vintage
        fields['benchmark'] = self.benchmark
        fields['format'] = 'json'

        if 'layers' in kwargs:
            fields['layers'] = kwargs['layers']

        returntype = kwargs.get('returntype', 'geographies')
        url = self._geturl(searchtype, returntype)

        try:
            with requests.get(url, params=fields, timeout=kwargs.get('timeout')) as r:
                content = r.json()
                if "addressMatches" in content.get('result', {}):
                    return AddressResult(content)

                if "geographies" in content.get('result', {}):
                    return GeographyResult(content)

                raise ValueError()

        except (ValueError, KeyError):
            raise ValueError("Unable to parse response from Census")

        except RequestException as e:
            raise e
83209
def searchZone(self, zone, q=None, has_geo=False, callback=None, errback=None):
        
        import ns1.zones
        return zone.search(q, has_geo, callback=callback, errback=errback)
105807
def by_population_density(self,
                              lower=-1,
                              upper=2 ** 31,
                              zipcode_type=ZipcodeType.Standard,
                              sort_by=SimpleZipcode.population_density.name,
                              ascending=False,
                              returns=DEFAULT_LIMIT):
        
        return self.query(
            population_density_lower=lower,
            population_density_upper=upper,
            sort_by=sort_by, zipcode_type=zipcode_type,
            ascending=ascending, returns=returns,
        )
561962
def find_near(lat, lon, *, n=10, session=None):
    """"""
    search_params = {'npoints': n, 'clat': lat, 'clon': lon, 
                     'Columns[]': ['Subregion', 'Notes', 'CollectionYear', 
                                   'ReservoirAge', 'ReservoirErr', 'C14age', 
                                   'C14err', 'LabID', 'Delta13C', 'nextime', 
                                   'Genus', 'Species', 'Feeding', 'Name']}
    resp = _query_near(session=session, **search_params)
    df = _response_to_dataframe(resp)
    df_clean = _clean_dataframe(df)
    return df_clean
413231
def get_array_size(self):
        """"""
        match = re.search(r"(?<=\[)\d+(?=\])", self.get_address())
        return int(match.group(0))
628061
def _autobounds(self):
        """"""
        bounds = {}

        def check(prop, compare, extreme, val):
            opp = min if compare is max else max
            bounds.setdefault(prop, val)
            bounds[prop] = opp(compare(bounds[prop], val), extreme)

        def bound_check(lat_lon):
            lat, lon = lat_lon
            check('max_lat', max, 90, lat)
            check('min_lat', min, -90, lat)
            check('max_lon', max, 180, lon)
            check('min_lon', min, -180, lon)

        lat_lons = [lat_lon for feature in self._features.values() for
                    lat_lon in feature.lat_lons]
        if not lat_lons:
            lat_lons.append(self._default_lat_lon)
        for lat_lon in lat_lons:
            bound_check(lat_lon)

        return bounds
519322
def search(opts={})
      iso_country_code = opts[:iso_country_code] || 'US'
      resource = opts.delete(:resource)

      params = {
        :AreaCode => opts[:area_code],
        :InPostalCode => opts[:postal_code],
        :InRegion => opts[:in_region],
        :Contains => opts[:contains],
        :NearLatLong => opts[:near_lat_long],
        :NearNumber => opts[:near_number],
        :InLata => opts[:in_lata],
        :InRateCenter => opts[:in_rate_center],
        :Distance => opts[:distance],
        :Page => opts[:page],
        :PageSize => opts[:page_size]
      }.reject {|k,v| v == nil} unless opts.empty?
      
      Twilio.get("/AvailablePhoneNumbers/#{iso_country_code}/#{resource}", :query => params)
    end
1004993
def query_search_api(min_lat, max_lat, min_lon, max_lon, max_results):
    '''
    
    '''

    # Create URL
    params = urllib.urlencode(zip(
        ['client_id', 'bbox', 'per_page'],
        [CLIENT_ID, ','.join([str(min_lon), str(min_lat), str(
            max_lon), str(max_lat)]), str(max_results)]
    ))
    print(MAPILLARY_API_IM_SEARCH_URL + params)

    # Get data from server, then parse JSON
    query = urllib2.urlopen(MAPILLARY_API_IM_SEARCH_URL + params).read()
    query = json.loads(query)['features']

    print("Result: {0} images in area.".format(len(query)))
    return query
314259
function findNearCoords(err, postalObj) {
      if (err) throw err;
      if (!postalObj || postalObj === null) {
        throw new Error("No postal object found for zipcode "+zipcode+" using document attribute "
          +selectorAttr+"; make sure postal data has been loaded.");
      }
      var geoSearchParams = { 
        loc : { 
          $within: {
            $centerSphere : [postalObj.loc, milesToRadians(radiusMiles)], 
            $uniqueDocs:true
          }
        } 
      };
      dbCollection.find(geoSearchParams).limit(limit).toArray(this);
    }
126197
final void searchMap(String address) {
    launchIntent(new Intent(Intent.ACTION_VIEW, Uri.parse("geo:0,0?q=" + Uri.encode(address))));
  }