Module chompjs
23 |
26 |
239 | 27 | Expand source code 28 |
29 |# -*- coding: utf-8 -*-
30 |
31 | import json
32 | import warnings
33 |
34 | from _chompjs import parse, parse_objects
35 |
36 |
37 | def _preprocess(string, unicode_escape=False):
38 | if unicode_escape:
39 | string = string.encode().decode("unicode_escape")
40 | return string
41 |
42 |
43 | def _process_loader_arguments(loader_args, loader_kwargs, json_params):
44 | if json_params:
45 | msg = "json_params argument is deprecated, please use loader_kwargs instead"
46 | warnings.warn(msg, DeprecationWarning)
47 | loader_kwargs = json_params
48 |
49 | if not loader_args:
50 | loader_args = []
51 |
52 | if not loader_kwargs:
53 | loader_kwargs = {}
54 |
55 | return (loader_args, loader_kwargs)
56 |
57 |
58 | def parse_js_object(
59 | string,
60 | unicode_escape=False,
61 | loader=json.loads,
62 | loader_args=None,
63 | loader_kwargs=None,
64 | json_params=None,
65 | ):
66 | """
67 | Extracts first JSON object encountered in the input string
68 |
69 | Parameters
70 | ----------
71 | string: str
72 | Input string
73 |
74 | >>> parse_js_object("{a: 100}")
75 | {'a': 100}
76 |
77 | unicode_escape: bool, optional
78 | Attempt to fix input string if it contains escaped special characters
79 |
80 | >>> parse_js_object('{\\\\"a\\\\": 100}')
81 | {'\\\\"a\\\\"': 100}
82 | >>> parse_js_object('{\\\\"a\\\\": 100}', unicode_escape=True)
83 | {'a': 100}
84 |
85 | loader: func, optional
86 | Function used to load processed input data. By default `json.loads` is used
87 |
88 | >>> import orjson
89 | >>> import chompjs
90 | >>>
91 | >>> chompjs.parse_js_object("{'a': 12}", loader=orjson.loads)
92 | {'a': 12}
93 |
94 | loader_args: list, optional
95 | Allow passing down positional arguments to loader function
96 |
97 | loader_kwargs: dict, optional
98 | Allow passing down keyword arguments to loader function
99 |
100 | >>> parse_js_object("{'a': 10.1}")
101 | {'a': 10.1}
102 | >>> import decimal
103 | >>> parse_js_object("{'a': 10.1}", loader_kwargs={'parse_float': decimal.Decimal})
104 | {'a': Decimal('10.1')}
105 |
106 | .. deprecated:: 1.3.0
107 | json_params: dict, optional
108 | Use `loader_kwargs` instead
109 |
110 | Returns
111 | -------
112 | list | dict
113 | Extracted JSON object
114 |
115 | Raises
116 | ------
117 | ValueError
118 | If failed to parse input properly
119 |
120 | ```python
121 | >>> parse_js_object(None)
122 | Traceback (most recent call last):
123 | ...
124 | ValueError: Invalid input
125 | >>> parse_js_object("No JSON objects in sight...")
126 | Traceback (most recent call last):
127 | ...
128 | json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0)
129 |
130 | ```
131 |
132 | """
133 | if not string:
134 | raise ValueError("Invalid input")
135 |
136 | loader_args, loader_kwargs = _process_loader_arguments(
137 | loader_args, loader_kwargs, json_params
138 | )
139 |
140 | if json_params:
141 | msg = "json_params argument is deprecated, please use loader_kwargs instead"
142 | warnings.warn(msg, DeprecationWarning)
143 |
144 | string = _preprocess(string, unicode_escape)
145 | parsed_data = parse(string)
146 | return loader(parsed_data, *loader_args, **loader_kwargs)
147 |
148 |
149 | def parse_js_objects(
150 | string,
151 | unicode_escape=False,
152 | omitempty=False,
153 | loader=json.loads,
154 | loader_args=None,
155 | loader_kwargs=None,
156 | json_params=None,
157 | ):
158 | """
159 | Returns a generator extracting all JSON objects encountered in the input string.
160 | Can be used to read JSON Lines
161 |
162 | Parameters
163 | ----------
164 | string: str
165 | Input string
166 |
167 | >>> it = parse_js_objects("{a: 100} {b: 100}")
168 | >>> next(it)
169 | {'a': 100}
170 | >>> next(it)
171 | {'b': 100}
172 |
173 | unicode_escape: bool, optional
174 | Attempt to fix input string if it contains escaped special characters
175 |
176 | >>> next(parse_js_objects('{\\\\"a\\\\": 100}'))
177 | {'\\\\"a\\\\"': 100}
178 | >>> next(parse_js_objects('{\\\\"a\\\\": 100}', unicode_escape=True))
179 | {'a': 100}
180 |
181 | omitempty: bool, optional
182 | Skip empty dictionaries and lists
183 |
184 | >>> list(parse_js_objects("{a: 12} {} {b: 13}"))
185 | [{'a': 12}, {}, {'b': 13}]
186 | >>> list(parse_js_objects("{a: 12} {} {b: 13}", omitempty=True))
187 | [{'a': 12}, {'b': 13}]
188 |
189 | loader: func, optional
190 | Function used to load processed input data. By default `json.loads` is used
191 |
192 | >>> import orjson
193 | >>> import chompjs
194 | >>>
195 | >>> next(chompjs.parse_js_objects("{'a': 12}", loader=orjson.loads))
196 | {'a': 12}
197 |
198 | loader_args: list, optional
199 | Allow passing down positional arguments to loader function
200 |
201 | loader_kwargs: dict, optional
202 | Allow passing down keyword arguments to loader function
203 |
204 | >>> next(parse_js_objects("{'a': 10.1}"))
205 | {'a': 10.1}
206 | >>> import decimal
207 | >>> next(parse_js_objects("{'a': 10.1}", loader_kwargs={'parse_float': decimal.Decimal}))
208 | {'a': Decimal('10.1')}
209 |
210 | .. deprecated:: 1.3.0
211 | json_params: dict, optional
212 | Use `loader_kwargs` instead
213 |
214 | Returns
215 | -------
216 | generator
217 | Iterating over it yields all encountered JSON objects
218 | """
219 |
220 | if not string:
221 | return
222 |
223 | loader_args, loader_kwargs = _process_loader_arguments(
224 | loader_args, loader_kwargs, json_params
225 | )
226 |
227 | string = _preprocess(string, unicode_escape)
228 | for raw_data in parse_objects(string):
229 | try:
230 | data = loader(raw_data, *loader_args, **loader_kwargs)
231 | except ValueError:
232 | continue
233 |
234 | if not data and omitempty:
235 | continue
236 |
237 | yield dataFunctions
246 |-
247 |
248 | def parse_js_object(string, unicode_escape=False, loader=<function loads>, loader_args=None, loader_kwargs=None, json_params=None) 249 |
250 | -
251 | 318 |
Extracts first JSON object encountered in the input string
252 |Parameters
253 |-
254 |
string:str
255 | - Input string 256 |
260 |>>> parse_js_object("{a: 100}") 258 | {'a': 100} 259 |-
261 |
unicode_escape:bool, optional
262 | - Attempt to fix input string if it contains escaped special characters 263 |
269 |>>> parse_js_object('{\\"a\\": 100}') 265 | {'\\"a\\"': 100} 266 | >>> parse_js_object('{\\"a\\": 100}', unicode_escape=True) 267 | {'a': 100} 268 |-
270 |
loader:func, optional
271 | - Function used to load processed input data. By default
json.loadsis used
272 |
279 |>>> import orjson 274 | >>> import chompjs 275 | >>> 276 | >>> chompjs.parse_js_object("{'a': 12}", loader=orjson.loads) 277 | {'a': 12} 278 |-
280 |
loader_args:list, optional
281 | - Allow passing down positional arguments to loader function 282 |
loader_kwargs:dict, optional
283 | - Allow passing down keyword arguments to loader function 284 |
291 |>>> parse_js_object("{'a': 10.1}") 286 | {'a': 10.1} 287 | >>> import decimal 288 | >>> parse_js_object("{'a': 10.1}", loader_kwargs={'parse_float': decimal.Decimal}) 289 | {'a': Decimal('10.1')} 290 |292 |294 |Deprecated since version: 1.3.0
293 |-
295 |
json_params:dict, optional
296 | - Use
loader_kwargsinstead
297 |
Returns
299 |-
300 |
list | dict
301 | - Extracted JSON object 302 |
Raises
304 |-
305 |
ValueError
306 | - If failed to parse input properly 307 |
>>> parse_js_object(None) 309 | Traceback (most recent call last): 310 | ... 311 | ValueError: Invalid input 312 | >>> parse_js_object("No JSON objects in sight...") 313 | Traceback (most recent call last): 314 | ... 315 | json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0) 316 | 317 |319 |412 |320 | Expand source code 321 |
322 |
411 |def parse_js_object( 323 | string, 324 | unicode_escape=False, 325 | loader=json.loads, 326 | loader_args=None, 327 | loader_kwargs=None, 328 | json_params=None, 329 | ): 330 | """ 331 | Extracts first JSON object encountered in the input string 332 | 333 | Parameters 334 | ---------- 335 | string: str 336 | Input string 337 | 338 | >>> parse_js_object("{a: 100}") 339 | {'a': 100} 340 | 341 | unicode_escape: bool, optional 342 | Attempt to fix input string if it contains escaped special characters 343 | 344 | >>> parse_js_object('{\\\\"a\\\\": 100}') 345 | {'\\\\"a\\\\"': 100} 346 | >>> parse_js_object('{\\\\"a\\\\": 100}', unicode_escape=True) 347 | {'a': 100} 348 | 349 | loader: func, optional 350 | Function used to load processed input data. By default `json.loads` is used 351 | 352 | >>> import orjson 353 | >>> import chompjs 354 | >>> 355 | >>> chompjs.parse_js_object("{'a': 12}", loader=orjson.loads) 356 | {'a': 12} 357 | 358 | loader_args: list, optional 359 | Allow passing down positional arguments to loader function 360 | 361 | loader_kwargs: dict, optional 362 | Allow passing down keyword arguments to loader function 363 | 364 | >>> parse_js_object("{'a': 10.1}") 365 | {'a': 10.1} 366 | >>> import decimal 367 | >>> parse_js_object("{'a': 10.1}", loader_kwargs={'parse_float': decimal.Decimal}) 368 | {'a': Decimal('10.1')} 369 | 370 | .. deprecated:: 1.3.0 371 | json_params: dict, optional 372 | Use `loader_kwargs` instead 373 | 374 | Returns 375 | ------- 376 | list | dict 377 | Extracted JSON object 378 | 379 | Raises 380 | ------ 381 | ValueError 382 | If failed to parse input properly 383 | 384 | ```python 385 | >>> parse_js_object(None) 386 | Traceback (most recent call last): 387 | ... 388 | ValueError: Invalid input 389 | >>> parse_js_object("No JSON objects in sight...") 390 | Traceback (most recent call last): 391 | ... 392 | json.decoder.JSONDecodeError: Expecting value: line 1 column 1 (char 0) 393 | 394 | ``` 395 | 396 | """ 397 | if not string: 398 | raise ValueError("Invalid input") 399 | 400 | loader_args, loader_kwargs = _process_loader_arguments( 401 | loader_args, loader_kwargs, json_params 402 | ) 403 | 404 | if json_params: 405 | msg = "json_params argument is deprecated, please use loader_kwargs instead" 406 | warnings.warn(msg, DeprecationWarning) 407 | 408 | string = _preprocess(string, unicode_escape) 409 | parsed_data = parse(string) 410 | return loader(parsed_data, *loader_args, **loader_kwargs)
413 | 414 | def parse_js_objects(string, unicode_escape=False, omitempty=False, loader=<function loads>, loader_args=None, loader_kwargs=None, json_params=None) 415 |
416 | -
417 | 482 |
Returns a generator extracting all JSON objects encountered in the input string. 418 | Can be used to read JSON Lines
419 |Parameters
420 |-
421 |
string:str
422 | - Input string 423 |
430 |>>> it = parse_js_objects("{a: 100} {b: 100}") 425 | >>> next(it) 426 | {'a': 100} 427 | >>> next(it) 428 | {'b': 100} 429 |-
431 |
unicode_escape:bool, optional
432 | - Attempt to fix input string if it contains escaped special characters 433 |
439 |>>> next(parse_js_objects('{\\"a\\": 100}')) 435 | {'\\"a\\"': 100} 436 | >>> next(parse_js_objects('{\\"a\\": 100}', unicode_escape=True)) 437 | {'a': 100} 438 |-
440 |
omitempty:bool, optional
441 | - Skip empty dictionaries and lists 442 |
448 |>>> list(parse_js_objects("{a: 12} {} {b: 13}")) 444 | [{'a': 12}, {}, {'b': 13}] 445 | >>> list(parse_js_objects("{a: 12} {} {b: 13}", omitempty=True)) 446 | [{'a': 12}, {'b': 13}] 447 |-
449 |
loader:func, optional
450 | - Function used to load processed input data. By default
json.loadsis used
451 |
458 |>>> import orjson 453 | >>> import chompjs 454 | >>> 455 | >>> next(chompjs.parse_js_objects("{'a': 12}", loader=orjson.loads)) 456 | {'a': 12} 457 |-
459 |
loader_args:list, optional
460 | - Allow passing down positional arguments to loader function 461 |
loader_kwargs:dict, optional
462 | - Allow passing down keyword arguments to loader function 463 |
470 |>>> next(parse_js_objects("{'a': 10.1}")) 465 | {'a': 10.1} 466 | >>> import decimal 467 | >>> next(parse_js_objects("{'a': 10.1}", loader_kwargs={'parse_float': decimal.Decimal})) 468 | {'a': Decimal('10.1')} 469 |471 |473 |Deprecated since version: 1.3.0
472 |-
474 |
json_params:dict, optional
475 | - Use
loader_kwargsinstead
476 |
Returns
478 |-
479 |
generator
480 | - Iterating over it yields all encountered JSON objects 481 |
483 |576 |484 | Expand source code 485 |
486 |
575 |def parse_js_objects( 487 | string, 488 | unicode_escape=False, 489 | omitempty=False, 490 | loader=json.loads, 491 | loader_args=None, 492 | loader_kwargs=None, 493 | json_params=None, 494 | ): 495 | """ 496 | Returns a generator extracting all JSON objects encountered in the input string. 497 | Can be used to read JSON Lines 498 | 499 | Parameters 500 | ---------- 501 | string: str 502 | Input string 503 | 504 | >>> it = parse_js_objects("{a: 100} {b: 100}") 505 | >>> next(it) 506 | {'a': 100} 507 | >>> next(it) 508 | {'b': 100} 509 | 510 | unicode_escape: bool, optional 511 | Attempt to fix input string if it contains escaped special characters 512 | 513 | >>> next(parse_js_objects('{\\\\"a\\\\": 100}')) 514 | {'\\\\"a\\\\"': 100} 515 | >>> next(parse_js_objects('{\\\\"a\\\\": 100}', unicode_escape=True)) 516 | {'a': 100} 517 | 518 | omitempty: bool, optional 519 | Skip empty dictionaries and lists 520 | 521 | >>> list(parse_js_objects("{a: 12} {} {b: 13}")) 522 | [{'a': 12}, {}, {'b': 13}] 523 | >>> list(parse_js_objects("{a: 12} {} {b: 13}", omitempty=True)) 524 | [{'a': 12}, {'b': 13}] 525 | 526 | loader: func, optional 527 | Function used to load processed input data. By default `json.loads` is used 528 | 529 | >>> import orjson 530 | >>> import chompjs 531 | >>> 532 | >>> next(chompjs.parse_js_objects("{'a': 12}", loader=orjson.loads)) 533 | {'a': 12} 534 | 535 | loader_args: list, optional 536 | Allow passing down positional arguments to loader function 537 | 538 | loader_kwargs: dict, optional 539 | Allow passing down keyword arguments to loader function 540 | 541 | >>> next(parse_js_objects("{'a': 10.1}")) 542 | {'a': 10.1} 543 | >>> import decimal 544 | >>> next(parse_js_objects("{'a': 10.1}", loader_kwargs={'parse_float': decimal.Decimal})) 545 | {'a': Decimal('10.1')} 546 | 547 | .. deprecated:: 1.3.0 548 | json_params: dict, optional 549 | Use `loader_kwargs` instead 550 | 551 | Returns 552 | ------- 553 | generator 554 | Iterating over it yields all encountered JSON objects 555 | """ 556 | 557 | if not string: 558 | return 559 | 560 | loader_args, loader_kwargs = _process_loader_arguments( 561 | loader_args, loader_kwargs, json_params 562 | ) 563 | 564 | string = _preprocess(string, unicode_escape) 565 | for raw_data in parse_objects(string): 566 | try: 567 | data = loader(raw_data, *loader_args, **loader_kwargs) 568 | except ValueError: 569 | continue 570 | 571 | if not data and omitempty: 572 | continue 573 | 574 | yield data
577 |