def __init__(self, service, environment=config.get_default_environ(),
base_path=None, token=None, app_name=None):
self.environment = environment
self.base_url = config.get_service_url(environment, service)
if base_path is not None:
self.base_url = slash_join(self.base_url, base_path)
# setup the basics for wrapping a Requests Session
# including basics for internal header dict
self._session = requests.Session()
self._headers = {
'Accept': 'application/json',
'User-Agent': self.BASE_USER_AGENT
}
# load a token for the client's service if it is not given as a param
# assign the result
if not token:
token = self.config_load_token()
self.set_token(token)
# verify SSL? Usually true
self._verify = config.get_ssl_verify(environment)
# set application name if given
self.app_name = None
if app_name is not None:
self.set_app_name(app_name)
def __init__(self, service, environment=config.get_default_environ(), base_path=None, token=None, app_name=None):
self.environment = environment
self.base_url = config.get_service_url(environment, service)
if base_path is not None:
self.base_url = slash_join(self.base_url, base_path)
# setup the basics for wrapping a Requests Session
# including basics for internal header dict
self._session = requests.Session()
self._headers = {"Accept": "application/json", "User-Agent": self.BASE_USER_AGENT}
# load a token for the client's service if it is not given as a param
# assign the result
if not token:
token = self.config_load_token()
self.set_token(token)
# verify SSL? Usually true
self._verify = config.get_ssl_verify(environment)
# set application name if given
self.app_name = None
if app_name is not None:
self.set_app_name(app_name)
def __init__(self,
environment=config.get_default_environ(),
token=None,
app_name=None):
BaseClient.__init__(self,
"auth",
environment,
token=token,
app_name=app_name)
def __init__(self,
environment=config.get_default_environ(),
token=None,
app_name=None):
BaseClient.__init__(self,
"transfer",
environment,
"/v0.10/",
token=token,
app_name=None)
def __init__(self, service, environment=None,
base_path=None, authorizer=None, app_name=None):
# get the fully qualified name of the client class, so that it's a
# child of globus_sdk
self.logger = ClientLogAdapter(
logging.getLogger(self.__module__ + '.' + self.__class__.__name__),
{'client': self})
self.logger.info('Creating client of type {} for service "{}"'
.format(type(self), service))
# if restrictions have been placed by a child class on the allowed
# authorizer types, make sure we are not in violation of those
# constraints
if self.allowed_authorizer_types is not None and (
authorizer is not None and
type(authorizer) not in self.allowed_authorizer_types):
self.logger.error("{} doesn't support authorizer={}"
.format(type(self), type(authorizer)))
raise ValueError(
("{0} can only take authorizers from {1}, "
"but you have provided {2}").format(
type(self), self.allowed_authorizer_types,
type(authorizer)))
# defer this default until instantiation time so that logging can
# capture the execution of the config load
if environment is None:
environment = config.get_default_environ()
self.environment = environment
self.authorizer = authorizer
self.base_url = config.get_service_url(environment, service)
if base_path is not None:
self.base_url = slash_join(self.base_url, base_path)
# setup the basics for wrapping a Requests Session
# including basics for internal header dict
self._session = requests.Session()
self._headers = {
'Accept': 'application/json',
'User-Agent': self.BASE_USER_AGENT
}
# verify SSL? Usually true
self._verify = config.get_ssl_verify(environment)
# set application name if given
self.app_name = None
if app_name is not None:
self.set_app_name(app_name)
def __init__(self, authorizer=None, **kwargs):
if authorizer is None:
# TODO: remove; this is a temporary backwards compatibility hack
access_token = config.get_transfer_token(
kwargs.get('environment', config.get_default_environ()))
if access_token is not None:
logger.warn(('Using deprecated config token. '
'Switch to use of AccessTokenAuthorizer'))
authorizer = AccessTokenAuthorizer(access_token)
BaseClient.__init__(self,
"transfer",
base_path="/v0.10/",
authorizer=authorizer,
**kwargs)
def __init__(self, client_id=None, authorizer=None, **kwargs):
self.client_id = client_id
# an AuthClient may contain a GlobusOAuth2FlowManager in order to
# encapsulate the functionality of various different types of flow
# managers
self.current_oauth2_flow_manager = None
if authorizer is None:
# TODO: remove; this is a temporary backwards compatibility hack
access_token = config.get_auth_token(
kwargs.get('environment', config.get_default_environ()))
if access_token is not None:
logger.warn(('Using deprecated config token. '
'Switch to use of AccessTokenAuthorizer'))
authorizer = AccessTokenAuthorizer(access_token)
BaseClient.__init__(self, "auth", authorizer=authorizer, **kwargs)
def __init__(self, service, environment=config.get_default_environ(),
base_path=None):
self.environment = environment
self.base_url = config.get_service_url(environment, service)
if base_path is not None:
self.base_url = slash_join(self.base_url, base_path)
self._session = requests.Session()
self._headers = dict(Accept="application/json")
self._auth = None
# potentially add an Authorization header, if a token is specified
auth_token = config.get_auth_token(environment)
if auth_token:
warnings.warn(
('Providing raw Auth Tokens is not recommended, and is slated '
'for deprecation. If you use this feature, be ready to '
'transition to using a new authentication mechanism after we '
'announce its availability.'),
PendingDeprecationWarning)
self.set_auth_token(auth_token)
self._verify = config.get_ssl_verify(environment)
def __init__(self,
service,
environment=None,
base_url=None,
base_path=None,
authorizer=None,
app_name=None,
http_timeout=None,
*args,
**kwargs):
self._init_logger_adapter()
self.logger.info('Creating client of type {} for service "{}"'.format(
type(self), service))
# if restrictions have been placed by a child class on the allowed
# authorizer types, make sure we are not in violation of those
# constraints
if self.allowed_authorizer_types is not None and (
authorizer is not None
and type(authorizer) not in self.allowed_authorizer_types):
self.logger.error("{} doesn't support authorizer={}".format(
type(self), type(authorizer)))
raise exc.GlobusSDKUsageError(
("{0} can only take authorizers from {1}, "
"but you have provided {2}").format(
type(self), self.allowed_authorizer_types,
type(authorizer)))
# defer this default until instantiation time so that logging can
# capture the execution of the config load
if environment is None:
environment = config.get_default_environ()
self.environment = environment
self.authorizer = authorizer
if base_url is None:
self.base_url = config.get_service_url(environment, service)
else:
self.base_url = base_url
if base_path is not None:
self.base_url = slash_join(self.base_url, base_path)
# setup the basics for wrapping a Requests Session
# including basics for internal header dict
self._session = requests.Session()
self._headers = {
'Accept': 'application/json',
'User-Agent': self.BASE_USER_AGENT
}
# verify SSL? Usually true
self._verify = config.get_ssl_verify(environment)
# HTTP connection timeout
# this is passed verbatim to `requests`, and we therefore technically
# support a tuple for connect/read timeouts, but we don't need to
# advertise that... Just declare it as an float value
if http_timeout is None:
http_timeout = config.get_http_timeout(environment)
self._http_timeout = http_timeout
# handle -1 by passing None to requests
if self._http_timeout == -1:
self._http_timeout = None
# set application name if given
self.app_name = None
if app_name is not None:
self.set_app_name(app_name)
def __init__(self, environment=config.get_default_environ()):
BaseClient.__init__(self, "auth", environment)
def __init__(self, environment=config.get_default_environ(),
token=None, app_name=None):
BaseClient.__init__(self, "transfer", environment, "/v0.10/",
token=token, app_name=None)
def __init__(self, environment=config.get_default_environ()):
BaseClient.__init__(self, "nexus", environment)
# warn that this class is deprecated upon initialization
warnings.warn(self._DEPRECATION_TEXT, PendingDeprecationWarning)
def __init__(self, environment=config.get_default_environ(), token=None, app_name=None):
BaseClient.__init__(self, "auth", environment, token=token, app_name=app_name)