Application: gvSIG desktop » gvSIG scripting

#Mon Aug 28 18:11:58 CEST 2023

buildNumber=303

<?xml version="1.0"?>

<!--

Definitions of plugin persistence org.gvsig.scripting.app.mainplugin.

 -->

<definitions>

  <version>1.0.0</version>

  <classes>

    <class name="org.gvsig.scripting.app.mainplugin">

      <description>Persistence of scripting plugin</description>

      <fields>

        <field name="ComposerUseHisWindowManager" type="boolean" mandatory="true" defaultValue="true">

          <description>When true the composer use his window manager instead of the gvSIG Window manager.</description>

        </field>

      </fields>

    </class>

  </classes>

</definitions>

_Scripting=Scripting

_Show_scripting_launcher=Abrir lanzador de scripts

_Show_scripting_composer=Abrir editor de scripts

_Show_scripting_jython_console=Abrir consola Jython

User=Usuario

System=Sistema

Accept=Aceptar

Cancel=Cancelar

Apply=Aplicar

Retrieving_data=Recibiendo datos...

File=Fichero

New=Nuevo

Close_document=Cerrar documento

Close_all_documents=Cerrar todos los documentos

Run=Ejecutar

Save=Guardar

Close=Cerrar

Close_current_tab=Cerrar pesta\u00f1a actual

Open_edition_mode=Abrir modo edici\u00f3n

Run_selected_script=Ejecutar script seleccionado

Delete_selected_script=Borrar script seleccionado

Refresh_directories=Actualizar carpetas

Move_files=Mover ficheros

Set_file_preferences=Editar preferencias de fichero

Edit=Editar

Cut=Cortar

Copy=Copiar

Paste=Pegar

Select_all=Seleccionar todo

Tools=Herramientas

Launcher=Lanzador de scripts

Scripting_Launcher=Lanzador de scripts

Scripting_Composer=Editor de scripts

Jython_Console=Consola Jython

Import_JavaDoc=Importar JavaDoc

JavaDoc=Ayuda de Java (JavaDoc)

Remove_JavaDoc=Eliminar JavaDoc

Help_contents=Contenido de la ayuda

About_scripts_editor=Acerca del editor de scripts

Get_help=Ayuda

Help=Ayuda

_Package_script=Empaquetar script...

_Package_help=Empaquetar ayuda...

Problems=Errores

Console=Consola

Description=Descripci\u00f3n

Resource=Recurso

Location=Ubicaci\u00f3n

no_line=sin l\u00ednea

Line=L\u00ednea

Welcome_message=Bienvenido al entorno de scripting

Error_opening_in_edition_mode_title=Error al abrir fichero

Error_opening_in_edition_mode=No se pudo abrir el fichero en modo edici\u00f3n

New_Script=Nuevo elemento

New_Script_Description=Crea un nuevo script, di\u00e1logo, proyecto, directorio

Deleting_JavaDocs_successfully_title=Operaci\u00f3n realizada con \u00e9xito

Deleting_JavaDocs_successfully=Eliminaci\u00f3n de los JavaDocs exitosa

Import_JavaDoc_title=Importar JavaDocs desde los directorios de sistema al ScriptingFramework JavaDoc

Remove_JavaDoc_title=Eliminar JavaDocs del ScriptingFramework JavaDoc

projects_modified_title=Proyectos sin guardar

projects_modified=Algunos proyectos han sido modificados.\u00bfSalvar cambios?

project_modified=ha sido modificado.\u00bfSalvar cambios?

Delete_all_title=Borrar el documento

Delete_all_message=Esta acci\u00f3n elimina el documento o el directorio con todo su contenido. \u00bf Desea continuar ?

About_us_title=Informaci\u00f3n de todos los contribuidores al proyecto gvSIG

Success=Operaci\u00f3n realizada con \u00e9xito

Error=Error

Error_renaming=Inesperado error renombrando el fichero

Error_moving=Inesperado error moviendo el fichero

Error_help=Selecciona una ayuda

Rename_succesfully=Renombrado del fichero realizado con \u00e9xito

Select_first=Debe seleccionar un fichero primero

help_key=No hay ayuda para el texto

script_filesystem=script en el \u00e1rbol de directorio

Move=Mover

move_desc=Cambia la ubicaci\u00f3n del fichero seleccionado

Rename=Renombrar

rename_desc=Cambia el nombre y otras propiedades del fichero seleccionado

Moving_succesfully=Reubicaci\u00f3n del fichero realizado con \u00e9xito

Dialog=Di\u00e1logo

Code=C\u00f3digo

Properties=Propiedades

current_name=Nombre actual

new_name=Nuevo name

rename_name_title=Cambiar el nombre del fichero

more_properties=M\u00e1s propiedades

Javadoc_remove=Selecciona el JavaDoc a eliminar

no_Javadoc_remove=No hay JavaDoc para eliminar

Name=Nombre

Version=Versi\u00f3n

Created_by=Creado por

Description=Descripci\u00f3n

Type=Tipo

Language=Lenguaje

Author=Autor

Move_from=Mover desde

Move_to=Destino

Browse=Abrir

Import_from=Importar desde

Name_blank=El nombre no puede estar en blanco

Name_exists=Este nombre ya existe. Debe elegir otro

Import_success=Los JavaDocs se han importado satisfactoriamente

JavaDoc_Error=Selecciona JavaDoc a importar

go_to_line_Xhorizontal_ellipsisX=Ir a la l\u00ednea\u2026

find_Xhorizontal_ellipsisX=Buscar\u2026

replace_Xhorizontal_ellipsisX=Reemplazar\u2026

_Searching_autorun_scripts_Xhorizontal_ellipsisX=Buscando scripts de autoarranque...

_Starting_XnameX=Iniciando {0}...

_The_script_XscriptnameX_is_modified=El script "{0}" ha sido modificado.

_Save_changes_XquestionX=\u00bf Guardar cambios ?

_Do_you_want_to_save_changes_XquestionX=\u00bf Desea guardar los cambios ?

_notice=Aviso

_Initializing_the_scripting_plugin_Xhorizontal_ellipsisX=Inicializando el plugin de scripting...

_Waiting_to_terminate=Esperando que termine.

_Run_main_script=Ejecutar script principal

_Select_main_script=Seleccionar script pricipal

_Main_script_is_not_selected=No hay seleccionado un script como principal.

_The_selected_script_is_invalid=El script seleccionado no es valido.

_Do_you_want_to_select_one_and_execute_it=\u00bfDesea seleccionar uno y ejecutarlo ?

_The_changes_in_current_file_are_not_saved=Los cambios en el fichero corriente no han sido guardados.

_Do_you_want_to_continue_and_discard_the_changes=\u00bf Quiere continuar y descartar los cambios ?

_There_was_a_problem_starting_the_application_It_is_convenient_that_you_close_it_and_start_it_again=Ha habido un problema durante el inicio de la aplicaci\u00f3n.\nEs conveniente que la cierre y vuelva a iniciarla.

_Scripting=Scripting

_Show_scripting_launcher=Show scripting launcher

_Show_scripting_composer=Show scripting composer

_Show_scripting_jython_console=Show Jython console

User=User

System=System

Accept=Accept

Cancel=Cancel

Apply=Apply

Retrieving_data=Retrieving data...

File=File

New=New

Close_document=Close document

Close_all_documents=Cloase all documents

Run=Run

Save=Save

Close=Close

Close_current_tab=Close current tab

Open_edition_mode=Open edition mode

Run_selected_script=Run selected script

Delete_selected_script=Delete selected script

Refresh_directories=Refresh directories

Move_files=Move files

Set_file_preferences=Set file preferences

_Running_autorun_script_from_XnameX=Running autorun script from {0}

Edit=Edit

Cut=Cut

Copy=Copy

Paste=Paste

Select_all=Select all

Tools=Tools

Launcher=Scripting Launcher

Scripting_Launcher=Scripting Launcher

Scripting_Composer=Scripting Composer

Jython_Console=Jython console

Import_JavaDoc=Import JavaDoc

JavaDoc=Java Help (JavaDoc)

Remove_JavaDoc=Remove JavaDoc

Help_contents=Help contents

About_scripts_editor=About scripts editor

Get_help=Help

Help=Help

_Package_script=Package script...

_Package_help=Package help...

Problems=Errors

Console=Console

Description=Description

Resource=Resource

Location=Location

no_line=no line

Line=Line

Welcome_message=Welcome to the scripting framework

Error_opening_in_edition_mode_title=Error opening file in edition mode

Error_opening_in_edition_mode=The file can't be opened in edition mode

New_Script=New element

New_Script_Description=Create a new script, dialog, project, directory

Deleting_JavaDocs_successfully_title=Operation successful

Deleting_JavaDocs_successfully=Deleting JavaDocs successfully

Import_JavaDoc_title=Import JavaDocs from filesystem to ScriptingFramework JavaDoc

Remove_JavaDoc_title=Remove JavaDocs from ScriptingFramework JavaDoc

projects_modified_title=Projects without saving

projects_modified=Some projects have been modified. Save changes?

project_modified=has been modified. Save changes?

Delete_all_title=Delete document

Delete_all_message=This action removes the document or directory with all its content. Do you wish to continue ?

About_us_title=Information about all the gvSIG's contributors

Success=Operation done successfully

Error=Error

Error_renaming=Unexpected error renaming the file

Error_moving=Unexpected error moving the file

Error_help=Select help

Rename_succesfully=Renaming successfully

Select_first=Select a file first

help_key=There isn't any help to this text

script_filesystem=script filesystem

Move=Move

move_desc=Change location of selected file

Rename=Rename

rename_desc=Change the name and more properties of the selected file

Moving_succesfully=File moved succesfully

Dialog=Dialog

Code=Code

Properties=Properties

current_name=Current name

new_name=New name

rename_name_title=Change filename

more_properties=more properties

Javadoc_remove=Choose JavaDoc to delete

no_Javadoc_remove=There's no JavaDoc to delete

Name=Name

Version=Version

Created_by=Create by

Description=Description

Type=Type

Language=Language

Author=Author

Move_from=Move from

Move_to=Move to

Browse=Browse

Import_from=Import from

Name_blank=Name can't be blank

Name_exists=This name already exists. Choose another one

Import_success=JavaDocs imported successfully

JavaDoc_Error=Select JavaDoc to import

go_to_line_Xhorizontal_ellipsisX=Go To Line\u2026

find_Xhorizontal_ellipsisX=Find\u2026

replace_Xhorizontal_ellipsisX=Replace\u2026

_Searching_autorun_scripts_Xhorizontal_ellipsisX=Searching autorun scripts...

_Starting_XnameX=Starting {0}...

_The_script_XscriptnameX_is_modified=The script "{0}" has been modified.

_Save_changes_XquestionX=Save changes ?

_Do_you_want_to_save_changes_XquestionX=Do you want to save changes ?

_notice=Notice

_Initializing_the_scripting_plugin_Xhorizontal_ellipsisX=Initializing the scripting plugin...

_Waiting_to_terminate=Waiting to terminate.

_Run_main_script=Run main script

_Select_main_script=Select main script

_Main_script_is_not_selected=Main script is not selected.

_The_selected_script_is_invalid=The selected script is not valid.

_Do_you_want_to_select_one_and_execute_it=Do you want to select one and execute it?

_The_changes_in_current_file_are_not_saved=The changes in the current file are not saved.

_Do_you_want_to_continue_and_discard_the_changes=Do you want to continue and discard the changes?

_There_was_a_problem_starting_the_application_It_is_convenient_that_you_close_it_and_start_it_again=There was a problem starting the application.\nIt is convenient that you close it and start it again.

----------------------------------------------

CHALKWORK BASIC

by Dave Shea

mezzoblue.com/icons/chalkwork/basic

----------------------------------------------

CHALKWORK COMMERCE

by Dave Shea

mezzoblue.com/icons/chalkwork/commerce

----------------------------------------------

CHALKWORK EDITING CONTROLS

by Dave Shea

mezzoblue.com/icons/chalkwork/editing-controls

----------------------------------------------

CHALKWORK INFORMATION MANAGEMENT

by Dave Shea

mezzoblue.com/icons/chalkwork/information-management

----------------------------------------------

CHALKWORK HTML (Free Version)

by Dave Shea

mezzoblue.com/icons/chalkwork/html

----------------------------------------------

Thanks for your interest in the Chalkwork Family. Please consider subscribing to the Chalkwork news feed, which will announce new releases in the family as well as inform existing users of updates if any occur.

	http://mezzoblue.com/icons/chalkwork/news.xml

- Dave Shea

  mezzoblue.com

  @mezzoblue on Twitter

LICENSE AGREEMENT

----------------------------------------------

By downloading this icon set, you agree to abide by the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License under which these icons are being made available for non-commercial use.

	Applicable Creative Commons License: http://creativecommons.org/licenses/by-nc-sa/3.0/

	Attribution and additional license information: http://www.mezzoblue.com/icons/license/#license-cc

By purchasing a Chalkwork Commercial License, you agree to abide by the Chalkwork Royalty-Free Stock Icon License Agreement under which these icons are being made available for commercial use.

	Chalkwork Commercial License: http://www.mezzoblue.com/icons/license/#license-cc

This notice must be included any time these icons are redistributed.

----------------------------------------------

ICON FOLDER INDEX

----------------------------------------------

The icon files are broken down by file format. Due to some formats resulting in higher quality results, those are considered the preferred files and are located in the folder titled 'High Quality'. This package should contain the following folders in this hierarchy:

High Quality

    ICNS (Mac)

    ICO (Windows)

    PNG

    TIF

Lower Quality

    BMP

    GIF

Within each of the second-level folders, you'll find 102 further folders, one for each icon and its variations. Depending on the file format, you may find multiple sizes within these folders along with any icon variations that may exist. Please note that ICO and ICNS files contain all applicable sizes within a single file, and that ICNS files do not support the 24x24 icon size.

----------------------------------------------

CHALKWORK INFORMATION MANAGEMENT ICON INDEX

* indicates that variations of this icon are provided within this set

---------------------------------------------------------------------

Ad

	- Ad (Dollars) *

	- Ad (Euros) *

	- Ad (Pounds) *

Address Book *

Announcement *

API

Archive *

Attachment *

Authenticate

Blog *

Bookmark *

Briefcase *

Category *

Chart (Area) *

Chart (Bar) *

Chart (Pie) *

Collapse

Colour Palette *

Continue

Control Panel

Conversation *

Create

Dashboard *

Database *

Dictionary *

Document (Area Chart) *

Document (Bar Chart) *

Document (Blank) *

Document (Form) *

Document (Photo) *

Document (Pie Chart) *

Document (Secure) *

Document (Shred)

Documents (x2) *

Documents (x3) *

Download

Draw

Entry *

Excerpt *

Expand

Export

Fax *

File *

	- File (Closed)

	- File (Open)

Filter *

Flag *

Flag (Black) *

Flag (Blue) *

Flag (Brown) *

Flag (Green) *

Flag (Light Blue) *

Flag (Orange) *

Flag (Pink) *

Flag (Purple) *

Flag (Red) *

Flag (White) *

Flag (Yellow) *

Formatting

Hierarchy *

Import

Inbox *

Index *

List *

Log *

Map *

Mobile Phone *

Moderate

Module *

News *

Notes *

Notification *

Office *

Package *

Password

Phone *

	- Phone (Batphone) *

	- Phone (Office) *

Plugin *

Preview

Publish

Read More

Rebuild

Relationship (Data) *

Relationship (People) *

Rotate Left

Rotate Right

Schedule *

	- Schedule (Noun)

	- Schedule (Verb)

Script *

Security *

Sign In

Sign Out

Sort Down

Sort Up

Spam *

Statistics *

Status *

	- Status (Green)

	- Status (Off)

	- Status (On)

	- Status (Red)

	- Status (Yellow)

Support *

Sync

Template *

Ticket *

Time Zone *

Tools *

Trackback

View (Columns)

View (Lists)

View (Thumbnails)

Weather *

Write

This plugin provides support for scripting to gvSIG.

Among other things it contains:

- The gvSIG scripting engine

- The gvSIG script editor

- Script engines for:

   - Jython

   - Groovy

   - javascript

   - Renjin

- The script install module for the add-on manager.

- Utilities to generate packages of complements with our scripts.

- Python libraries as:

   - Six - Utilities for writing code that runs on Python 2 and 3

   - PyLint - Python source code analyzer

   - Pygments - syntax highlighting package

   - CSSUtils - CSS Cascading Style Sheets library

   - Docutils - Python Documentation Utilities

   - geopy - client for several popular geocoding web services

   - PyInliner - CSS-to-inline-styles conversion tool for HTML

   - Statistics - functions for calculating statistics of data

   - Cartodb - simple CartoDB client to perform requests against the CartoDB API

- Java libraries to use from scripting as:

   - Abeille forms deseigner

   - jOpenDocument

   - JNumeric

   - CSSBox

This plugin can be configured to be preinstalled automatically, allowing 

"Script" type plugins to be installed during the application installation process. 

To do this, the following entries must be added to the "packages.properties" 

of gvspks::

    installers=scripts

    installer.scripts.initializer=org.gvsig.scripting.app.extension.ScriptsInstallerInitializer

    installer.scripts.package.code=org.gvsig.scripting.app.mainplugin

    installer.scripts.factory.name=Script

    installer.scripts.libs=lib

If the "installers" entry already exists, add "scripts" to the end separating 

it with a space.

"""

geopy is a Python 2 and 3 client for several popular geocoding web services.

geopy makes it easy for Python developers to locate the coordinates of

addresses, cities, countries, and landmarks across the globe using third-party

geocoders and other data sources.

geopy is tested against CPython 2.7, CPython 3.2, CPython 3.4, PyPy, and PyPy3.

"""

from geopy.point import Point

from geopy.location import Location

from geopy.geocoders import * # pylint: disable=W0401

from geopy.util import __version__

"""

Exceptions raised by geopy.

"""

class GeopyError(Exception):

    """

    Geopy-specific exceptions are all inherited from GeopyError.

    """

class ConfigurationError(GeopyError):

    """

    When instantiating a geocoder, the arguments given were invalid. See

    the documentation of each geocoder's `__init__` for more details.

    """

class GeocoderServiceError(GeopyError):

    """

    There was an exception caused when calling the remote geocoding service,

    and no more specific exception could be raised by geopy. When calling

    geocoders' `geocode` or `reverse` methods, this is the most general

    exception that can be raised, and any non-geopy exception will be caught

    and turned into this. The exception's message will be that of the

    original exception.

    """

class GeocoderQueryError(GeocoderServiceError):

    """

    Either geopy detected input that would cause a request to fail,

    or a request was made and the remote geocoding service responded

    that the request was bad.

    """

class GeocoderQuotaExceeded(GeocoderServiceError):

    """

    The remote geocoding service refused to fulfill the request

    because the client has used its quota.

    """

class GeocoderAuthenticationFailure(GeocoderServiceError):

    """

    The remote geocoding service rejects the API key or account

    credentials this geocoder was instantiated with.

    """

class GeocoderInsufficientPrivileges(GeocoderServiceError):

    """

    The remote geocoding service refused to fulfill a request using the

    account credentials given.

    """

class GeocoderTimedOut(GeocoderServiceError):

    """

    The call to the geocoding service was aborted because no response

    was receiving within the `timeout` argument of either the geocoding class

    or, if specified, the method call. Some services are just consistently

    slow, and a higher timeout may be needed to use them.

    """

class GeocoderUnavailable(GeocoderServiceError):

    """

    Either it was not possible to establish a connection to the remote

    geocoding service, or the service responded with a code indicating

    it was unavailable.

    """

class GeocoderParseError(GeocoderServiceError):

    """

    Geopy could not parse the service's response. This is a bug in geopy.

    """

class GeocoderNotFound(GeopyError):

    """

    Caller requested the geocoder matching a string, e.g.,

    "google" > GoogleV3, but no geocoder could be found.

    """

"""

Convert units.

"""

import math

# Angles

def degrees(radians=0, arcminutes=0, arcseconds=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    deg = 0.

    if radians:

        deg = math.degrees(radians)

    if arcminutes:

        deg += arcminutes / arcmin(degrees=1.)

    if arcseconds:

        deg += arcseconds / arcsec(degrees=1.)

    return deg

def radians(degrees=0, arcminutes=0, arcseconds=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    if arcminutes:

        degrees += arcminutes / arcmin(degrees=1.)

    if arcseconds:

        degrees += arcseconds / arcsec(degrees=1.)

    return math.radians(degrees)

def arcminutes(degrees=0, radians=0, arcseconds=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    if radians:

        degrees += math.degrees(radians)

    if arcseconds:

        degrees += arcseconds / arcsec(degrees=1.)

    return degrees * 60.

def arcseconds(degrees=0, radians=0, arcminutes=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    if radians:

        degrees += math.degrees(radians)

    if arcminutes:

        degrees += arcminutes / arcmin(degrees=1.)

    return degrees * 3600.

# Lengths

def kilometers(meters=0, miles=0, feet=0, nautical=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    ret = 0.

    if meters:

        ret += meters / 1000.

    if feet:

        miles += feet / ft(1.)

    if nautical:

        ret += nautical / nm(1.)

    ret += miles * 1.609344

    return ret

def meters(kilometers=0, miles=0, feet=0, nautical=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    return (kilometers + km(nautical=nautical, miles=miles, feet=feet)) * 1000

def miles(kilometers=0, meters=0, feet=0, nautical=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    ret = 0.

    if nautical:

        kilometers += nautical / nm(1.)

    if feet:

        ret += feet / ft(1.)

    if meters:

        kilometers += meters / 1000.

    ret += kilometers / 1.609344

    return ret

def feet(kilometers=0, meters=0, miles=0, nautical=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    ret = 0.

    if nautical:

        kilometers += nautical / nm(1.)

    if meters:

        kilometers += meters / 1000.

    if kilometers:

        miles += mi(kilometers=kilometers)

    ret += miles * 5280

    return ret

def nautical(kilometers=0, meters=0, miles=0, feet=0): # pylint: disable=W0621

    """

    TODO docs.

    """

    ret = 0.

    if feet:

        miles += feet / ft(1.)

    if miles:

        kilometers += km(miles=miles)

    if meters:

        kilometers += meters / 1000.

    ret += kilometers / 1.852

    return ret

# Compatible names

rad = radians # pylint: disable=C0103

arcmin = arcminutes # pylint: disable=C0103

arcsec = arcseconds # pylint: disable=C0103

km = kilometers # pylint: disable=C0103

m = meters # pylint: disable=C0103

mi = miles # pylint: disable=C0103

ft = feet # pylint: disable=C0103

nm = nautical # pylint: disable=C0103

"""

Compatibility...

"""

import sys

py3k = sys.version_info >= (3, 0)

if py3k: # pragma: no cover

    string_compare = str

else: # pragma: no cover

    string_compare = (str, unicode)

# Unicode compatibility, borrowed from 'six'

if py3k: # pragma: no cover

    def u(s):

        """

        Convert to Unicode with py3k

        """

        return s

else: # pragma: no cover

    def u(s):

        """

        Convert to Unicode with unicode escaping

        """

        return unicode(s.replace(r'\\', r'\\\\'), 'unicode_escape')

if py3k: # pragma: no cover

    from urllib.parse import urlencode, quote # pylint: disable=W0611,F0401,W0611,E0611

    from urllib.request import (Request, urlopen, # pylint: disable=W0611,F0401,W0611,E0611

                                build_opener, ProxyHandler,

                                URLError, install_opener,

                                HTTPPasswordMgrWithDefaultRealm,

                                HTTPBasicAuthHandler)

    from urllib.error import HTTPError # pylint: disable=W0611,F0401,W0611,E0611

    def itervalues(d):

        """

        Function for iterating on values due to methods

        renaming between Python 2 and 3 versions

        For Python2

        """

        return iter(d.values())

    def iteritems(d):

        """

        Function for iterating on items due to methods

        renaming between Python 2 and 3 versions

        For Python2

        """

        return iter(d.items())

else: # pragma: no cover

    from urllib import urlencode as original_urlencode, quote # pylint: disable=W0611,F0401,W0611,E0611

    from urllib2 import (Request, HTTPError,   # pylint: disable=W0611,F0401,W0611,E0611

                         ProxyHandler, URLError, urlopen,

                         build_opener, install_opener,

                         HTTPPasswordMgrWithDefaultRealm,

                         HTTPBasicAuthHandler)

    def force_str(str_or_unicode):

        """

        Python2-only, ensures that a string is encoding to a str.

        """

        if isinstance(str_or_unicode, unicode):

            return str_or_unicode.encode('utf-8')

        else:

            return str_or_unicode

    def urlencode(query, doseq=0):

        """

        A version of Python's urllib.urlencode() function that can operate on

        unicode strings. The parameters are first cast to UTF-8 encoded strings

        and then encoded as per normal.

        Based on the urlencode from django.utils.http

        """

        if hasattr(query, 'items'):

            query = query.items()

        return original_urlencode(

            [(force_str(k),

              [force_str(i) for i in v]

              if isinstance(v, (list, tuple)) else force_str(v))

             for k, v in query],

            doseq)

    def itervalues(d):

        """

        Function for iterating on values due to methods

        renaming between Python 2 and 3 versions

        For Python3

        """

        return d.itervalues()

    def iteritems(d):

        """

        Function for iterating on items due to methods

        renaming between Python 2 and 3 versions

        For Python3

        """

        return d.iteritems()

"""

:class:`.Baidu` is the Baidu Maps geocoder.

"""

from geopy.compat import urlencode

from geopy.geocoders.base import Geocoder, DEFAULT_TIMEOUT

from geopy.exc import (

    GeocoderQueryError,

    GeocoderQuotaExceeded,

    GeocoderAuthenticationFailure,

)

from geopy.location import Location

from geopy.util import logger

__all__ = ("Baidu", )

class Baidu(Geocoder):

    """

    Geocoder using the Baidu Maps v2 API. Documentation at:

        http://developer.baidu.com/map/webservice-geocoding.htm

    """

    def __init__(

            self,

            api_key,

            scheme='http',

            timeout=DEFAULT_TIMEOUT,

            proxies=None,

            user_agent=None

        ):

        """

        Initialize a customized Baidu geocoder using the v2 API.

        .. versionadded:: 1.0.0

        :param string api_key: The API key required by Baidu Map to perform

            geocoding requests. API keys are managed through the Baidu APIs

            console (http://lbsyun.baidu.com/apiconsole/key).

        :param string scheme: Use 'https' or 'http' as the API URL's scheme.

            Default is http and only http support.

        :param dict proxies: If specified, routes this geocoder's requests

            through the specified proxy. E.g., {"https": "192.0.2.0"}. For

            more information, see documentation on

            :class:`urllib2.ProxyHandler`.

        """

        super(Baidu, self).__init__(

            scheme=scheme, timeout=timeout, proxies=proxies, user_agent=user_agent

        )

        self.api_key = api_key

        self.scheme = scheme

        self.doc = {}

        self.api = 'http://api.map.baidu.com/geocoder/v2/'

    @staticmethod

    def _format_components_param(components):

        """

        Format the components dict to something Baidu understands.

        """

        return "|".join(

            (":".join(item)

             for item in components.items()

            )

        )

    def geocode(

            self,

            query,

            exactly_one=True,

            timeout=None

        ):

        """

        Geocode a location query.

        :param string query: The address or query you wish to geocode.

        :param bool exactly_one: Return one result or a list of results, if

            available.

        :param int timeout: Time, in seconds, to wait for the geocoding service

            to respond before raising a :class:`geopy.exc.GeocoderTimedOut`

            exception. Set this only if you wish to override, on this call

            only, the value set during the geocoder's initialization.

        """

        params = {

            'ak': self.api_key,

            'output': 'json',

            'address': self.format_string % query,

        }

        url = "?".join((self.api, urlencode(params)))

        logger.debug("%s.geocode: %s", self.__class__.__name__, url)

        return self._parse_json(

            self._call_geocoder(url, timeout=timeout), exactly_one=exactly_one

        )

    def reverse(self, query, timeout=None):  # pylint: disable=W0221

        """

        Given a point, find an address.

        :param query: The coordinates for which you wish to obtain the

            closest human-readable addresses.

        :type query: :class:`geopy.point.Point`, list or tuple of (latitude,

            longitude), or string as "%(latitude)s, %(longitude)s"

        :param int timeout: Time, in seconds, to wait for the geocoding service

            to respond before raising a :class:`geopy.exc.GeocoderTimedOut`

            exception. Set this only if you wish to override, on this call

            only, the value set during the geocoder's initialization.

        """

        params = {

            'ak': self.api_key,

            'output': 'json',

            'location': self._coerce_point_to_string(query),

        }

        url = "?".join((self.api, urlencode(params)))

        logger.debug("%s.reverse: %s", self.__class__.__name__, url)

        return self._parse_reverse_json(

            self._call_geocoder(url, timeout=timeout)

        )

    @staticmethod

    def _parse_reverse_json(page):

        """

        Parses a location from a single-result reverse API call.

        """

        place = page.get('result')

        location = place.get('formatted_address').encode('utf-8')

        latitude = place['location']['lat']

        longitude = place['location']['lng']

        return Location(location, (latitude, longitude), place)

    def _parse_json(self, page, exactly_one=True):

        """

        Returns location, (latitude, longitude) from JSON feed.

        """

        place = page.get('result', None)

        if not place:

            self._check_status(page.get('status'))

            return None

        def parse_place(place):

            """

            Get the location, lat, lng from a single JSON place.

            """

            location = place.get('level')

            latitude = place['location']['lat']

            longitude = place['location']['lng']

            return Location(location, (latitude, longitude), place)

        if exactly_one:

            return parse_place(place)

        else:

            return [parse_place(item) for item in place]

    @staticmethod

    def _check_status(status):

        """

        Validates error statuses.

        """

        if status == '0':

            # When there are no results, just return.

            return

        if status == '1':

            raise GeocoderQueryError(

                'Internal server error.'

            )

        elif status == '2':

            raise GeocoderQueryError(

                'Invalid request.'

            )

        elif status == '3':

            raise GeocoderAuthenticationFailure(

                'Authentication failure.'

            )

        elif status == '4':

            raise GeocoderQuotaExceeded(

                'Quota validate failure.'

            )

        elif status == '5':

            raise GeocoderQueryError(

                'AK Illegal or Not Exist.'

            )

        elif status == '101':

            raise GeocoderQueryError(

                'Your request was denied.'

            )

        elif status == '102':

            raise GeocoderQueryError(

                'IP/SN/SCODE/REFERER Illegal:'

            )

        elif status == '2xx':

            raise GeocoderQueryError(

                'Has No Privilleges.'

            )

        elif status == '3xx':

            raise GeocoderQuotaExceeded(

                'Quota Error.'

            )

        else:

            raise GeocoderQueryError('Unknown error')

"""

:class:`.GoogleV3` is the Google Maps V3 geocoder.

"""

import base64

import hashlib

import hmac

from geopy.compat import urlencode

from geopy.geocoders.base import Geocoder, DEFAULT_TIMEOUT, DEFAULT_SCHEME

from geopy.exc import (

    GeocoderQueryError,

    GeocoderQuotaExceeded,

    ConfigurationError,

    GeocoderParseError,

    GeocoderQueryError,

)

from geopy.location import Location

from geopy.util import logger

try:

    from pytz import timezone, UnknownTimeZoneError

    from calendar import timegm

    from datetime import datetime

    from numbers import Number

    pytz_available = True

except ImportError:

    pytz_available = False

__all__ = ("GoogleV3", )

class GoogleV3(Geocoder):  # pylint: disable=R0902

    """

    Geocoder using the Google Maps v3 API. Documentation at:

        https://developers.google.com/maps/documentation/geocoding/

    """

    def __init__(

            self,

            api_key=None,

            domain='maps.googleapis.com',

            scheme=DEFAULT_SCHEME,

            client_id=None,

            secret_key=None,

            timeout=DEFAULT_TIMEOUT,

            proxies=None,

            user_agent=None,

        ):  # pylint: disable=R0913

        """

        Initialize a customized Google geocoder.

        API authentication is only required for Google Maps Premier customers.

        :param string api_key: The API key required by Google to perform

            geocoding requests. API keys are managed through the Google APIs

            console (https://code.google.com/apis/console).

            .. versionadded:: 0.98.2

        :param string domain: Should be the localized Google Maps domain to

            connect to. The default is 'maps.googleapis.com', but if you're

            geocoding address in the UK (for example), you may want to set it

            to 'maps.google.co.uk' to properly bias results.

        :param string scheme: Use 'https' or 'http' as the API URL's scheme.

            Default is https. Note that SSL connections' certificates are not

            verified.

            .. versionadded:: 0.97

        :param string client_id: If using premier, the account client id.

        :param string secret_key: If using premier, the account secret key.

        :param dict proxies: If specified, routes this geocoder's requests

            through the specified proxy. E.g., {"https": "192.0.2.0"}. For

            more information, see documentation on

            :class:`urllib2.ProxyHandler`.

            .. versionadded:: 0.96

        """

        super(GoogleV3, self).__init__(

            scheme=scheme, timeout=timeout, proxies=proxies, user_agent=user_agent

        )

        if client_id and not secret_key:

            raise ConfigurationError('Must provide secret_key with client_id.')

        if secret_key and not client_id:

            raise ConfigurationError('Must provide client_id with secret_key.')

        self.api_key = api_key

        self.domain = domain.strip('/')

        self.scheme = scheme

        self.doc = {}

        if client_id and secret_key:

            self.premier = True

            self.client_id = client_id

            self.secret_key = secret_key

        else:

            self.premier = False

            self.client_id = None

            self.secret_key = None

        self.api = '%s://%s/maps/api/geocode/json' % (self.scheme, self.domain)

        self.tz_api = '%s://%s/maps/api/timezone/json' % (

            self.scheme,

            self.domain

        )

    def _get_signed_url(self, params):

        """

        Returns a Premier account signed url. Docs on signature:

            https://developers.google.com/maps/documentation/business/webservices/auth#digital_signatures

        """

        params['client'] = self.client_id

        path = "?".join(('/maps/api/geocode/json', urlencode(params)))

        signature = hmac.new(

            base64.urlsafe_b64decode(self.secret_key),

            path.encode('utf-8'),

            hashlib.sha1

        )

        signature = base64.urlsafe_b64encode(

            signature.digest()

        ).decode('utf-8')

        return '%s://%s%s&signature=%s' % (

            self.scheme, self.domain, path, signature

        )

    @staticmethod

    def _format_components_param(components):

        """

        Format the components dict to something Google understands.

        """

        return "|".join(

            (":".join(item)

             for item in components.items()

            )

        )

    @staticmethod

    def _format_bounds_param(bounds):

      """

      Format the bounds to something Google understands.

      """

      return '%f,%f|%f,%f' % (bounds[0], bounds[1], bounds[2], bounds[3])

    def geocode(

            self,

            query,

            exactly_one=True,

            timeout=None,

            bounds=None,

            region=None,

            components=None,

            language=None,

            sensor=False,

        ):  # pylint: disable=W0221,R0913

        """

        Geocode a location query.

        :param string query: The address or query you wish to geocode.

        :param bool exactly_one: Return one result or a list of results, if

            available.

        :param int timeout: Time, in seconds, to wait for the geocoding service

            to respond before raising a :class:`geopy.exc.GeocoderTimedOut`

            exception. Set this only if you wish to override, on this call

            only, the value set during the geocoder's initialization.

            .. versionadded:: 0.97

        :param bounds: The bounding box of the viewport within which

            to bias geocode results more prominently.

        :type bounds: list or tuple

        :param string region: The region code, specified as a ccTLD

            ("top-level domain") two-character value.

        :param dict components: Restricts to an area. Can use any combination

            of: route, locality, administrative_area, postal_code, country.

            .. versionadded:: 0.97.1

        :param string language: The language in which to return results.

        :param bool sensor: Whether the geocoding request comes from a

            device with a location sensor.

        """

        params = {

            'address': self.format_string % query,

            'sensor': str(sensor).lower()

        }

        if self.api_key:

            params['key'] = self.api_key

        if bounds:

            if len(bounds) != 4:

                raise GeocoderQueryError(

                    "bounds must be a four-item iterable of lat,lon,lat,lon"

                )

            params['bounds'] = self._format_bounds_param(bounds)

        if region:

            params['region'] = region

        if components:

            params['components'] = self._format_components_param(components)

        if language:

            params['language'] = language

        if self.premier is False:

            url = "?".join((self.api, urlencode(params)))

        else:

            url = self._get_signed_url(params)

        logger.debug("%s.geocode: %s", self.__class__.__name__, url)

        return self._parse_json(

            self._call_geocoder(url, timeout=timeout), exactly_one

        )

    def reverse(

            self,

            query,

            exactly_one=False,

            timeout=None,

            language=None,

            sensor=False,

        ):  # pylint: disable=W0221,R0913

        """

        Given a point, find an address.

        :param query: The coordinates for which you wish to obtain the

            closest human-readable addresses.

        :type query: :class:`geopy.point.Point`, list or tuple of (latitude,

            longitude), or string as "%(latitude)s, %(longitude)s"

        :param boolean exactly_one: Return one result or a list of results, if

            available.

        :param int timeout: Time, in seconds, to wait for the geocoding service

            to respond before raising a :class:`geopy.exc.GeocoderTimedOut`

            exception.

            .. versionadded:: 0.97

        :param string language: The language in which to return results.

        :param boolean sensor: Whether the geocoding request comes from a

            device with a location sensor.

        """

        params = {

            'latlng': self._coerce_point_to_string(query),

            'sensor': str(sensor).lower()

        }

        if language:

            params['language'] = language

        if self.api_key:

            params['key'] = self.api_key

        if not self.premier:

            url = "?".join((self.api, urlencode(params)))

        else:

            url = self._get_signed_url(params)

        logger.debug("%s.reverse: %s", self.__class__.__name__, url)

        return self._parse_json(

            self._call_geocoder(url, timeout=timeout), exactly_one

        )

    def timezone(self, location, at_time=None, timeout=None):

        """

        **This is an unstable API.**

        Finds the timezone a `location` was in for a specified `at_time`,

        and returns a pytz timezone object.

            .. versionadded:: 1.2.0

        :param location: The coordinates for which you want a timezone.

        :type location: :class:`geopy.point.Point`, list or tuple of (latitude,

            longitude), or string as "%(latitude)s, %(longitude)s"

        :param at_time: The time at which you want the timezone of this

            location. This is optional, and defaults to the time that the

            function is called in UTC.

        :type at_time integer, long, float, datetime:

        :rtype: pytz timezone

        """

        if not pytz_available:

            raise ImportError(

                'pytz must be installed in order to locate timezones. '

                ' Install with `pip install geopy -e ".[timezone]"`.'

            )

        location = self._coerce_point_to_string(location)

        if isinstance(at_time, Number):

            timestamp = at_time

        elif isinstance(at_time, datetime):

            timestamp = timegm(at_time.utctimetuple())

        elif at_time is None:

            timestamp = timegm(datetime.utcnow().utctimetuple())

        else:

            raise GeocoderQueryError(

                "`at_time` must be an epoch integer or "

                "datetime.datetime object"

            )

        params = {

            "location": location,

            "timestamp": timestamp,

        }

        if self.api_key:

            params['key'] = self.api_key

        url = "?".join((self.tz_api, urlencode(params)))

        logger.debug("%s.timezone: %s", self.__class__.__name__, url)

        response = self._call_geocoder(url, timeout=timeout)

        try:

            tz = timezone(response["timeZoneId"])

        except UnknownTimeZoneError:

            raise GeocoderParseError(

                "pytz could not parse the timezone identifier (%s) "

                "returned by the service." % response["timeZoneId"]

            )

        except KeyError:

            raise GeocoderParseError(

                "geopy could not find a timezone in this response: %s" %

                response

            )

        return tz

    def _parse_json(self, page, exactly_one=True):

        '''Returns location, (latitude, longitude) from json feed.'''

        places = page.get('results', [])

        if not len(places):

            self._check_status(page.get('status'))

            return None

        def parse_place(place):

            '''Get the location, lat, lng from a single json place.'''

            location = place.get('formatted_address')

            latitude = place['geometry']['location']['lat']

            longitude = place['geometry']['location']['lng']

            return Location(location, (latitude, longitude), place)

        if exactly_one:

            return parse_place(places[0])