| from typing import Iterator, List, Dict, TypeVar | |
| import json | |
| import argparse | |
| from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor | |
| from itertools import islice | |
| import smart_open | |
| from tqdm import tqdm | |
| import jmespath | |
| T = TypeVar("T") | |
| def batch_iterator(iterator: Iterator[T], batch_size: int = 50) -> Iterator[List[T]]: | |
| iterator = iter(iterator) | |
| while True: | |
| batch = list(islice(iterator, batch_size)) | |
| if not batch: | |
| return | |
| yield batch | |
| def process_chunk(chunk: List, extractor: jmespath.parser.ParsedResult) -> List[Dict]: | |
| """ | |
| Apply JMESPath to a chunk of JSONL data. | |
| """ | |
| results: List[Dict] = [] | |
| for line in chunk: | |
| data = json.loads(line) | |
| extracted = extractor.search(data) | |
| if extracted is not None: | |
| if not isinstance(extracted, list): | |
| extracted = [extracted] | |
| for item in extracted: | |
| item["url"] = data["url"] | |
| item["schema_type"] = data["schema_type"] | |
| results.append(item) | |
| return results | |
| def process_file( | |
| input_file: str, | |
| output_file: str, | |
| chunk_size: int, | |
| num_threads: int, | |
| extractor: jmespath.parser.ParsedResult, | |
| ): | |
| """ | |
| Apply JMESPath to a large JSONL file in parallel. | |
| input_file: path to input JSONL file | |
| output_file: path to output JSONL file | |
| chunk_size: number of lines to process at a time | |
| num_threads: number of threads to use | |
| extractor: compiled JMESPath expression to apply | |
| """ | |
| with smart_open.open(input_file, "rt", encoding="utf-8") as reader, smart_open.open( | |
| output_file, "wt", encoding="utf-8" | |
| ) as writer: | |
| with ThreadPoolExecutor(max_workers=num_threads) as executor: | |
| for chunk in batch_iterator(tqdm(reader), batch_size=chunk_size): | |
| if not chunk: | |
| break | |
| results = executor.map(process_chunk, [chunk], [extractor]) | |
| for result in results: | |
| for item in result: | |
| writer.write(json.dumps(item, ensure_ascii=False)) | |
| writer.write("\n") | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser( | |
| description="Apply JMESPath to a large JSONL file in parallel." | |
| ) | |
| parser.add_argument("input_file", help="path to input JSONL file") | |
| parser.add_argument("output_file", help="path to output JSONL file") | |
| parser.add_argument( | |
| "--chunk-size", | |
| type=int, | |
| default=10000, | |
| help="number of lines to process at a time (default: 10000)", | |
| ) | |
| parser.add_argument( | |
| "--num-threads", | |
| type=int, | |
| default=4, | |
| help="number of threads to use (default: 4)", | |
| ) | |
| args = parser.parse_args() | |
| jmespath_expression: jmespath.parser.ParsedResult = jmespath.compile( | |
| """metadata.*[?"@type"=='FAQPage' || "@type"=='HowTo'][]""" | |
| ) | |
| process_file( | |
| args.input_file, | |
| args.output_file, | |
| args.chunk_size, | |
| args.num_threads, | |
| jmespath_expression, | |
| ) | |