Python SDK API requests fail

[schluta]

Yesterday I was having a lot of trouble getting the SDK to work. I could get good responses from the following command, so I thought that I had a good access token, however, any requests using the SDK's UserApi, AccountApi, or EnvelopesApi all would fail.

ApiClient.get_user_info(access_token)

Today I decided to try executing curl commands myself, and the access tokens were working just fine. I have not investigated to the root of the issue, but if I do not use

    api_client.host = BASE_PATH

in the following:

    api_client = ApiClient()
    api_client.set_base_path(BASE_PATH)
    with open(PRIVATE_KEY_PATH, 'r') as key_file:
        private_key_bytes = key_file.read()
    scopes = ['signature', 'impersonation']
    response = api_client.request_jwt_user_token(
        client_id=INTEGRATOR_KEY,
        user_id=USER_ID,
        oauth_host_name=OAUTH_HOST_NAME,
        private_key_bytes=private_key_bytes,
        expires_in=3600,
        scopes=scopes
    )
    #
    access_token = response.access_token
    api_client.host = BASE_PATH

Then all of my requests fail. I am not too sure what the difference between host and base_path are supposed to be. I am not sure what the config.host refers to. Interestingly, the only time the self.host member is used is when the call_api function is called.
The relevant sections are below:

    def __init__(self, host=None, header_name=None, header_value=None, cookie=None, oauth_host_name=None, base_path=None):
        """
        Constructor of the class.
        """

        config = Configuration()
        self.rest_client = RESTClientObject(configuration=config)
        self.default_headers = {'X-DocuSign-SDK': 'Python'}
        if header_name is not None:
            self.default_headers[header_name] = header_value
        if host is None:
            self.host = config.host
        elif host == "":
            raise ArgumentException("basePath cannot be empty")
        else:
            self.host = host

def __call_api(self, resource_path, method,
                   path_params=None, query_params=None, header_params=None,
                   body=None, post_params=None, files=None,
                   response_type=None, auth_settings=None, callback=None,
                   _return_http_data_only=None, collection_formats=None, _preload_content=True,
                   _request_timeout=None):
        """
        :param _preload_content: if False, the urllib3.HTTPResponse object will be returned without
                                 reading/decoding response data. Default is True. 
        :return: 
        """

        # header parameters
        header_params = header_params or {}
        header_params.update(self.default_headers)
        if self.cookie:
            header_params['Cookie'] = self.cookie
        if header_params:
            header_params = self.sanitize_for_serialization(header_params)
            header_params = dict(self.parameters_to_tuples(header_params,
                                                           collection_formats))

        # path parameters
        if path_params:
            path_params = self.sanitize_for_serialization(path_params)
            path_params = self.parameters_to_tuples(path_params,
                                                    collection_formats)
            for k, v in path_params:
                resource_path = resource_path.replace(
                    '{%s}' % k, quote(str(v), safe=""))

        # query parameters
        if query_params:
            query_params = self.sanitize_for_serialization(query_params)
            query_params = self.parameters_to_tuples(query_params,
                                                     collection_formats)

        # post parameters
        if post_params or files:
            post_params = self.prepare_post_parameters(post_params, files)
            post_params = self.sanitize_for_serialization(post_params)
            post_params = self.parameters_to_tuples(post_params,
                                                    collection_formats)

        # auth setting
        self.update_params_for_auth(header_params, query_params, auth_settings)

        # body
        if body:
            body = self.sanitize_for_serialization(body)

        # request url
        url = self.host + resource_path

I am not really sure how anyone is really using this SDK. To me this looks like a bug or oversight where the base_path should be used. Some debug functions or prints would be awesome.

I accidentally stumbled upon this "fix" at this link in the Instantiating and configuring the ApiClient for making API calls section.

[GuilhermeFloresDocuSign]

Hi there!

Both api_client.host and api_client.set_base_path(BASE_PATH) are used to set the root URL for the API calls, but they work a bit differently:

• api_client.host is a property where you directly set the base URL (like https://demo.docusign.net/restapi for the demo environment). This tells the SDK where to send your API requests.
• api_client.set_base_path(BASE_PATH) is a method you can use to update the base path after you’ve already created the ApiClient object.

We often see users filling both options properties, but ".host" should be the property that will point to the Base URL the API will use, and it is the one suggested at https://developers.docusign.com/docs/esign-rest-api/sdks/python/auth/

[schluta]

Is there a use case for having these not be set to the same thing that I'm not seeing? Why are there two parameters?

If the host parameter is not updated after I get the JWT token, none of the API calls work.

Even if I instantiate an ApiClient and then set the base path it doesn't work unless I set the host. I really don't understand the point.

[GuilhermeFloresDocuSign]

Hi @schluta .

I checked the jwt_helper in GitHub.

The api_client.set_base_path(auth_server) references the auth_server, which would be the "account-d.docusign.com" URL (demonstration server). This is the authentication endpoint.

The api_client.host = base_path refers to the base_path, which is the Base URL found on the Apps and Keys page. This URL is used for targeting the eSignature API calls.

Although they have similar names, if you check the jwt_helper link, they work differently. They are used in different functions. We agree that it is a bit confusing, and an enhancement to the naming convention would be helpful.

You will need to use api_client.host to set the Base URL to API calls, while "set_base_path" is often used in authentication methods (generate token, etc).

[schluta]

I am not sure what the base_path variable is really doing then, because it works in my code above set to the base path. This section below also seems to assume the opposite (and is the only place I can see base path even being used; which is to infer the oath_host)

   def set_oauth_host_name(self, oauth_host_name=None):
        """
        :param oauth_host_name:
        :return:
        """
        if oauth_host_name:
            self.oauth_host_name = oauth_host_name
            return

        # Derive OAuth Base Path if not given
        if self.base_path is None or self.base_path.startswith("https://demo") or self.base_path.startswith("http://demo") or self.base_path.startswith("https://apps-d") or self.base_path.startswith("http://apps-d"):
            self.oauth_host_name = OAuth.DEMO_OAUTH_BASE_PATH
        else:
            self.oauth_host_name = OAuth.PRODUCTION_OAUTH_BASE_PATH

It would also be great to have a method to set the host path instead of just accessing the parameter directly.
I am not sure why you would have two methods for setting the oauth endpoint?
I haven't really seen anyone setting the host in the ApiClient initialization even though it could be.
It might be worthwhile to make this a required parameter instead of an optional one.

In any case a name change and some commenting might be helpful. Debugging this took quite some time since there is not any debugging functionality to this SDK. I kept getting an authorization error, which had me suspecting problems with the token, API key, etc.

[GuilhermeFloresDocuSign]

Authentication will always use the "account" addresses, while Endpoints will use what is in your Apps and keys page.

Our https://developers.docusign.com/platform/api-endpoint-base-paths/ shows all the URLs that you will need to use to make API calls.

The "host" variable should be "https://demo.docusign.net/restapi" and "set_base_path" should stick to "account-d.docusign.com".

We recommend using the above suggestions. About the name change, we will need to raise an enhancement request to our team responsible for developing the SDK.

[schluta]

Why does this line imply otherwise?

if self.base_path is None or self.base_path.startswith("https://demo") or self.base_path.startswith("http://demo") or self.base_path.startswith("https://apps-d") or self.base_path.startswith("http://apps-d"):

[GuilhermeFloresDocuSign]

Hi there!

So, there’s a mechanism in place where, if you set the base_path to either "demo" or "prod", the system will automatically adjust the route to call the appropriate token endpoint. However, it’s important to note that this logic only comes into play if the client uses the set_oauth_host_name method. If that method isn’t called, the validation simply doesn’t happen.

Additionally, the set_base_path method is only really meaningful if ACG is being implemented. In cases where the client uses request_jwt_user_token, the third parameter in that method already determines which server will be used, so the host parameter continues to serve as the base URL for the request.

Just to clarify regarding base_path: even though it might not be actively used, it will still be assigned the default production base URL as defined in configuration.py, rather than the authentication base path.

We’ll make sure to raise this matter with our team responsible for the Python SDK to ensure it’s properly addressed.