CODEWITHSUNDEEP
pythonparametersargskeyword-argument
BBedit
BBedit

Reputation: 8047

What is the best way to force a keyword while using **kwargs?

I'm not sure if I have used the correct terminology in the question.

Currently, I am trying to make a wrapper/interface around Google's Blogger API (Blog service). [I know it has been done already, but I am using this as a project to learn OOP/python.]

I have made a method that gets a set of 25 posts from a blog:

def get_posts(self, **kwargs):
    """ Makes an API request. Returns list of posts. """

    api_url = '/blogs/{id}/posts'.format(id=self.id)
    return self._send_request(api_url, kwargs)

def _send_request(self, url, parameters={}):
    """ Sends an HTTP GET request to the Blogger API.
        Returns JSON decoded response as a dict. """

    url = '{base}{url}?'.format(base=self.base, url=url)

# Requests formats the parameters into the URL for me
    try:
        r = requests.get(url, params=parameters)
    except:
        print "** Could not reach url:\n", url
        return
    api_response = r.text
    return self._jload(api_response)

The problem is, I have to specify the API key every time I call the get_posts function:

someblog = BloggerClient(url='http://someblog.blogger.com', key='0123')
someblog.get_posts(key=self.key)

Every API call requires that the key be sent as a parameter on the URL. Then, what is the best way to do that?

I'm thinking a possible way (but probably not the best way?), is to add the key to the kwargs dictionary in the _send_request():

def _send_request(self, url, parameters={}):
    """ Sends an HTTP get request to Blogger API.
        Returns JSON decoded response. """
# Format the full API URL:
    url = '{base}{url}?'.format(base=self.base, url=url)

# The api key will be always be added:
    parameters['key']= self.key
    try:
        r = requests.get(url, params=parameters)
    except:
        print "** Could not reach url:\n", url
        return
    api_response = r.text
    return self._jload(api_response)

I can't really get my head around what is the best way (or most pythonic way) to do it.

Upvotes: 0

Views: 186

Answers (2)

misterE
misterE

Reputation: 21

You could store it in a named constant.

If this code doesn't need to be secure, simply

API_KEY = '1ih3f2ihf2f'

If it's going to be hosted on a server somewhere or needs to be more secure, you could store the value in an environment variable

In your terminal:

export API_KEY='1ih3f2ihf2f'

then in your python script:

import os
API_KEY = os.environ.get('API_KEY')

Upvotes: 1

abarnert
abarnert

Reputation: 365717

The problem is, I have to specify the API key every time I call the get_posts function:

If it really is just this one method, the obvious idea is to write a wrapper:

def get_posts(blog, *args, **kwargs):
    returns blog.get_posts(*args, key=key, **kwargs)

Or, better, wrap up the class to do it for you:

class KeyRememberingBloggerClient(BloggerClient):
    def __init__(self, *args, **kwargs):
        self.key = kwargs.pop('key')
        super(KeyRememberingBloggerClient, self).__init__(*args, **kwargs)
    def get_posts(self, *args, **kwargs):
        return super(KeyRememberingBloggerClient, self).get_posts(
            *args, key=self.key, **kwargs)

So now:

someblog = KeyRememberingBloggerClient(url='http://someblog.blogger.com', key='0123')
someblog.get_posts()

Yes, you can override or monkeypatch the _send_request method that all of the other methods use, but if there's only 1 or 2 methods that need to be fixed, why delve into the undocumented internals of the class, and fork the body of one of those methods just so you can change it in a way you clearly weren't expected to, instead of doing it cleanly?

Of course if there are 90 different methods scattered across 4 different classes, you might want to consider building these wrappers programmatically (and/or monkeypatching the classes)… or just patching the one private method, as you're doing. That seems reasonable.

Upvotes: 0

Related Questions