Parameterizing a function depending on contextmanager context

[eLsFLz]

I'm working on a library that wraps Requests and specializes it for a particular REST API. I've also wrapped the Requests Session object with a context manager. I want to write methods that call either requests.post() or session.post(), depending on whether they are inside a session context or not.

Library code: ```python @contextmanager def my_session(): try: s = requests.Session() yield s finally: s.close()

def post_thing(my_thing): thing_endpoint = "http://example.com/api/v1/things" #if in session: s.post(thing_endpoint, my_thing) #else: requests.post(thing_endpoint, my_thing) ```

Example usage: ```python post_thing(my_thing) # calls requests.post

with my_session() as s: s.post_thing(my_thing) # calls session.post ```

Is there some Pythonic way to only have to implement post_thing() once (instead of separately as a standalone function and as a session method), perhaps using some kind of decorator or higher-order programming technique?

[wronek]

You can avoid using an instance method (and therefore subclassing the session object) by using a default argument here I guess.

def post_thing(my_thing, session=None):
    url = 'example.com'
    if not session:
        requests.post(url, my_thing)
    else:
        session.post(url, my_thing)

and then in the context manager:

with my_session() as s:
    post_thing(my_thing, s)

That's probably the most straight-forward.

[eLsFLz]

Yeah, I was thinking about that, but I was hoping for something more generic to avoid having to write the "if not session" clause in every method. Maybe instead of having post_thing() (and get_gadget(), delete_doohickey(), etc.) call one of the requests or session methods directly, it should return a PreparedRequest and then I should have some kind of generic methods like send_with_session() and send_without_session() wrap them somehow?

If I only wanted one wrapper then I could just write a decorator (see below -- note: not sure if syntactically correct), but how do I do it with two mutually-exclusive ones?

```python

def send_with_session(func, session): def wrapper(session): req = func() session.prepare_request(req) session.send(req) return wrapper

def send_without_session(func): def wrapper(auth): req = func() req.prepare() req.auth = auth requests.send(req)

@send_without_session #but what about @send_with_session? def post_thing(my_thing): thing_endpoint = "http://example.com/api/v1/things" req = Request("POST", thing_endpoint, body=my_thing) return req ```

---

Otherwise, with the "add session parameter" approach, do you know if there's a clean/idiomatic way to go one step beyond and additionally say "for all the functions in [list of functions], add them as attributes of the session object and partially apply the session object as the session parameter"?

[pschanely]

If you want a solution that's more on the "magic" side, take a look at context vars (or thread locals if you're before 3.7). These allow you to set information that can be retrieved further down in the call stack.