################################################## 
# CommonService_services.py 
# generated by ZSI.generate.wsdl2python
##################################################


from CommonService_services_types import *
import urlparse, types
from ZSI.TCcompound import ComplexType, Struct
from ZSI import client
import ZSI

# Locator
class CommonServiceLocator:
    CommonServiceSoap_address = "http://findv3.staging.mappoint.net/Find-30/Common.asmx"
    def getCommonServiceSoapAddress(self):
        return CommonServiceLocator.CommonServiceSoap_address
    def getCommonServiceSoap(self, url=None, **kw):
        return CommonServiceSoapSOAP(url or CommonServiceLocator.CommonServiceSoap_address, **kw)

# Methods
class CommonServiceSoapSOAP:
    def __init__(self, url, **kw):
        kw.setdefault("readerclass", None)
        kw.setdefault("writerclass", None)
        # no resource properties
        self.binding = client.Binding(url=url, **kw)
        # no ws-addressing

    # op: GetVersionInfo
    def GetVersionInfo(self, request):
        if isinstance(request, GetVersionInfoSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetVersionInfo", **kw)
        # no output wsaction
        response = self.binding.Receive(GetVersionInfoSoapOut.typecode)
        if isinstance(response, GetVersionInfoSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: GetCountryRegionInfo
    def GetCountryRegionInfo(self, request):
        if isinstance(request, GetCountryRegionInfoSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetCountryRegionInfo", **kw)
        # no output wsaction
        response = self.binding.Receive(GetCountryRegionInfoSoapOut.typecode)
        if isinstance(response, GetCountryRegionInfoSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: GetEntityTypes
    def GetEntityTypes(self, request):
        if isinstance(request, GetEntityTypesSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetEntityTypes", **kw)
        # no output wsaction
        response = self.binding.Receive(GetEntityTypesSoapOut.typecode)
        if isinstance(response, GetEntityTypesSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: GetDataSourceInfo
    def GetDataSourceInfo(self, request):
        if isinstance(request, GetDataSourceInfoSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetDataSourceInfo", **kw)
        # no output wsaction
        response = self.binding.Receive(GetDataSourceInfoSoapOut.typecode)
        if isinstance(response, GetDataSourceInfoSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: GetGreatCircleDistances
    def GetGreatCircleDistances(self, request):
        if isinstance(request, GetGreatCircleDistancesSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetGreatCircleDistances", **kw)
        # no output wsaction
        response = self.binding.Receive(GetGreatCircleDistancesSoapOut.typecode)
        if isinstance(response, GetGreatCircleDistancesSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

GetVersionInfoSoapIn = ns3.GetVersionInfo_Dec().pyclass

GetVersionInfoSoapOut = ns3.GetVersionInfoResponse_Dec().pyclass

GetCountryRegionInfoSoapIn = ns3.GetCountryRegionInfo_Dec().pyclass

GetCountryRegionInfoSoapOut = ns3.GetCountryRegionInfoResponse_Dec().pyclass

GetEntityTypesSoapIn = ns3.GetEntityTypes_Dec().pyclass

GetEntityTypesSoapOut = ns3.GetEntityTypesResponse_Dec().pyclass

GetDataSourceInfoSoapIn = ns3.GetDataSourceInfo_Dec().pyclass

GetDataSourceInfoSoapOut = ns3.GetDataSourceInfoResponse_Dec().pyclass

GetGreatCircleDistancesSoapIn = ns3.GetGreatCircleDistances_Dec().pyclass

GetGreatCircleDistancesSoapOut = ns3.GetGreatCircleDistancesResponse_Dec().pyclass

from CommonService_services_types import *
import urlparse, types
from ZSI.TCcompound import ComplexType, Struct
from ZSI import client
import ZSI

# Locator
class FindServiceLocator:
    FindServiceSoap_address = "http://findv3.staging.mappoint.net/Find-30/FindService.asmx"
    def getFindServiceSoapAddress(self):
        return FindServiceLocator.FindServiceSoap_address
    def getFindServiceSoap(self, url=None, **kw):
        return FindServiceSoapSOAP(url or FindServiceLocator.FindServiceSoap_address, **kw)

# Methods
class FindServiceSoapSOAP:
    def __init__(self, url, **kw):
        kw.setdefault("readerclass", None)
        kw.setdefault("writerclass", None)
        # no resource properties
        self.binding = client.Binding(url=url, **kw)
        # no ws-addressing

    # op: Find
    def Find(self, request):
        if isinstance(request, FindSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/Find", **kw)
        # no output wsaction
        response = self.binding.Receive(FindSoapOut.typecode)
        if isinstance(response, FindSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: FindAddress
    def FindAddress(self, request):
        if isinstance(request, FindAddressSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/FindAddress", **kw)
        # no output wsaction
        response = self.binding.Receive(FindAddressSoapOut.typecode)
        if isinstance(response, FindAddressSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: ParseAddress
    def ParseAddress(self, request):
        if isinstance(request, ParseAddressSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/ParseAddress", **kw)
        # no output wsaction
        response = self.binding.Receive(ParseAddressSoapOut.typecode)
        if isinstance(response, ParseAddressSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: GetLocationInfo
    def GetLocationInfo(self, request):
        if isinstance(request, GetLocationInfoSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetLocationInfo", **kw)
        # no output wsaction
        response = self.binding.Receive(GetLocationInfoSoapOut.typecode)
        if isinstance(response, GetLocationInfoSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: FindNearby
    def FindNearby(self, request):
        if isinstance(request, FindNearbySoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/FindNearby", **kw)
        # no output wsaction
        response = self.binding.Receive(FindNearbySoapOut.typecode)
        if isinstance(response, FindNearbySoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: FindByProperty
    def FindByProperty(self, request):
        if isinstance(request, FindByPropertySoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/FindByProperty", **kw)
        # no output wsaction
        response = self.binding.Receive(FindByPropertySoapOut.typecode)
        if isinstance(response, FindByPropertySoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: FindByID
    def FindByID(self, request):
        if isinstance(request, FindByIDSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/FindByID", **kw)
        # no output wsaction
        response = self.binding.Receive(FindByIDSoapOut.typecode)
        if isinstance(response, FindByIDSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: FindNearRoute
    def FindNearRoute(self, request):
        if isinstance(request, FindNearRouteSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/FindNearRoute", **kw)
        # no output wsaction
        response = self.binding.Receive(FindNearRouteSoapOut.typecode)
        if isinstance(response, FindNearRouteSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: FindPolygon
    def FindPolygon(self, request):
        if isinstance(request, FindPolygonSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/FindPolygon", **kw)
        # no output wsaction
        response = self.binding.Receive(FindPolygonSoapOut.typecode)
        if isinstance(response, FindPolygonSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

FindSoapIn = ns3.Find_Dec().pyclass

FindSoapOut = ns3.FindResponse_Dec().pyclass

FindAddressSoapIn = ns3.FindAddress_Dec().pyclass

FindAddressSoapOut = ns3.FindAddressResponse_Dec().pyclass

ParseAddressSoapIn = ns3.ParseAddress_Dec().pyclass

ParseAddressSoapOut = ns3.ParseAddressResponse_Dec().pyclass

GetLocationInfoSoapIn = ns3.GetLocationInfo_Dec().pyclass

GetLocationInfoSoapOut = ns3.GetLocationInfoResponse_Dec().pyclass

FindNearbySoapIn = ns3.FindNearby_Dec().pyclass

FindNearbySoapOut = ns3.FindNearbyResponse_Dec().pyclass

FindByPropertySoapIn = ns3.FindByProperty_Dec().pyclass

FindByPropertySoapOut = ns3.FindByPropertyResponse_Dec().pyclass

FindByIDSoapIn = ns3.FindByID_Dec().pyclass

FindByIDSoapOut = ns3.FindByIDResponse_Dec().pyclass

FindNearRouteSoapIn = ns3.FindNearRoute_Dec().pyclass

FindNearRouteSoapOut = ns3.FindNearRouteResponse_Dec().pyclass

FindPolygonSoapIn = ns3.FindPolygon_Dec().pyclass

FindPolygonSoapOut = ns3.FindPolygonResponse_Dec().pyclass

from CommonService_services_types import *
import urlparse, types
from ZSI.TCcompound import ComplexType, Struct
from ZSI import client
import ZSI

# Locator
class RouteServiceLocator:
    RouteServiceSoap_address = "http://routev3.staging.mappoint.net/Route-30/RouteService.asmx"
    def getRouteServiceSoapAddress(self):
        return RouteServiceLocator.RouteServiceSoap_address
    def getRouteServiceSoap(self, url=None, **kw):
        return RouteServiceSoapSOAP(url or RouteServiceLocator.RouteServiceSoap_address, **kw)

# Methods
class RouteServiceSoapSOAP:
    def __init__(self, url, **kw):
        kw.setdefault("readerclass", None)
        kw.setdefault("writerclass", None)
        # no resource properties
        self.binding = client.Binding(url=url, **kw)
        # no ws-addressing

    # op: CalculateSimpleRoute
    def CalculateSimpleRoute(self, request):
        if isinstance(request, CalculateSimpleRouteSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/CalculateSimpleRoute", **kw)
        # no output wsaction
        response = self.binding.Receive(CalculateSimpleRouteSoapOut.typecode)
        if isinstance(response, CalculateSimpleRouteSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: CalculateRoute
    def CalculateRoute(self, request):
        if isinstance(request, CalculateRouteSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/CalculateRoute", **kw)
        # no output wsaction
        response = self.binding.Receive(CalculateRouteSoapOut.typecode)
        if isinstance(response, CalculateRouteSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

CalculateSimpleRouteSoapIn = ns3.CalculateSimpleRoute_Dec().pyclass

CalculateSimpleRouteSoapOut = ns3.CalculateSimpleRouteResponse_Dec().pyclass

CalculateRouteSoapIn = ns3.CalculateRoute_Dec().pyclass

CalculateRouteSoapOut = ns3.CalculateRouteResponse_Dec().pyclass

from CommonService_services_types import *
import urlparse, types
from ZSI.TCcompound import ComplexType, Struct
from ZSI import client
import ZSI

# Locator
class RenderServiceLocator:
    RenderServiceSoap_address = "http://renderv3.staging.mappoint.net/Render-30/RenderService.asmx"
    def getRenderServiceSoapAddress(self):
        return RenderServiceLocator.RenderServiceSoap_address
    def getRenderServiceSoap(self, url=None, **kw):
        return RenderServiceSoapSOAP(url or RenderServiceLocator.RenderServiceSoap_address, **kw)

# Methods
class RenderServiceSoapSOAP:
    def __init__(self, url, **kw):
        kw.setdefault("readerclass", None)
        kw.setdefault("writerclass", None)
        # no resource properties
        self.binding = client.Binding(url=url, **kw)
        # no ws-addressing

    # op: GetMap
    def GetMap(self, request):
        if isinstance(request, GetMapSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetMap", **kw)
        # no output wsaction
        response = self.binding.Receive(GetMapSoapOut.typecode)
        if isinstance(response, GetMapSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: ConvertToPoint
    def ConvertToPoint(self, request):
        if isinstance(request, ConvertToPointSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/ConvertToPoint", **kw)
        # no output wsaction
        response = self.binding.Receive(ConvertToPointSoapOut.typecode)
        if isinstance(response, ConvertToPointSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: ConvertToLatLong
    def ConvertToLatLong(self, request):
        if isinstance(request, ConvertToLatLongSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/ConvertToLatLong", **kw)
        # no output wsaction
        response = self.binding.Receive(ConvertToLatLongSoapOut.typecode)
        if isinstance(response, ConvertToLatLongSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: GetBestMapView
    def GetBestMapView(self, request):
        if isinstance(request, GetBestMapViewSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetBestMapView", **kw)
        # no output wsaction
        response = self.binding.Receive(GetBestMapViewSoapOut.typecode)
        if isinstance(response, GetBestMapViewSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

    # op: GetLineDriveMap
    def GetLineDriveMap(self, request):
        if isinstance(request, GetLineDriveMapSoapIn) is False:
            raise TypeError, "%s incorrect request type" % (request.__class__)
        kw = {}
        # no input wsaction
        self.binding.Send(None, None, request, soapaction="http://s.mappoint.net/mappoint-30/GetLineDriveMap", **kw)
        # no output wsaction
        response = self.binding.Receive(GetLineDriveMapSoapOut.typecode)
        if isinstance(response, GetLineDriveMapSoapOut.typecode.pyclass) is False:
            raise TypeError, "%s incorrect response type" % (response.__class__)
        return response

GetMapSoapIn = ns3.GetMap_Dec().pyclass

GetMapSoapOut = ns3.GetMapResponse_Dec().pyclass

ConvertToPointSoapIn = ns3.ConvertToPoint_Dec().pyclass

ConvertToPointSoapOut = ns3.ConvertToPointResponse_Dec().pyclass

ConvertToLatLongSoapIn = ns3.ConvertToLatLong_Dec().pyclass

ConvertToLatLongSoapOut = ns3.ConvertToLatLongResponse_Dec().pyclass

GetBestMapViewSoapIn = ns3.GetBestMapView_Dec().pyclass

GetBestMapViewSoapOut = ns3.GetBestMapViewResponse_Dec().pyclass

GetLineDriveMapSoapIn = ns3.GetLineDriveMap_Dec().pyclass

GetLineDriveMapSoapOut = ns3.GetLineDriveMapResponse_Dec().pyclass
