Python env.get函数代码示例

 def setUpClass(cls):
     if not credentials:
         return
     cls.geocoder = IGNFrance(
         api_key=env.get('IGNFRANCE_KEY'),
         username=env.get('IGNFRANCE_USERNAME'),
         password=env.get('IGNFRANCE_PASSWORD'),
         referer=env.get('IGNFRANCE_REFERER'),
         timeout=10
     )
     cls.delta_exact = 0.2

 def setUpClass(cls):
     cls.delta = 0.04
     cls.geocoder = GeocodeFarm(
         # None api_key will use free tier on GeocodeFarm.
         api_key=env.get('GEOCODEFARM_KEY'),
         timeout=10,
     )

from geopy.exc import ConfigurationError
from test.geocoders.nominatim import BaseNominatimTestCase
from test.geocoders.util import GeocoderTestBase, env
import unittest


class OpenMapQuestNoNetTestCase(GeocoderTestBase):

    def test_user_agent_custom(self):
        geocoder = OpenMapQuest(
            api_key='DUMMYKEY1234',
            user_agent='my_user_agent/1.0'
        )
        self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')

    def test_raises_without_apikey(self):
        with self.assertRaises(ConfigurationError):
            OpenMapQuest()


@unittest.skipUnless(
    bool(env.get('OPENMAPQUEST_APIKEY')),
    "No OPENMAPQUEST_APIKEY env variable set"
)
class OpenMapQuestTestCase(BaseNominatimTestCase, GeocoderTestBase):

    @classmethod
    def make_geocoder(cls, **kwargs):
        return OpenMapQuest(api_key=env['OPENMAPQUEST_APIKEY'],
                            timeout=3, **kwargs)

import unittest
import types

from geopy import exc
from geopy.point import Point
from geopy.geocoders import GeocodeFarm
from test.geocoders.util import GeocoderTestBase, env


@unittest.skipUnless(  # pylint: disable=R0904,C0111
    bool(env.get("GEOCODEFARM_KEY")), "GEOCODEFARM_KEY env variable not set"
)
class GeocodeFarmTestCase(GeocoderTestBase):  # pylint: disable=R0904,C0111
    @classmethod
    def setUpClass(cls):
        cls.delta = 0.04
        cls.geocoder = GeocodeFarm(api_key=env["GEOCODEFARM_KEY"], format_string="%s US")

    def test_geocode(self):
        """
        OpenCage.geocode
        """
        self.geocode_run(
            {"query": "435 north michigan ave, chicago il 60611 usa"}, {"latitude": 41.890, "longitude": -87.624}
        )

    def test_reverse_string(self):
        """
        GeocodeFarm.reverse string
        """
        self.reverse_run(

import unittest

from geopy.compat import u
from geopy.point import Point
from geopy.geocoders import Bing
from test.geocoders.util import GeocoderTestBase, env


@unittest.skipUnless(bool(env.get("BING_KEY")), "No BING_KEY env variable set")  # pylint: disable=R0904,C0111
class BingTestCase(GeocoderTestBase):
    @classmethod
    def setUpClass(cls):
        cls.geocoder = Bing(format_string="%s", scheme="http", api_key=env["BING_KEY"])

    def test_geocode(self):
        """
        Bing.geocode
        """
        self.geocode_run(
            {"query": "435 north michigan ave, chicago il 60611 usa"}, {"latitude": 41.890, "longitude": -87.624}
        )

    def test_unicode_name(self):
        """
        Bing.geocode unicode
        """
        self.geocode_run({"query": u("\u6545\u5bab")}, {"latitude": 39.916, "longitude": 116.390})

    def test_reverse_point(self):
        """
        Bing.reverse using point

import unittest

from geopy.geocoders import AzureMaps
from test.geocoders.util import GeocoderTestBase, env
from test.geocoders.tomtom import BaseTomTomTestCase


@unittest.skipUnless(
    bool(env.get('AZURE_SUBSCRIPTION_KEY')),
    "No AZURE_SUBSCRIPTION_KEY env variable set"
)
class AzureMapsTestCase(BaseTomTomTestCase, GeocoderTestBase):

    @classmethod
    def make_geocoder(cls, **kwargs):
        return AzureMaps(env['AZURE_SUBSCRIPTION_KEY'], timeout=3,
                         **kwargs)

import unittest

from geopy import exc
from geopy.compat import u
from geopy.point import Point
from geopy.geocoders import ArcGIS
from test.geocoders.util import GeocoderTestBase, env


@unittest.skipUnless(  # pylint: disable=R0904,C0111
    bool(env.get('ARCGIS_USERNAME')),
    "No ARCGIS_USERNAME env variable set"
)
class ArcGISTestCase(GeocoderTestBase):

    @classmethod
    def setUpClass(cls):
        cls.geocoder = ArcGIS(timeout=3)

    def test_config_error(self):
        """
        ArcGIS.__init__ invalid authentication
        """
        with self.assertRaises(exc.ConfigurationError):
            ArcGIS(username='a')

    def test_scheme_config_error(self):
        """
        ArcGIS.__init__ invalid scheme
        """
        with self.assertRaises(exc.ConfigurationError):

    def test_custom_wkid(self):
        with warnings.catch_warnings(record=True) as w:
            warnings.simplefilter('always')
            # Custom wkid should be ignored and a warning should be issued.
            location = self.reverse_run(
                {"query": Point(40.753898, -73.985071), "wkid": 2000},
                {"latitude": 40.75376406311989,
                 "longitude": -73.98489005863667},
            )
            self.assertIn('New York', location.address)
            self.assertEqual(1, len(w))


@unittest.skipUnless(
    (env.get('ARCGIS_USERNAME') is not None
     or env.get('ARCGIS_PASSWORD') is not None
     or env.get('ARCGIS_REFERER') is not None),
    "No ARCGIS_USERNAME or ARCGIS_PASSWORD or ARCGIS_REFERER env variable set"
)
class ArcGISAuthenticatedTestCase(GeocoderTestBase):

    @classmethod
    def setUpClass(cls):
        cls.geocoder = ArcGIS(
            username=env['ARCGIS_USERNAME'],
            password=env['ARCGIS_PASSWORD'],
            referer=env['ARCGIS_REFERER'],
            timeout=3
        )

import unittest

from geopy.compat import u
from geopy.geocoders import What3Words
from test.geocoders.util import GeocoderTestBase, env


@unittest.skipUnless(bool(env.get('WHAT3WORDS_KEY')),
                     "No WHAT3WORDS_KEY env variable set"
)
class What3WordsTestCase(GeocoderTestBase):
    @classmethod
    def setUpClass(cls):
        cls.geocoder = What3Words(
            env['WHAT3WORDS_KEY'],
            scheme='http',
            timeout=3

        )
        cls.delta = 0.7

    def test_geocode(self):
        """
        What3Words.geocode - '3 Words' and 'OneWord'
        """
        self.geocode_run(
            {"query": u("piped.gains.jangle")},
            {"latitude": 53.037611, "longitude": 11.565012},
        )

        self.geocode_run(

import unittest

from geopy.geocoders import MapQuest
from test.geocoders.util import GeocoderTestBase, env


@unittest.skipUnless(  # pylint: disable=R0904,C0111
    bool(env.get('MAPQUEST_KEY')),
    "No MAPQUEST_KEY env variable set"
)
class MapQuestTestCase(GeocoderTestBase):

    @classmethod
    def setUpClass(cls):
        cls.geocoder = MapQuest(
            env['MAPQUEST_KEY'],
            scheme='http',
            timeout=3
        )
        cls.delta = 0.7

    def test_geocode(self):
        """
        MapQuest.geocode
        """
        self.geocode_run(
            {"query": u"435 north michigan ave, chicago il 60611 usa"},
            {"latitude": 41.890, "longitude": -87.624},
        )

from test.geocoders.util import GeocoderTestBase, env


class HereTestCaseUnitTest(GeocoderTestBase):

    def test_user_agent_custom(self):
        geocoder = Here(
            app_id='DUMMYID1234',
            app_code='DUMMYCODE1234',
            user_agent='my_user_agent/1.0'
        )
        self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')


@unittest.skipUnless(
    bool(env.get('HERE_APP_ID')),
    "No HERE_APP_ID env variable set"
)
@unittest.skipUnless(
    bool(env.get('HERE_APP_CODE')),
    "No HERE_APP_CODE env variable set"
)
class HereTestCase(GeocoderTestBase):

    @classmethod
    def setUpClass(cls):
        cls.geocoder = Here(
            app_id=env['HERE_APP_ID'],
            app_code=env['HERE_APP_CODE'],
            timeout=10,
        )

# -*- coding: utf8 -*-
import unittest

from geopy.exc import ConfigurationError, GeocoderQueryError
from geopy.geocoders import IGNFrance
from test.geocoders.util import GeocoderTestBase, env

credentials = bool(
    (env.get('IGNFRANCE_KEY') and env.get('IGNFRANCE_USERNAME')
     and env.get('IGNFRANCE_PASSWORD')) or (
         env.get('IGNFRANCE_KEY') and env.get('IGNFRANCE_REFERER'))
)


class IGNFranceTestCaseUnitTest(GeocoderTestBase):

    def test_user_agent_custom(self):
        geocoder = IGNFrance(
            api_key='DUMMYKEY1234',
            username='MUSTERMANN',
            password='tops3cr3t',
            user_agent='my_user_agent/1.0'
        )
        self.assertEqual(geocoder.headers['User-Agent'], 'my_user_agent/1.0')


@unittest.skipUnless(
    credentials,
    "One or more of the env variables IGNFRANCE_KEY, IGNFRANCE_USERNAME "
    "and IGNFRANCE_PASSWORD is not set"
)

        with self.assertRaises(geopy.exc.ConfigurationError):
            What3Words(
                api_key=self.dummy_api_key,
                scheme='http',
            )

    @patch.object(geopy.geocoders.options, 'default_scheme', 'http')
    def test_default_scheme_is_ignored(self):
        geocoder = What3Words(api_key=self.dummy_api_key)
        self.assertEqual(geocoder.scheme, 'https')
        geocoder = What3Words(api_key=self.dummy_api_key, scheme=None)
        self.assertEqual(geocoder.scheme, 'https')


@unittest.skipUnless(
    bool(env.get('WHAT3WORDS_KEY')),
    "No WHAT3WORDS_KEY env variable set"
)
class What3WordsTestCase(GeocoderTestBase):
    @classmethod
    def setUpClass(cls):
        cls.geocoder = What3Words(
            env['WHAT3WORDS_KEY'],
            scheme='https',
            timeout=3

        )
        cls.delta = 0.7

    def test_geocode(self):
        self.geocode_run(

import unittest

from geopy.geocoders import LiveAddress
from test.geocoders.util import GeocoderTestBase, env


@unittest.skipUnless(  # pylint: disable=R0904,C0111
    bool(env.get('LIVESTREETS_AUTH_KEY')),
    "No LIVESTREETS_AUTH_KEY env variable set"
)
class LiveAddressTestCase(GeocoderTestBase):

    @classmethod
    def setUpClass(cls):
        cls.geocoder = LiveAddress(
            auth_token=env['LIVESTREETS_AUTH_KEY'],
            scheme='http'
        )
        cls.delta = 0.04

    def test_geocode(self):
        """
        LiveAddress.geocode
        """
        self.geocode_run(
            {"query": u"435 north michigan ave, chicago il 60611 usa"},
            {"latitude": 41.890, "longitude": -87.624},
        )

 def make_geocoder(cls, **kwargs):
     return Pelias(env.get('PELIAS_DOMAIN'), api_key=env.get('PELIAS_KEY'),
                   **kwargs)