Skip to content

_core#

Lunchmoney SDK Core

LunchMoneyAPIClient #

Core API Client Class

Source code in lunchable/models/_core.py 
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
class LunchMoneyAPIClient:
    """
    Core API Client Class
    """

    class Methods:
        """
        HTTP Request Method Enumerations: GET, OPTIONS, HEAD, POST, PUT, PATCH, or DELETE
        """

        # This Helper Namespace Organizes and Tracks HTTP Requests by Method
        GET = "GET"
        OPTIONS = "OPTIONS"
        HEAD = "HEAD"
        POST = "POST"
        PUT = "PUT"
        PATCH = "PATCH"
        DELETE = "DELETE"

    def __init__(self, access_token: str | None = None) -> None:
        """
        Initialize a Lunch Money object with an Access Token.

        Tries to inherit from the Environment if one isn't provided

        Parameters
        ----------
        access_token: Optional[str]
            Lunchmoney Developer API Access Token
        """
        self.access_token = APIConfig.get_access_token(access_token=access_token)

    def __repr__(self) -> str:
        """
        String Representation

        Returns
        -------
        str
        """
        return "<LunchMoney: httpx.Client>"

    @cached_property
    def session(self) -> httpx.Client:
        """
        Lunch Money HTTPX Client

        Returns
        -------
        httpx.Client
        """
        return LunchMoneyClient(access_token=self.access_token)

    @cached_property
    def async_session(self) -> httpx.AsyncClient:
        """
        Lunch Money HTTPX Async Client

        Returns
        -------
        httpx.AsyncClient
        """
        return LunchMoneyAsyncClient(access_token=self.access_token)

    def request(
        self,
        method: str,
        url: Union[httpx.URL, str],
        *,
        content: Optional[
            Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
        ] = None,
        data: Optional[Mapping[str, Any]] = None,
        json: Optional[Any] = None,
        params: Optional[Mapping[str, Any]] = None,
        **kwargs: Any,
    ) -> httpx.Response:
        """
        Make an HTTP request

        This is a simple method :class:`.LunchMoney` exposes to make HTTP requests. It
        has the benefit of using an existing `httpx.Client` as well as as out of the box
        auth headers that are used to connect to the Lunch Money Developer API.

        Parameters
        ----------
        method: str
            requests method: GET, OPTIONS, HEAD, POST, PUT,
            PATCH, or DELETE
        url: Union[httpx.URL, str]
            URL for the new Request object.
        content: Optional[Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]]
            Content to send in the body of the Request.
        data: Optional[Mapping[str, Any]]
            Dictionary, list of tuples, bytes, or file-like object to send
            in the body of the Request.
        json: Optional[Any]
            A JSON serializable Python object to send in the body of the Request.
        params: Optional[Mapping[str, Any]]
            Dictionary, list of tuples or bytes to send in the query
            string for the Request.
        **kwargs: Any
            Additional arguments to send to the request method.

        Returns
        -------
        httpx.Response

        Examples
        --------
        A recent use of this method was to delete a Tag (which isn't available via the
        Developer API yet)

        ```python
        import lunchable

        lunch = lunchable.LunchMoney()

        # Get All the Tags
        all_tags = lunch.get_tags()
        # Get All The Null Tags (a list of 1 or zero)
        null_tags = [tag for tag in all_tags if tag.name in [None, ""]]

        # Create a Cookie dictionary from a browser session
        cookies = {"cookie_keys": "cookie_values"}
        del lunch.session.headers["authorization"]

        for null_tag in null_tags:
            # use the httpx.client embedded in the class to make a request with cookies
            response = lunch.request(
                method=lunch.Methods.DELETE,
                url=f"https://api.lunchmoney.app/tags/{null_tag.id}",
                cookies=cookies
            )
            # raise an error for 4XX responses
            response.raise_for_status()
        ```
        """
        response = self.session.request(
            method=method,
            url=url,
            content=content,
            data=data,
            json=json,
            params=params,
            **kwargs,
        )
        return response

    async def arequest(
        self,
        method: str,
        url: Union[httpx.URL, str],
        *,
        content: Optional[
            Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
        ] = None,
        data: Optional[Mapping[str, Any]] = None,
        json: Optional[Any] = None,
        params: Optional[Mapping[str, Any]] = None,
        **kwargs: Any,
    ) -> httpx.Response:
        """
        Make an async HTTP request

        This is a simple method :class:`.LunchMoney` exposes to make HTTP requests. It
        has the benefit of using an existing `httpx.Client` as well as as out of the box
        auth headers that are used to connect to the Lunch Money Developer API.

        Parameters
        ----------
        method: str
            requests method: GET, OPTIONS, HEAD, POST, PUT,
            PATCH, or DELETE
        url: Union[httpx.URL, str]
            URL for the new Request object.
        content: Optional[Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]]
            Content to send in the body of the Request.
        data: Optional[Mapping[str, Any]]
            Dictionary, list of tuples, bytes, or file-like object to send
            in the body of the Request.
        json: Optional[Any]
            A JSON serializable Python object to send in the body of the Request.
        params: Optional[Mapping[str, Any]]
            Dictionary, list of tuples or bytes to send in the query
            string for the Request.
        **kwargs: Any
            Additional arguments to send to the request method.

        Returns
        -------
        httpx.Response
        """
        response = self.async_session.request(
            method=method,
            url=url,
            content=content,
            data=data,
            json=json,
            params=params,
            **kwargs,
        )
        return await response

    @classmethod
    def process_response(cls, response: httpx.Response) -> Any:
        """
        Process a Lunch Money response and raise any errors

        This includes 200 responses that are actually errors

        Parameters
        ----------
        response: httpx.Response
            An HTTPX Response Object
        """
        try:
            response.raise_for_status()
        except httpx.HTTPError as he:
            raise LunchMoneyHTTPError(response.text) from he
        if response.content:
            returned_data = response.json()
        else:
            returned_data = None
        if isinstance(returned_data, dict) and any(
            ["error" in returned_data.keys(), "errors" in returned_data.keys()]
        ):
            try:
                errors = returned_data["error"]
            except KeyError:
                errors = returned_data["errors"]
            raise LunchMoneyHTTPError(errors)
        return returned_data

    def make_request(
        self,
        method: str,
        url_path: Union[list[Union[str, int]], str, int],
        params: Optional[Mapping[str, Any]] = None,
        payload: Optional[Any] = None,
        **kwargs: Any,
    ) -> Any:
        """
        Make an HTTP request and `process` its response

        This method is a wrapper around :meth:`.LunchMoney.request` that
        also processes the response and checks for any errors.

        Parameters
        ----------
        method: str
            requests method: GET, OPTIONS, HEAD, POST, PUT,
            PATCH, or DELETE
        url_path: Union[List[Union[str, int]], str, int]
            URL components to make into a URL
        payload: Optional[Mapping[str, Any]]
            Data to send in the body of the Request.
        params: Optional[Mapping[str, Any]]
            Dictionary, list of tuples or bytes to send in the query
            string for the Request.
        **kwargs: Any
            Additional arguments to send to the request method.

        Returns
        -------
        Any
        """
        url = APIConfig.make_url(url_path=url_path)
        json_safe_payload = pydantic_core.to_json(payload) if payload else None
        json_safe_params = pydantic_core.to_jsonable_python(params)
        response = self.request(
            method=method,
            url=url,
            params=json_safe_params,
            content=json_safe_payload,
            **kwargs,
        )
        data = self.process_response(response=response)
        return data

    async def amake_request(
        self,
        method: str,
        url_path: Union[list[Union[str, int]], str, int],
        params: Optional[Mapping[str, Any]] = None,
        payload: Optional[Any] = None,
        **kwargs: Any,
    ) -> Any:
        """
        Make an async HTTP request and `process` its response

        This method is a wrapper around :meth:`.LunchMoney.arequest` that
        also processes the response and checks for any errors.

        Parameters
        ----------
        method: str
            requests method: GET, OPTIONS, HEAD, POST, PUT,
            PATCH, or DELETE
        url_path: Union[List[Union[str, int]], str, int]
            URL components to make into a URL
        payload: Optional[Mapping[str, Any]]
            Data to send in the body of the Request.
        params: Optional[Mapping[str, Any]]
            Dictionary, list of tuples or bytes to send in the query
            string for the Request.
        **kwargs: Any
            Additional arguments to send to the request method.

        Returns
        -------
        Any
        """
        url = APIConfig.make_url(url_path=url_path)
        json_safe_payload = pydantic_core.to_jsonable_python(payload)
        json_safe_params = pydantic_core.to_jsonable_python(params)
        response = await self.arequest(
            method=method,
            url=url,
            params=json_safe_params,
            data=json_safe_payload,
            **kwargs,
        )
        data = self.process_response(response=response)
        return data

async_session: httpx.AsyncClient cached property #

Lunch Money HTTPX Async Client

Returns:

Type Description
AsyncClient

session: httpx.Client cached property #

Lunch Money HTTPX Client

Returns:

Type Description
Client

Methods #

HTTP Request Method Enumerations: GET, OPTIONS, HEAD, POST, PUT, PATCH, or DELETE

Source code in lunchable/models/_core.py 
54
55
56
57
58
59
60
61
62
63
64
65
66
class Methods:
    """
    HTTP Request Method Enumerations: GET, OPTIONS, HEAD, POST, PUT, PATCH, or DELETE
    """

    # This Helper Namespace Organizes and Tracks HTTP Requests by Method
    GET = "GET"
    OPTIONS = "OPTIONS"
    HEAD = "HEAD"
    POST = "POST"
    PUT = "PUT"
    PATCH = "PATCH"
    DELETE = "DELETE"

__init__(access_token=None) #

Initialize a Lunch Money object with an Access Token.

Tries to inherit from the Environment if one isn't provided

Parameters:

Name Type Description Default
access_token str | None

Lunchmoney Developer API Access Token

 None
Source code in lunchable/models/_core.py 
68
69
70
71
72
73
74
75
76
77
78
79
def __init__(self, access_token: str | None = None) -> None:
    """
    Initialize a Lunch Money object with an Access Token.

    Tries to inherit from the Environment if one isn't provided

    Parameters
    ----------
    access_token: Optional[str]
        Lunchmoney Developer API Access Token
    """
    self.access_token = APIConfig.get_access_token(access_token=access_token)

__repr__() #

String Representation

Returns:

Type Description
str
Source code in lunchable/models/_core.py 
81
82
83
84
85
86
87
88
89
def __repr__(self) -> str:
    """
    String Representation

    Returns
    -------
    str
    """
    return "<LunchMoney: httpx.Client>"

amake_request(method, url_path, params=None, payload=None, **kwargs) async #

Make an async HTTP request and process its response

This method is a wrapper around :meth:.LunchMoney.arequest that also processes the response and checks for any errors.

Parameters:

Name Type Description Default
method str

requests method: GET, OPTIONS, HEAD, POST, PUT, PATCH, or DELETE

 required
url_path Union[list[Union[str, int]], str, int]

URL components to make into a URL

 required
payload Optional[Any]

Data to send in the body of the Request.

 None
params Optional[Mapping[str, Any]]

Dictionary, list of tuples or bytes to send in the query string for the Request.

 None
**kwargs Any

Additional arguments to send to the request method.

 {}

Returns:

Type Description
Any
Source code in lunchable/models/_core.py 
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
async def amake_request(
    self,
    method: str,
    url_path: Union[list[Union[str, int]], str, int],
    params: Optional[Mapping[str, Any]] = None,
    payload: Optional[Any] = None,
    **kwargs: Any,
) -> Any:
    """
    Make an async HTTP request and `process` its response

    This method is a wrapper around :meth:`.LunchMoney.arequest` that
    also processes the response and checks for any errors.

    Parameters
    ----------
    method: str
        requests method: GET, OPTIONS, HEAD, POST, PUT,
        PATCH, or DELETE
    url_path: Union[List[Union[str, int]], str, int]
        URL components to make into a URL
    payload: Optional[Mapping[str, Any]]
        Data to send in the body of the Request.
    params: Optional[Mapping[str, Any]]
        Dictionary, list of tuples or bytes to send in the query
        string for the Request.
    **kwargs: Any
        Additional arguments to send to the request method.

    Returns
    -------
    Any
    """
    url = APIConfig.make_url(url_path=url_path)
    json_safe_payload = pydantic_core.to_jsonable_python(payload)
    json_safe_params = pydantic_core.to_jsonable_python(params)
    response = await self.arequest(
        method=method,
        url=url,
        params=json_safe_params,
        data=json_safe_payload,
        **kwargs,
    )
    data = self.process_response(response=response)
    return data

arequest(method, url, *, content=None, data=None, json=None, params=None, **kwargs) async #

Make an async HTTP request

This is a simple method :class:.LunchMoney exposes to make HTTP requests. It has the benefit of using an existing httpx.Client as well as as out of the box auth headers that are used to connect to the Lunch Money Developer API.

Parameters:

Name Type Description Default
method str

requests method: GET, OPTIONS, HEAD, POST, PUT, PATCH, or DELETE

 required
url Union[URL, str]

URL for the new Request object.

 required
content Optional[Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]]

Content to send in the body of the Request.

 None
data Optional[Mapping[str, Any]]

Dictionary, list of tuples, bytes, or file-like object to send in the body of the Request.

 None
json Optional[Any]

A JSON serializable Python object to send in the body of the Request.

 None
params Optional[Mapping[str, Any]]

Dictionary, list of tuples or bytes to send in the query string for the Request.

 None
**kwargs Any

Additional arguments to send to the request method.

 {}

Returns:

Type Description
Response
Source code in lunchable/models/_core.py 
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
async def arequest(
    self,
    method: str,
    url: Union[httpx.URL, str],
    *,
    content: Optional[
        Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
    ] = None,
    data: Optional[Mapping[str, Any]] = None,
    json: Optional[Any] = None,
    params: Optional[Mapping[str, Any]] = None,
    **kwargs: Any,
) -> httpx.Response:
    """
    Make an async HTTP request

    This is a simple method :class:`.LunchMoney` exposes to make HTTP requests. It
    has the benefit of using an existing `httpx.Client` as well as as out of the box
    auth headers that are used to connect to the Lunch Money Developer API.

    Parameters
    ----------
    method: str
        requests method: GET, OPTIONS, HEAD, POST, PUT,
        PATCH, or DELETE
    url: Union[httpx.URL, str]
        URL for the new Request object.
    content: Optional[Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]]
        Content to send in the body of the Request.
    data: Optional[Mapping[str, Any]]
        Dictionary, list of tuples, bytes, or file-like object to send
        in the body of the Request.
    json: Optional[Any]
        A JSON serializable Python object to send in the body of the Request.
    params: Optional[Mapping[str, Any]]
        Dictionary, list of tuples or bytes to send in the query
        string for the Request.
    **kwargs: Any
        Additional arguments to send to the request method.

    Returns
    -------
    httpx.Response
    """
    response = self.async_session.request(
        method=method,
        url=url,
        content=content,
        data=data,
        json=json,
        params=params,
        **kwargs,
    )
    return await response

make_request(method, url_path, params=None, payload=None, **kwargs) #

Make an HTTP request and process its response

This method is a wrapper around :meth:.LunchMoney.request that also processes the response and checks for any errors.

Parameters:

Name Type Description Default
method str

requests method: GET, OPTIONS, HEAD, POST, PUT, PATCH, or DELETE

 required
url_path Union[list[Union[str, int]], str, int]

URL components to make into a URL

 required
payload Optional[Any]

Data to send in the body of the Request.

 None
params Optional[Mapping[str, Any]]

Dictionary, list of tuples or bytes to send in the query string for the Request.

 None
**kwargs Any

Additional arguments to send to the request method.

 {}

Returns:

Type Description
Any
Source code in lunchable/models/_core.py 
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
def make_request(
    self,
    method: str,
    url_path: Union[list[Union[str, int]], str, int],
    params: Optional[Mapping[str, Any]] = None,
    payload: Optional[Any] = None,
    **kwargs: Any,
) -> Any:
    """
    Make an HTTP request and `process` its response

    This method is a wrapper around :meth:`.LunchMoney.request` that
    also processes the response and checks for any errors.

    Parameters
    ----------
    method: str
        requests method: GET, OPTIONS, HEAD, POST, PUT,
        PATCH, or DELETE
    url_path: Union[List[Union[str, int]], str, int]
        URL components to make into a URL
    payload: Optional[Mapping[str, Any]]
        Data to send in the body of the Request.
    params: Optional[Mapping[str, Any]]
        Dictionary, list of tuples or bytes to send in the query
        string for the Request.
    **kwargs: Any
        Additional arguments to send to the request method.

    Returns
    -------
    Any
    """
    url = APIConfig.make_url(url_path=url_path)
    json_safe_payload = pydantic_core.to_json(payload) if payload else None
    json_safe_params = pydantic_core.to_jsonable_python(params)
    response = self.request(
        method=method,
        url=url,
        params=json_safe_params,
        content=json_safe_payload,
        **kwargs,
    )
    data = self.process_response(response=response)
    return data

process_response(response) classmethod #

Process a Lunch Money response and raise any errors

This includes 200 responses that are actually errors

Parameters:

Name Type Description Default
response Response

An HTTPX Response Object

 required
Source code in lunchable/models/_core.py 
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
@classmethod
def process_response(cls, response: httpx.Response) -> Any:
    """
    Process a Lunch Money response and raise any errors

    This includes 200 responses that are actually errors

    Parameters
    ----------
    response: httpx.Response
        An HTTPX Response Object
    """
    try:
        response.raise_for_status()
    except httpx.HTTPError as he:
        raise LunchMoneyHTTPError(response.text) from he
    if response.content:
        returned_data = response.json()
    else:
        returned_data = None
    if isinstance(returned_data, dict) and any(
        ["error" in returned_data.keys(), "errors" in returned_data.keys()]
    ):
        try:
            errors = returned_data["error"]
        except KeyError:
            errors = returned_data["errors"]
        raise LunchMoneyHTTPError(errors)
    return returned_data

request(method, url, *, content=None, data=None, json=None, params=None, **kwargs) #

Make an HTTP request

This is a simple method :class:.LunchMoney exposes to make HTTP requests. It has the benefit of using an existing httpx.Client as well as as out of the box auth headers that are used to connect to the Lunch Money Developer API.

Parameters:

Name Type Description Default
method str

requests method: GET, OPTIONS, HEAD, POST, PUT, PATCH, or DELETE

 required
url Union[URL, str]

URL for the new Request object.

 required
content Optional[Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]]

Content to send in the body of the Request.

 None
data Optional[Mapping[str, Any]]

Dictionary, list of tuples, bytes, or file-like object to send in the body of the Request.

 None
json Optional[Any]

A JSON serializable Python object to send in the body of the Request.

 None
params Optional[Mapping[str, Any]]

Dictionary, list of tuples or bytes to send in the query string for the Request.

 None
**kwargs Any

Additional arguments to send to the request method.

 {}

Returns:

Type Description
Response

Examples:

A recent use of this method was to delete a Tag (which isn't available via the Developer API yet)

import lunchable

lunch = lunchable.LunchMoney()

# Get All the Tags
all_tags = lunch.get_tags()
# Get All The Null Tags (a list of 1 or zero)
null_tags = [tag for tag in all_tags if tag.name in [None, ""]]

# Create a Cookie dictionary from a browser session
cookies = {"cookie_keys": "cookie_values"}
del lunch.session.headers["authorization"]

for null_tag in null_tags:
    # use the httpx.client embedded in the class to make a request with cookies
    response = lunch.request(
        method=lunch.Methods.DELETE,
        url=f"https://api.lunchmoney.app/tags/{null_tag.id}",
        cookies=cookies
    )
    # raise an error for 4XX responses
    response.raise_for_status()
Source code in lunchable/models/_core.py 
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
def request(
    self,
    method: str,
    url: Union[httpx.URL, str],
    *,
    content: Optional[
        Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]
    ] = None,
    data: Optional[Mapping[str, Any]] = None,
    json: Optional[Any] = None,
    params: Optional[Mapping[str, Any]] = None,
    **kwargs: Any,
) -> httpx.Response:
    """
    Make an HTTP request

    This is a simple method :class:`.LunchMoney` exposes to make HTTP requests. It
    has the benefit of using an existing `httpx.Client` as well as as out of the box
    auth headers that are used to connect to the Lunch Money Developer API.

    Parameters
    ----------
    method: str
        requests method: GET, OPTIONS, HEAD, POST, PUT,
        PATCH, or DELETE
    url: Union[httpx.URL, str]
        URL for the new Request object.
    content: Optional[Union[str, bytes, Iterable[bytes], AsyncIterable[bytes]]]
        Content to send in the body of the Request.
    data: Optional[Mapping[str, Any]]
        Dictionary, list of tuples, bytes, or file-like object to send
        in the body of the Request.
    json: Optional[Any]
        A JSON serializable Python object to send in the body of the Request.
    params: Optional[Mapping[str, Any]]
        Dictionary, list of tuples or bytes to send in the query
        string for the Request.
    **kwargs: Any
        Additional arguments to send to the request method.

    Returns
    -------
    httpx.Response

    Examples
    --------
    A recent use of this method was to delete a Tag (which isn't available via the
    Developer API yet)

    ```python
    import lunchable

    lunch = lunchable.LunchMoney()

    # Get All the Tags
    all_tags = lunch.get_tags()
    # Get All The Null Tags (a list of 1 or zero)
    null_tags = [tag for tag in all_tags if tag.name in [None, ""]]

    # Create a Cookie dictionary from a browser session
    cookies = {"cookie_keys": "cookie_values"}
    del lunch.session.headers["authorization"]

    for null_tag in null_tags:
        # use the httpx.client embedded in the class to make a request with cookies
        response = lunch.request(
            method=lunch.Methods.DELETE,
            url=f"https://api.lunchmoney.app/tags/{null_tag.id}",
            cookies=cookies
        )
        # raise an error for 4XX responses
        response.raise_for_status()
    ```
    """
    response = self.session.request(
        method=method,
        url=url,
        content=content,
        data=data,
        json=json,
        params=params,
        **kwargs,
    )
    return response

LunchMoneyAsyncClient #

Bases: AsyncClient

API Async HTTP Client

Source code in lunchable/models/_core.py 
37
38
39
40
41
42
43
44
45
46
class LunchMoneyAsyncClient(httpx.AsyncClient):
    """
    API Async HTTP Client
    """

    def __init__(self, access_token: str | None = None) -> None:
        timeout = httpx.Timeout(connect=5, read=30, write=20, pool=5)
        super().__init__(timeout=timeout)
        api_headers = APIConfig.get_header(access_token=access_token)
        self.headers.update(api_headers)

LunchMoneyClient #

Bases: Client

API HTTP Client

Source code in lunchable/models/_core.py 
25
26
27
28
29
30
31
32
33
34
class LunchMoneyClient(Client):
    """
    API HTTP Client
    """

    def __init__(self, access_token: str | None = None) -> None:
        timeout = httpx.Timeout(connect=5, read=30, write=20, pool=5)
        super().__init__(timeout=timeout)
        api_headers = APIConfig.get_header(access_token=access_token)
        self.headers.update(api_headers)