From 07940ad16258cac0bac5396c19e5cbb67bbb9147 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:03:56 +0200 Subject: [PATCH 01/13] Added support rotated bboxes --- pyproject.toml | 22 ++++++-- scaledp/image/ImageDrawBoxes.py | 79 ++++++++++++++++++++------- scaledp/schemas/Box.py | 97 ++++++++++++++++++++++++++++++++- 3 files changed, 171 insertions(+), 27 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index 9920ddb..5cb8c19 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "scaledp" -version = "0.2.3rc11" +version = "0.2.3rc45" description = "ScaleDP is a library for processing documents using Apache Spark and LLMs" authors = ["Mykola Melnyk "] repository = "https://github.com/StabRise/scaledp" @@ -31,14 +31,17 @@ torch = [ #{version = "==2.2.0", platform = "darwin", optional = true }, {version = ">=2.4.1", source = "pytorch_cpu", optional = true} ] -dspy = {version = "2.5.43", optional = true} +#dspy = {version = "2.5.43", optional = true} levenshtein = "^0.27.1" pydantic = ">=1.8.0" huggingface-hub = "^0.28.1" -tenacity = "^9.0.0" -openai = "^1.58.0" +tenacity = ">=8.2.3" +openai = ">=1.58.0" sparkdantic = "^2.0.0" img2pdf = "^0.6.1" +pycrafter = "^0.0.7" +shapely = "^2.1.1" +pyclipper = "^1.3.0.post6" [tool.poetry.extras] @@ -70,6 +73,7 @@ black = "^24.10.0" ultralytics = "^8.3.40" pre-commit = "^3.7.1" ruff = "^0.5.0" +craft-text-detector-updated = "^0.4.7" [build-system] #requires = ["poetry-core<2.0.0"] @@ -145,7 +149,14 @@ lint.ignore = [ "N802", "SLF001", # call protected method "PLE0604", + "RET504", + "ANN204" ] +exclude = [ + "scaledp/models/detectors/yolo/*.py", + "scaledp/models/detectors/paddle_onnx/*.py", + ] + [tool.ruff.lint.per-file-ignores] "tests/*" = [ @@ -157,9 +168,10 @@ lint.ignore = [ ] + [tool.ruff.lint.pydocstyle] convention = "pep257" ignore-decorators = ["typing.overload"] [tool.ruff.lint.pylint] -allow-magic-value-types = ["int", "str", "float", "bytes"] \ No newline at end of file +allow-magic-value-types = ["int", "str", "float", "bytes"] diff --git a/scaledp/image/ImageDrawBoxes.py b/scaledp/image/ImageDrawBoxes.py index aad6e4a..2843a0b 100644 --- a/scaledp/image/ImageDrawBoxes.py +++ b/scaledp/image/ImageDrawBoxes.py @@ -1,4 +1,5 @@ import logging +import math import random import traceback from types import MappingProxyType @@ -127,7 +128,7 @@ def getDisplayText(self, box): text.append(val) return ":".join(text) - def transform_udf(self, image, data): + def transform_udf(self, image, *data_list: Any): def get_color(): return "#{:06x}".format(random.randint(0, 0xFFFFFF)) @@ -146,10 +147,12 @@ def get_color(): img1 = ImageDraw.Draw(img) fill = self.getColor() if self.getFilled() else None - if hasattr(data, "entities"): - self.draw_ner_boxes(data, fill, get_color, img1) - else: - self.draw_boxes(data, fill, img1) + for data in data_list: + + if hasattr(data, "entities"): + self.draw_ner_boxes(data, fill, get_color, img1) + else: + self.draw_boxes(data, fill, img1) except Exception: exception = traceback.format_exc() @@ -164,13 +167,7 @@ def draw_boxes(self, data, fill, img1): box = b if not isinstance(box, Box): box = Box(**box.asDict()) - img1.rounded_rectangle( - box.shape(self.getPadding()), - outline=color, - radius=4, - fill=fill, - width=self.getLineWidth(), - ) + self.draw_box(box, color, fill, img1) text = self.getDisplayText(box) if text: img1.text( @@ -183,6 +180,51 @@ def draw_boxes(self, data, fill, img1): font_size=self.getTextSize(), ) + def draw_box(self, box, color, fill, img1): + if box.angle == 0: + # Draw normal rectangle if angle is 0 + img1.rounded_rectangle( + box.shape(self.getPadding()), + outline=color, + radius=4, + fill=fill, + width=self.getLineWidth(), + ) + else: + # Draw rotated rectangle for non-zero angles + center_x = box.x + box.width / 2 + center_y = box.y + box.height / 2 + points = [ + # Top-left + (-box.width / 2, -box.height / 2), + # Top-right + (box.width / 2, -box.height / 2), + # Bottom-right + (box.width / 2, box.height / 2), + # Bottom-left + (-box.width / 2, box.height / 2), + ] + # Rotate points and translate to center + rotated_points = [] + + angle_rad = math.radians(box.angle) + for px, py in points: + # Rotate point + rx = px * math.cos(angle_rad) - py * math.sin(angle_rad) + ry = px * math.sin(angle_rad) + py * math.cos(angle_rad) + # Translate to center + rx += center_x + ry += center_y + rotated_points.append((rx, ry)) + + # Draw polygon with rotated points + img1.polygon( + rotated_points, + outline=color, + fill=fill, + width=self.getLineWidth(), + ) + def draw_ner_boxes(self, data, fill, get_color, img1): black_list = self.getBlackList() white_list = self.getWhiteList() @@ -209,13 +251,8 @@ def draw_ner_boxes(self, data, fill, get_color, img1): if not isinstance(box, Box): box = Box(**box.asDict()) text = self.getDisplayText(ner) - img1.rounded_rectangle( - box.shape(self.getPadding()), - outline=color, - radius=4, - fill=fill, - width=self.getLineWidth(), - ) + self.draw_box(box, color, fill, img1) + if text: tbox = list( img1.textbbox( @@ -254,7 +291,7 @@ def _preprocessing(self, dataset): def _transform(self, dataset): out_col = self.getOutputCol() image_col = self._validate(self.getInputCols()[0], dataset) - box_col = self._validate(self.getInputCols()[1], dataset) + box_cols = [self._validate(col, dataset) for col in self.getInputCols()[1:]] dataset = self._preprocessing(dataset) @@ -264,7 +301,7 @@ def _transform(self, dataset): ) result = dataset.withColumn( out_col, - udf(self.transform_udf, Image.get_schema())(image_col, box_col), + udf(self.transform_udf, Image.get_schema())(image_col, *box_cols), ) if not self.getKeepInputData(): diff --git a/scaledp/schemas/Box.py b/scaledp/schemas/Box.py index 6b83689..0e6285c 100644 --- a/scaledp/schemas/Box.py +++ b/scaledp/schemas/Box.py @@ -1,6 +1,8 @@ from dataclasses import dataclass from typing import Any, Dict +import numpy as np + from scaledp.utils.dataclass import map_dataclass_to_struct, register_type @@ -14,6 +16,7 @@ class Box: y: int width: int height: int + angle: float = 0.0 def to_string(self) -> "Box": self.text = str(self.text) @@ -34,6 +37,7 @@ def scale(self, factor: float, padding: int = 0) -> "Box": y=int(self.y * factor) - padding, width=int(self.width * factor) + padding, height=int(self.height * factor) + padding, + angle=self.angle, ) def shape(self, padding: int = 0) -> list[tuple[int, int]]: @@ -51,7 +55,7 @@ def bbox(self, padding: int = 0) -> list[int]: ] @staticmethod - def from_bbox(box: list[int], label: str = "", score: float = 0): + def from_bbox(box: list[int], angle: float = 0, label: str = "", score: float = 0): return Box( text=label, score=float(score), @@ -59,7 +63,98 @@ def from_bbox(box: list[int], label: str = "", score: float = 0): y=int(box[1]), width=int(box[2] - box[0]), height=int(box[3] - box[1]), + angle=angle, + ) + + @classmethod + def from_polygon( + cls, + polygon_points: list[tuple[float, float]], + text: str = "", + score: float = 1.0, + padding: int = 0, + ) -> "Box": + """ + Creates a Box instance from a list of polygon points (typically 4 for a rectangle). + Uses OpenCV's minAreaRect to find the rotated bounding box properties. + + Args: + polygon_points (list[tuple[float, float]]): A list of (x, y) coordinates + representing the vertices of the polygon. + Expected to be 4 points for a rectangle. + text (str): Optional text to assign to the box. Defaults to "". + score (float): Optional score to assign to the box. Defaults to 1.0. + + Returns: + Box: A new Box instance representing the minimum enclosing rotated rectangle. + + Raises: + ValueError: If the number of points is not 4. + """ + import cv2 + + if len(polygon_points) != 4: + # You might allow more points for convex hull, but for a strict 'Box' + # (which is a rectangle), 4 points are expected. + raise ValueError( + "from_polygon expects exactly 4 points for a rectangular box.", + ) + + # Convert list of tuples to a NumPy array for OpenCV + points_np = np.array(polygon_points, dtype=np.float32) + + # Get the minimum area rotated rectangle + (center_x, center_y), (raw_width, raw_height), angle_opencv = cv2.minAreaRect( + points_np, + ) + + # --- Normalize OpenCV's angle and dimensions to our Box convention --- + # Our convention: width is the horizontal dimension at 0 degrees, angle 0-360 positive + # CCW. + + box_width, box_height = raw_width, raw_height + box_angle = angle_opencv + + # If width is smaller than height, swap dimensions and adjust angle by 90 degrees. + # This makes 'width' conceptually the longer side or the side oriented towards 0/180 + # degrees. + if box_width < box_height: + box_width, box_height = box_height, box_width + box_angle -= 90.0 + + # Normalize angle to 0-360 range, ensuring positive counter-clockwise + # This handles negative angles from OpenCV and converts to our convention + box_angle = (box_angle % 360 + 360) % 360 + + if box_angle > 270: + box_angle -= 360 + + # --- Derive x, y (top-left of the unrotated box) --- + # The center is center_x, center_y + # The top-left of the unrotated box is center - (width/2, height/2) + # So x = center_x - width/2, y = center_y - height/2 + + x = int(round(center_x - box_width / 2.0)) + y = int(round(center_y - box_height / 2.0)) + + # Ensure dimensions are integers and positive + box_width_int = int(round(box_width)) + box_height_int = int(round(box_height)) + box_width_int = max(1, box_width_int) + box_height_int = max(1, box_height_int) + + return cls( + text=text, + score=score, + x=x - padding, + y=y - padding, + width=box_width_int + 2 * padding, + height=box_height_int + 2 * padding, + angle=box_angle, ) + def is_rotated(self) -> bool: + return abs(self.angle) >= 10 + register_type(Box, Box.get_schema) From d87df2c1967f7dde44ba0f1211fd10824a52cf07 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:04:33 +0200 Subject: [PATCH 02/13] Updated yolo detector --- scaledp/models/detectors/YoloDetector.py | 35 ++++++++++++++++++++---- 1 file changed, 29 insertions(+), 6 deletions(-) diff --git a/scaledp/models/detectors/YoloDetector.py b/scaledp/models/detectors/YoloDetector.py index 635d1b1..9b08dd0 100644 --- a/scaledp/models/detectors/YoloDetector.py +++ b/scaledp/models/detectors/YoloDetector.py @@ -4,7 +4,9 @@ from typing import Any from huggingface_hub import hf_hub_download +from huggingface_hub.errors import EntryNotFoundError from pyspark import keyword_only +from pyspark.ml.param import Param, Params, TypeConverters from scaledp.models.detectors.BaseDetector import BaseDetector from scaledp.params import HasBatchSize, HasDevice @@ -17,6 +19,13 @@ class YoloDetector(BaseDetector, HasDevice, HasBatchSize): _model = None + task = Param( + Params._dummy(), + "task", + "Yolo task type.", + typeConverter=TypeConverters.toString, + ) + defaultParams = MappingProxyType( { "inputCol": "image", @@ -31,6 +40,8 @@ class YoloDetector(BaseDetector, HasDevice, HasBatchSize): "pageCol": "page", "pathCol": "path", "propagateError": False, + "task": "detect", + "onlyRotated": False, }, ) @@ -49,12 +60,17 @@ def get_model(cls, params): model = params["model"] if not Path(model).is_file(): - model = hf_hub_download(repo_id=model, filename="best.pt") + try: + model = hf_hub_download(repo_id=model, filename="best.pt") + except EntryNotFoundError: + model = hf_hub_download(repo_id=model, filename="model.onnx") - detector = YOLO(model) + detector = YOLO(model, task=params["task"]) device = "cpu" if int(params["device"]) == Device.CPU.value else "cuda" - - cls._model = detector.to(device) + if "onnx" not in model: + cls._model = detector.to(device) + else: + cls._model = detector return cls._model @classmethod @@ -72,8 +88,15 @@ def call_detector(cls, images, params): results_final = [] for res, (_image, image_path) in zip(results, images): boxes = [] - for box in res.boxes: - boxes.append(Box.from_bbox(box.xyxy[0])) + + if params["task"] == "obb": + + for obb in res.obb: + xyxyxyxy = obb.xyxyxyxy.to("cpu").numpy().astype(int) + boxes.append(Box.from_polygon(xyxyxyxy.tolist()[0])) + else: + for box in res.boxes: + boxes.append(Box.from_bbox(box.xyxy[0])) results_final.append( DetectorOutput(path=image_path, type="yolo", bboxes=boxes), ) From eabc6278ba13486f36a74373a383477f5b01edfc Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:05:35 +0200 Subject: [PATCH 03/13] Updated yolo detector --- tests/models/detectors/test_yolo_detector.py | 91 +++++++++++--------- 1 file changed, 48 insertions(+), 43 deletions(-) diff --git a/tests/models/detectors/test_yolo_detector.py b/tests/models/detectors/test_yolo_detector.py index ad7b5d2..9b6e216 100644 --- a/tests/models/detectors/test_yolo_detector.py +++ b/tests/models/detectors/test_yolo_detector.py @@ -53,47 +53,52 @@ def test_yolo_detector_local_pipeline(receipt_file): # Temporarily replace the UserDefinedFunction pathSparkFunctions(pyspark) - # Initialize the pipeline stages - data_to_image = DataToImage() - detector = YoloDetector( - device=Device.CPU, - propagateError=True, - model="StabRise/receipt-detector-25-12-2024", - ) - draw = ImageDrawBoxes( - keepInputData=True, - inputCols=["image", "boxes"], - filled=False, - color="green", - lineWidth=5, - displayDataList=["score"], - ) - - # Create the pipeline - pipeline = PandasPipeline(stages=[data_to_image, detector, draw]) - - # Run the pipeline on the input image file - result = pipeline.fromFile(receipt_file) - - # Verify the pipeline result - assert result is not None - assert "image_with_boxes" in result.columns - assert "boxes" in result.columns - - # Verify the draw stage output - draw_result = result["image_with_boxes"][0] - assert draw_result.exception == "" - - # Verify the Detector stage output - bboxes = result["boxes"][0].bboxes - assert len(bboxes) > 0 - - # Save the output image to a temporary file for verification - with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp: - temp.write(draw_result.data) - temp.close() - - # Print the path to the temporary file - print("file://" + temp.name) - unpathSparkFunctions(pyspark) + try: + # Initialize the pipeline stages + data_to_image = DataToImage() + detector = YoloDetector( + device=Device.CPU, + propagateError=True, + keepInputData=True, + model="StabRise/receipt-detector-25-12-2024", + ) + draw = ImageDrawBoxes( + keepInputData=True, + inputCols=["image", "boxes"], + filled=False, + color="green", + lineWidth=5, + displayDataList=["score"], + ) + + # Create the pipeline + pipeline = PandasPipeline(stages=[data_to_image, detector, draw]) + + # Run the pipeline on the input image file + result = pipeline.fromFile(receipt_file) + + # Verify the pipeline result + assert result is not None + assert "image_with_boxes" in result.columns + assert "boxes" in result.columns + + # Verify the draw stage output + draw_result = result["image_with_boxes"][0] + assert draw_result.exception == "" + + # Verify the Detector stage output + bboxes = result["boxes"][0].bboxes + assert len(bboxes) > 0 + + # Save the output image to a temporary file for verification + with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp: + temp.write(draw_result.data) + temp.close() + + # Print the path to the temporary file + print("file://" + temp.name) + + finally: + # Clean up Spark functions + unpathSparkFunctions(pyspark) From 3f141778e7c8693f5405c43e4e687417b532feac Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:06:47 +0200 Subject: [PATCH 04/13] Added support multiple sources for ner models --- scaledp/models/ner/BaseNer.py | 15 +++++++++------ scaledp/models/ner/LLMNer.py | 2 +- scaledp/models/ner/Ner.py | 15 +++++++++++++-- scaledp/schemas/Document.py | 9 +++++++++ 4 files changed, 32 insertions(+), 9 deletions(-) diff --git a/scaledp/models/ner/BaseNer.py b/scaledp/models/ner/BaseNer.py index bd4fc15..aef66fd 100644 --- a/scaledp/models/ner/BaseNer.py +++ b/scaledp/models/ner/BaseNer.py @@ -17,7 +17,7 @@ HasColumnValidator, HasDefaultEnum, HasDevice, - HasInputCol, + HasInputCols, HasKeepInputData, HasModel, HasNumPartitions, @@ -33,7 +33,7 @@ class BaseNer( Transformer, - HasInputCol, + HasInputCols, HasOutputCol, HasKeepInputData, HasWhiteList, @@ -114,12 +114,15 @@ def get_params(self): def _transform(self, dataset): params = self.get_params() out_col = self.getOutputCol() - in_col = self._validate(self.getInputCol(), dataset) + for col in self.getInputCols(): + if col not in dataset.columns: + raise ValueError(f"Column {col} not found in dataset") + in_cols = [self._validate(col, dataset) for col in self.getInputCols()] if not self.getPartitionMap(): result = dataset.withColumn( out_col, - udf(self.transform_udf, NerOutput.get_schema())(in_col), + udf(self.transform_udf, NerOutput.get_schema())(*in_cols), ) else: if self.getNumPartitions() > 0: @@ -131,11 +134,11 @@ def _transform(self, dataset): result = dataset.withColumn( out_col, pandas_udf(self.transform_udf_pandas, self.outputSchema())( - in_col, + *in_cols, lit(params), ), ) if not self.getKeepInputData(): - result = result.drop(in_col) + result = result.drop(*in_cols) return result diff --git a/scaledp/models/ner/LLMNer.py b/scaledp/models/ner/LLMNer.py index 4cf5875..b7276b0 100644 --- a/scaledp/models/ner/LLMNer.py +++ b/scaledp/models/ner/LLMNer.py @@ -32,7 +32,7 @@ class LLMNer(BaseNer, HasLLM, HasPrompt, HasPropagateExc): defaultParams = MappingProxyType( { - "inputCol": "text", + "inputCols": ["text"], "outputCol": "ner", "keepInputData": True, "whiteList": [], diff --git a/scaledp/models/ner/Ner.py b/scaledp/models/ner/Ner.py index 919dcc9..0e52da7 100644 --- a/scaledp/models/ner/Ner.py +++ b/scaledp/models/ner/Ner.py @@ -6,6 +6,7 @@ from pyspark import keyword_only from scaledp.models.ner.BaseNer import BaseNer +from scaledp.schemas.Document import Document from scaledp.schemas.Entity import Entity from scaledp.schemas.NerOutput import NerOutput @@ -16,7 +17,7 @@ class Ner(BaseNer): defaultParams = MappingProxyType( { - "inputCol": "text", + "inputCols": ["text"], "outputCol": "ner", "keepInputData": True, "model": "d4data/biomedical-ner-all", @@ -81,9 +82,19 @@ def get_pipeline(self): ) return self.pipeline - def transform_udf(self, text): + def transform_udf(self, *documents: list[Document]): mapping = [] + typed_document = [] + if not isinstance(documents[0], Document): + for document in documents: + typed_document.append(Document(**document.asDict())) + else: + typed_document = documents + text = typed_document[0] + for t in typed_document[1:]: + text = text.merge(t) + for idx, box in enumerate(text.bboxes): mapping.extend([idx] * (len(box.text) + 1)) diff --git a/scaledp/schemas/Document.py b/scaledp/schemas/Document.py index afa7b02..2085fe6 100644 --- a/scaledp/schemas/Document.py +++ b/scaledp/schemas/Document.py @@ -17,5 +17,14 @@ class Document: def get_schema(): return map_dataclass_to_struct(Document) + def merge(self, document): + return Document( + path=document.path, + text=document.text + "\n" + self.text, + type=document.type, + bboxes=document.bboxes + self.bboxes, + exception=document.exception, + ) + register_type(Document, Document.get_schema) From d02f14533c5e01e858b23c3a8e939dd1b037cc60 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:07:47 +0200 Subject: [PATCH 05/13] Added yolo onnx detectors --- scaledp/models/detectors/YoloOnnxDetector.py | 95 ++++++++ .../models/detectors/YoloOnnxTextDetector.py | 218 ++++++++++++++++++ scaledp/models/detectors/yolo/yolo.py | 114 +++++++++ .../test_dbnet_onnx_text_detector.py | 59 +++++ .../detectors/test_yolo_onnx_detector.py | 50 ++++ 5 files changed, 536 insertions(+) create mode 100644 scaledp/models/detectors/YoloOnnxDetector.py create mode 100644 scaledp/models/detectors/YoloOnnxTextDetector.py create mode 100644 scaledp/models/detectors/yolo/yolo.py create mode 100644 tests/models/detectors/test_dbnet_onnx_text_detector.py create mode 100644 tests/models/detectors/test_yolo_onnx_detector.py diff --git a/scaledp/models/detectors/YoloOnnxDetector.py b/scaledp/models/detectors/YoloOnnxDetector.py new file mode 100644 index 0000000..aac0fcc --- /dev/null +++ b/scaledp/models/detectors/YoloOnnxDetector.py @@ -0,0 +1,95 @@ +import gc +import logging +from pathlib import Path +from types import MappingProxyType +from typing import Any + +import numpy as np +from huggingface_hub import hf_hub_download +from pyspark import keyword_only +from pyspark.ml.param import Param, Params, TypeConverters + +from scaledp.enums import Device +from scaledp.models.detectors.BaseDetector import BaseDetector +from scaledp.models.detectors.yolo.yolo import YOLO +from scaledp.params import HasBatchSize, HasDevice +from scaledp.schemas.Box import Box +from scaledp.schemas.DetectorOutput import DetectorOutput + + +class YoloOnnxDetector(BaseDetector, HasDevice, HasBatchSize): + _model = None + + task = Param( + Params._dummy(), + "task", + "Yolo task type.", + typeConverter=TypeConverters.toString, + ) + + defaultParams = MappingProxyType( + { + "inputCol": "image", + "outputCol": "boxes", + "keepInputData": False, + "scaleFactor": 1.0, + "scoreThreshold": 0.2, + "device": Device.CPU, + "batchSize": 2, + "partitionMap": False, + "numPartitions": 0, + "pageCol": "page", + "pathCol": "path", + "propagateError": False, + "task": "detect", + "onlyRotated": False, + }, + ) + + @keyword_only + def __init__(self, **kwargs: Any) -> None: + super(YoloOnnxDetector, self).__init__() + self._setDefault(**self.defaultParams) + self._set(**kwargs) + self.get_model({k.name: v for k, v in self.extractParamMap().items()}) + + @classmethod + def get_model(cls, params): + + logging.info("Loading model...") + if cls._model: + return cls._model + + model = params["model"] + if not Path(model).is_file(): + model = hf_hub_download(repo_id=model, filename="model.onnx") + + logging.info("Model downloaded") + + detector = YOLO(model, params["scoreThreshold"]) + + cls._model = detector + return cls._model + + @classmethod + def call_detector(cls, images, params): + logging.info("Running YoloOnnxDetector") + detector = cls.get_model(params) + + logging.info("Process images") + results_final = [] + for image, image_path in images: + boxes = [] + # Convert PIL to NumPy (RGB) + image_np = np.array(image) + raw_boxes, scores, class_ids = detector.detect_objects(image_np) + + for box in raw_boxes: + boxes.append(Box.from_bbox(box)) + results_final.append( + DetectorOutput(path=image_path, type="yolo", bboxes=boxes), + ) + + gc.collect() + + return results_final diff --git a/scaledp/models/detectors/YoloOnnxTextDetector.py b/scaledp/models/detectors/YoloOnnxTextDetector.py new file mode 100644 index 0000000..b889e5d --- /dev/null +++ b/scaledp/models/detectors/YoloOnnxTextDetector.py @@ -0,0 +1,218 @@ +import gc +import logging +from pathlib import Path +from types import MappingProxyType +from typing import Any + +import numpy as np +from huggingface_hub import hf_hub_download +from pyspark import keyword_only +from pyspark.ml.param import Param, Params, TypeConverters + +from scaledp.enums import Device +from scaledp.models.detectors.BaseDetector import BaseDetector +from scaledp.params import HasBatchSize, HasDevice +from scaledp.schemas.Box import Box +from scaledp.schemas.DetectorOutput import DetectorOutput + + +class YoloOnnxTextDetector(BaseDetector, HasDevice, HasBatchSize): + _model = None + + task = Param( + Params._dummy(), + "task", + "Yolo task type.", + typeConverter=TypeConverters.toString, + ) + + defaultParams = MappingProxyType( + { + "inputCol": "image", + "outputCol": "boxes", + "keepInputData": False, + "scaleFactor": 1.0, + "scoreThreshold": 0.2, + "device": Device.CPU, + "batchSize": 2, + "partitionMap": False, + "numPartitions": 0, + "pageCol": "page", + "pathCol": "path", + "propagateError": False, + "task": "detect", + "onlyRotated": False, + }, + ) + + @keyword_only + def __init__(self, **kwargs: Any) -> None: + super(YoloOnnxTextDetector, self).__init__() + self._setDefault(**self.defaultParams) + self._set(**kwargs) + self.get_model({k.name: v for k, v in self.extractParamMap().items()}) + + @classmethod + def get_model(cls, params): + + logging.info("Loading model...") + if cls._model: + return cls._model + + import onnxruntime as ort + + model = params["model"] + if not Path(model).is_file(): + model = hf_hub_download(repo_id=model, filename="model.onnx") + + logging.info("Model downloaded") + + detector = ort.InferenceSession(model, providers=["CPUExecutionProvider"]) + logging.info("Ort session created") + + cls._model = detector + return cls._model + + @classmethod + def obb_iou(cls, rect1, rect2): + import cv2 + + int_pts = cv2.rotatedRectangleIntersection(rect1, rect2)[1] + if int_pts is None: + return 0.0 + int_area = cv2.contourArea(int_pts) + area1 = rect1[1][0] * rect1[1][1] + area2 = rect2[1][0] * rect2[1][1] + union = area1 + area2 - int_area + return int_area / union if union > 0 else 0.0 + + @classmethod + def obb_nms(cls, boxes, iou_thresh=0.3): + # boxes: [N, 6] -> cx, cy, w, h, conf, angle + boxes = sorted(boxes, key=lambda x: x[4], reverse=True) # sort by confidence + keep = [] + + while boxes: + current = boxes.pop(0) + keep.append(current) + + current_rect = ( + (current[0], current[1]), + (current[2], current[3]), + np.degrees(current[5]), + ) + + remaining = [] + for box in boxes: + other_rect = ( + (box[0], box[1]), + (box[2], box[3]), + np.degrees(box[5]), + ) + iou = cls.obb_iou(current_rect, other_rect) + if iou < iou_thresh: + remaining.append(box) + boxes = remaining + + return np.array(keep) + + @classmethod + def call_detector(cls, images, params): + logging.info("Running YoloOnnxDetector") + import cv2 + + detector = cls.get_model(params) + + logging.info("Process images") + results_final = [] + for image, image_path in images: + boxes = [] + + # Convert PIL to NumPy (RGB) + image_np = np.array(image) + + # Convert RGB to BGR for OpenCV + image_rgb = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR) + + target_h = 960 + target_w = 960 + + scale = min(target_w / image_rgb.shape[1], target_h / image_rgb.shape[0]) + resize_h = int(image_rgb.shape[0] * scale) + resize_w = int(image_rgb.shape[1] * scale) + img = cv2.resize(image_rgb, (resize_w, resize_h)) + + if resize_h < target_h: + pad_bottom = target_h - resize_h + image_resized = cv2.copyMakeBorder( + img, + 0, + pad_bottom, + 0, + 0, + cv2.BORDER_CONSTANT, + value=(255, 255, 255), + ) + if resize_w < target_w: + pad_right = target_w - resize_w + image_resized = cv2.copyMakeBorder( + img, + 0, + 0, + 0, + pad_right, + cv2.BORDER_CONSTANT, + value=(255, 255, 255), + ) + ratio_h = ratio_w = scale + + # Preprocess + input_tensor = image_resized.astype(np.float32) / 255.0 # Normalize + input_tensor = np.transpose(input_tensor, (2, 0, 1)) # HWC -> CHW + input_tensor = np.expand_dims(input_tensor, axis=0) # Add batch dim + + input_name = detector.get_inputs()[0].name + + logging.info("Run ort inference") + + # Inference + outputs = detector.run(None, {input_name: input_tensor}) + + logging.info("Complete ort inference") + + raw = outputs[0].squeeze(0) # shape: (6, 8400) + + # Step 2: Transpose to (8400, 6) + output = raw.T # shape: (8400, 6) + + # Step 3: Confidence mask + mask = output[:, 4] > params["scoreThreshold"] + filtered = output[mask] + + nms_result = cls.obb_nms(filtered, iou_thresh=0.2) + + if params["task"] == "obb": + + for obb in nms_result: + cx, cy, bw, bh, conf, angle = obb + + # Scale to original image if needed (skip if already absolute) + angle_scaled = float( + np.degrees(angle), + ) # Convert radians to degrees + box = ((float(cx), float(cy)), (float(bw), float(bh)), angle_scaled) + points = cv2.boxPoints(box) + points[:, 0] *= ratio_w # x coordinates + points[:, 1] *= ratio_h # y coordinates + points = np.intp(points) + boxes.append(Box.from_polygon(points)) + else: + for box in nms_result: + boxes.append(Box.from_bbox(box.xyxy[0])) + results_final.append( + DetectorOutput(path=image_path, type="yolo", bboxes=boxes), + ) + + gc.collect() + + return results_final diff --git a/scaledp/models/detectors/yolo/yolo.py b/scaledp/models/detectors/yolo/yolo.py new file mode 100644 index 0000000..8eccabc --- /dev/null +++ b/scaledp/models/detectors/yolo/yolo.py @@ -0,0 +1,114 @@ +from typing import Any + +import cv2 +import numpy as np +import onnxruntime + +from scaledp.models.detectors.yolo.utils import multiclass_nms, xywh2xyxy + + +class YOLO: + + def __init__(self, path, conf_thres=0.7, iou_thres=0.5) -> None: + self.conf_threshold = conf_thres + self.iou_threshold = iou_thres + + # Initialize model + self.initialize_model(path) + + def __call__(self, image) -> Any: + return self.detect_objects(image) + + def initialize_model(self, path): + self.session = onnxruntime.InferenceSession( + path, providers=onnxruntime.get_available_providers() + ) + # Get model info + self.get_input_details() + self.get_output_details() + + def detect_objects(self, image): + input_tensor = self.prepare_input(image) + + # Perform inference on the image + outputs = self.inference(input_tensor) + + self.boxes, self.scores, self.class_ids = self.process_output(outputs) + + return self.boxes, self.scores, self.class_ids + + def prepare_input(self, image): + self.img_height, self.img_width = image.shape[:2] + + input_img = cv2.cvtColor(image, cv2.COLOR_BGR2RGB) + + # Resize input image + input_img = cv2.resize(input_img, (self.input_width, self.input_height)) + + # Scale input pixel values to 0 to 1 + input_img = input_img / 255.0 + input_img = input_img.transpose(2, 0, 1) + return input_img[np.newaxis, :, :, :].astype(np.float32) + + def inference(self, input_tensor): + return self.session.run(self.output_names, {self.input_names[0]: input_tensor}) + + def process_output(self, output): + predictions = np.squeeze(output[0]).T + + # Filter out object confidence scores below threshold + scores = np.max(predictions[:, 4:], axis=1) + predictions = predictions[scores > self.conf_threshold, :] + scores = scores[scores > self.conf_threshold] + + if len(scores) == 0: + return [], [], [] + + # Get the class with the highest confidence + class_ids = np.argmax(predictions[:, 4:], axis=1) + + # Get bounding boxes for each object + boxes = self.extract_boxes(predictions) + + # Apply non-maxima suppression to suppress weak, overlapping bounding boxes + indices = multiclass_nms(boxes, scores, class_ids, self.iou_threshold) + + return boxes[indices], scores[indices], class_ids[indices] + + def extract_boxes(self, predictions): + # Extract boxes from predictions + boxes = predictions[:, :4] + + # Scale boxes to original image dimensions + boxes = self.rescale_boxes(boxes) + + # Convert boxes to xyxy format + return xywh2xyxy(boxes) + + def rescale_boxes(self, boxes): + + # Rescale boxes to original image dimensions + input_shape = np.array( + [self.input_width, self.input_height, self.input_width, self.input_height] + ) + boxes = np.divide(boxes, input_shape, dtype=np.float32) + boxes *= np.array( + [self.img_width, self.img_height, self.img_width, self.img_height] + ) + return boxes + + def get_input_details(self): + model_inputs = self.session.get_inputs() + self.input_names = [model_inputs[i].name for i in range(len(model_inputs))] + + self.input_shape = model_inputs[0].shape + self.input_height = ( + self.input_shape[2] if self.input_shape[2] != "height" else 960 + ) + self.input_width = ( + self.input_shape[3] if self.input_shape[3] != "width" else 960 + ) + + def get_output_details(self): + model_outputs = self.session.get_outputs() + self.output_names = [model_outputs[i].name for i in range(len(model_outputs))] diff --git a/tests/models/detectors/test_dbnet_onnx_text_detector.py b/tests/models/detectors/test_dbnet_onnx_text_detector.py new file mode 100644 index 0000000..e33e6e1 --- /dev/null +++ b/tests/models/detectors/test_dbnet_onnx_text_detector.py @@ -0,0 +1,59 @@ +import tempfile + +from pyspark.ml import PipelineModel + +from scaledp import ( + ImageDrawBoxes, + TesseractRecognizer, +) +from scaledp.enums import TessLib +from scaledp.models.detectors.DBNetOnnxDetector import DBNetOnnxDetector + + +def test_dbnet_detector(image_rotated_df): + + detector = DBNetOnnxDetector( + model="StabRise/text_detection_dbnet_ml_v0.1", + keepInputData=True, + onlyRotated=True, + ) + + ocr = TesseractRecognizer( + inputCols=["image", "boxes"], + keepFormatting=False, + keepInputData=True, + tessLib=TessLib.PYTESSERACT, + lang=["eng", "spa"], + scoreThreshold=0.2, + scaleFactor=2.0, + partitionMap=True, + numPartitions=1, + ) + + draw = ImageDrawBoxes( + keepInputData=True, + inputCols=["image", "text"], + filled=False, + color="green", + lineWidth=5, + displayDataList=["score", "text", "angle"], + ) + # Transform the image dataframe through the OCR stage + pipeline = PipelineModel(stages=[detector, ocr, draw]) + result = pipeline.transform(image_rotated_df) + + data = result.collect() + + # Verify the pipeline result + assert len(data) == 1, "Expected exactly one result" + + # # Check that exceptions is empty + assert data[0].text.exception == "" + + # Save the output image to a temporary file for verification + with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp: + temp.write(data[0].image_with_boxes.data) + temp.close() + + # Print the path to the temporary file + print("file://" + temp.name) diff --git a/tests/models/detectors/test_yolo_onnx_detector.py b/tests/models/detectors/test_yolo_onnx_detector.py new file mode 100644 index 0000000..daba56c --- /dev/null +++ b/tests/models/detectors/test_yolo_onnx_detector.py @@ -0,0 +1,50 @@ +import tempfile + +from pyspark.ml import PipelineModel + +from scaledp import ( + ImageDrawBoxes, + YoloOnnxDetector, +) +from scaledp.enums import Device + + +def test_yolo_onnx_detector(image_qr_code_df): + + detector = YoloOnnxDetector( + device=Device.CPU, + keepInputData=True, + partitionMap=True, + numPartitions=0, + scoreThreshold=0.5, + task="detect", + model="StabRise/YOLO_QR_Code_Detection", + ) + + draw = ImageDrawBoxes( + keepInputData=True, + inputCols=["image", "boxes"], + filled=False, + color="green", + lineWidth=5, + displayDataList=["score", "angle"], + ) + # Transform the image dataframe through the OCR stage + pipeline = PipelineModel(stages=[detector, draw]) + result = pipeline.transform(image_qr_code_df) + + data = result.collect() + + # Verify the pipeline result + assert len(data) == 1, "Expected exactly one result" + + # # Check that exceptions is empty + assert data[0].boxes.exception == "" + + # Save the output image to a temporary file for verification + with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp: + temp.write(data[0].image_with_boxes.data) + temp.close() + + # Print the path to the temporary file + print("file://" + temp.name) From 0950b51be53cbba38a03a03dd953864cb1c21ac4 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:08:18 +0200 Subject: [PATCH 06/13] Updated tesseract recognizer --- .../models/recognizers/TesseractRecognizer.py | 124 +++++++++++++++++- 1 file changed, 120 insertions(+), 4 deletions(-) diff --git a/scaledp/models/recognizers/TesseractRecognizer.py b/scaledp/models/recognizers/TesseractRecognizer.py index ca330f1..a299a49 100644 --- a/scaledp/models/recognizers/TesseractRecognizer.py +++ b/scaledp/models/recognizers/TesseractRecognizer.py @@ -1,6 +1,8 @@ +import logging from types import MappingProxyType from typing import Any +import numpy as np from pyspark import keyword_only from pyspark.ml.param import Param, Params, TypeConverters @@ -64,10 +66,6 @@ def __init__(self, **kwargs: Any) -> None: self._setDefault(**self.defaultParams) self._set(**kwargs) - @classmethod - def call_pytesseract(cls, images, boxes, params): - raise NotImplementedError("Pytesseract version not implemented yet.") - @staticmethod def getLangTess(params): return "+".join( @@ -77,6 +75,124 @@ def getLangTess(params): ], ) + @classmethod + def _prepare_box_for_ocr(cls, image_np, box, params): + import cv2 + + # Ensure box is Box instance + if isinstance(box, dict): + box = Box(**box) + elif not isinstance(box, Box): + box = Box(**box.asDict()) + + scaled_box = box.scale(params["scaleFactor"], padding=5) + if scaled_box.angle == 90: + scaled_box.angle = -90 + + center_tuple = ( + scaled_box.x + scaled_box.width / 2, + scaled_box.y + scaled_box.height / 2, + ) + size_tuple = (scaled_box.width, scaled_box.height) + + rect = (center_tuple, size_tuple, scaled_box.angle) + src_pts = cv2.boxPoints(rect).astype("float32") + dst_pts = np.array( + [ + [0, int(scaled_box.height) - 1], + [0, 0], + [int(scaled_box.width) - 1, 0], + [int(scaled_box.width) - 1, int(scaled_box.height) - 1], + ], + dtype="float32", + ) + + try: + m_transform = cv2.getPerspectiveTransform(src_pts, dst_pts) + return cv2.warpPerspective( + image_np, + m_transform, + (int(scaled_box.width), int(scaled_box.height)), + flags=cv2.INTER_CUBIC, + borderMode=cv2.BORDER_REPLICATE, + ) + except cv2.error as e: + logging.error(f"Error processing box {box}: {e}") + return None + + @classmethod + def _convert_to_pil(cls, cropped_np): + import cv2 + from PIL import Image + + if cropped_np is None or cropped_np.size == 0: + return None + if cropped_np.ndim == 3: + if cropped_np.shape[2] == 4: + cropped_np = cv2.cvtColor(cropped_np, cv2.COLOR_RGBA2RGB) + elif cropped_np.shape[2] not in (3,): + cropped_np = cv2.cvtColor(cropped_np, cv2.COLOR_BGR2GRAY) + elif cropped_np.ndim != 2: + return None + return Image.fromarray(cropped_np) + + @classmethod + def _process_image_with_tesseract(cls, image, image_path, detected_boxes, params): + from tesserocr import PSM, PyTessBaseAPI + + boxes, texts = [], [] + image_np = np.array(image) + lang = cls.getLangTess(params) + + with PyTessBaseAPI( + path=params["tessDataPath"], + psm=PSM.SINGLE_WORD, + oem=params["oem"], + lang=lang, + ) as api: + api.SetVariable("debug_file", "ocr.log") + for box in detected_boxes.bboxes: + cropped_np = cls._prepare_box_for_ocr(image_np, box, params) + pil_image = cls._convert_to_pil(cropped_np) + if pil_image is None: + continue + + api.SetImage(pil_image) + api.Recognize(0) + b = box + if isinstance(box, dict): + b = Box(**b) + b.text = api.GetUTF8Text() + b.conf = api.MeanTextConf() + + if b.score > params["scoreThreshold"]: + boxes.append(b) + texts.append(b.text) + + if params["keepFormatting"]: + text = TesseractRecognizer.box_to_formatted_text( + boxes, + params["lineTolerance"], + ) + else: + text = " ".join(texts) + + return Document( + path=image_path, + text=text, + bboxes=boxes, + type="text", + exception="", + ) + + @classmethod + def call_pytesseract(cls, images, detected_boxes, params): # pragma: no cover + results = [] + for (image, image_path), boxes in zip(images, detected_boxes): + doc = cls._process_image_with_tesseract(image, image_path, boxes, params) + results.append(doc) + return results + @classmethod def call_tesserocr(cls, images, detected_boxes, params): # pragma: no cover from tesserocr import PyTessBaseAPI From e8221fc846103b63799599a918469f99f84aa9b1 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:12:03 +0200 Subject: [PATCH 07/13] Updated DocTRTextDetector.py --- scaledp/models/detectors/DocTRTextDetector.py | 1 + 1 file changed, 1 insertion(+) diff --git a/scaledp/models/detectors/DocTRTextDetector.py b/scaledp/models/detectors/DocTRTextDetector.py index f51d9a1..0145ef6 100644 --- a/scaledp/models/detectors/DocTRTextDetector.py +++ b/scaledp/models/detectors/DocTRTextDetector.py @@ -30,6 +30,7 @@ class DocTRTextDetector(BaseDetector, HasDevice, HasBatchSize): "pageCol": "page", "pathCol": "path", "propagateError": False, + "onlyRotated": False, }, ) From 567e9932be42e861764618e3470096ab74b1f43d Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:41:06 +0200 Subject: [PATCH 08/13] Lot updates --- Dockerfile | 2 +- poetry.lock | 2619 ++--------------- pyproject.toml | 2 +- scaledp/__init__.py | 2 + scaledp/image/DataToImage.py | 2 +- scaledp/models/detectors/BaseDetector.py | 13 +- scaledp/models/detectors/CraftTextDetector.py | 281 ++ scaledp/models/detectors/DBNetOnnxDetector.py | 97 + scaledp/models/detectors/FastTextDetector.py | 124 + scaledp/models/detectors/craft/__init__.py | 0 scaledp/models/detectors/craft/models.py | 28 + .../models/detectors/paddle_onnx/__init__.py | 0 .../detectors/paddle_onnx/db_postprocess.py | 275 ++ scaledp/models/detectors/paddle_onnx/imaug.py | 36 + .../models/detectors/paddle_onnx/operators.py | 199 ++ .../detectors/paddle_onnx/predict_base.py | 58 + .../detectors/paddle_onnx/predict_det.py | 122 + scaledp/models/detectors/yolo/__init__.py | 0 scaledp/models/detectors/yolo/utils.py | 70 + scaledp/models/recognizers/BaseOcr.py | 2 +- scaledp/pdf/PdfDataToDocument.py | 58 +- scaledp/pdf/PdfDataToImage.py | 26 +- scaledp/pdf/SingleImageToPdf.py | 13 +- scaledp/pipeline/PandasPipeline.py | 54 +- scaledp/schemas/Image.py | 13 + tests/conftest.py | 42 + .../detectors/test_craft_text_detector.py | 111 + tests/models/ner/test_ner.py | 50 +- tests/pdf/test_pdf_data_to_document.py | 15 +- tests/pdf/test_pdf_data_to_image.py | 43 + tests/pipeline/test_pipeline.py | 46 +- tests/pytest.ini | 4 + tests/testresources/images/QrCode.png | Bin 0 -> 54391 bytes 33 files changed, 1956 insertions(+), 2451 deletions(-) create mode 100644 scaledp/models/detectors/CraftTextDetector.py create mode 100644 scaledp/models/detectors/DBNetOnnxDetector.py create mode 100644 scaledp/models/detectors/FastTextDetector.py create mode 100644 scaledp/models/detectors/craft/__init__.py create mode 100644 scaledp/models/detectors/craft/models.py create mode 100644 scaledp/models/detectors/paddle_onnx/__init__.py create mode 100644 scaledp/models/detectors/paddle_onnx/db_postprocess.py create mode 100644 scaledp/models/detectors/paddle_onnx/imaug.py create mode 100644 scaledp/models/detectors/paddle_onnx/operators.py create mode 100644 scaledp/models/detectors/paddle_onnx/predict_base.py create mode 100644 scaledp/models/detectors/paddle_onnx/predict_det.py create mode 100644 scaledp/models/detectors/yolo/__init__.py create mode 100644 scaledp/models/detectors/yolo/utils.py create mode 100644 tests/models/detectors/test_craft_text_detector.py create mode 100644 tests/pytest.ini create mode 100644 tests/testresources/images/QrCode.png diff --git a/Dockerfile b/Dockerfile index b2d3b0f..9ffa381 100644 --- a/Dockerfile +++ b/Dockerfile @@ -8,7 +8,7 @@ RUN mkdir -p /etc/apt/sources.list.d RUN mv wtf-bookworm.sources /etc/apt/sources.list.d/ RUN apt-get update && apt-get install --no-install-recommends --yes \ - tesseract-ocr openjdk-8-jdk + tesseract-ocr tesseract-ocr-spa openjdk-8-jdk EXPOSE 8888 diff --git a/poetry.lock b/poetry.lock index 908b0ee..7c8778a 100644 --- a/poetry.lock +++ b/poetry.lock @@ -1,160 +1,5 @@ # This file is automatically @generated by Poetry 2.1.3 and should not be changed by hand. -[[package]] -name = "aiohappyeyeballs" -version = "2.6.1" -description = "Happy Eyeballs for asyncio" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "aiohappyeyeballs-2.6.1-py3-none-any.whl", hash = "sha256:f349ba8f4b75cb25c99c5c2d84e997e485204d2902a9597802b0371f09331fb8"}, - {file = "aiohappyeyeballs-2.6.1.tar.gz", hash = "sha256:c3f9d0113123803ccadfdf3f0faa505bc78e6a72d1cc4806cbd719826e943558"}, -] - -[[package]] -name = "aiohttp" -version = "3.11.16" -description = "Async http client/server framework (asyncio)" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "aiohttp-3.11.16-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:fb46bb0f24813e6cede6cc07b1961d4b04f331f7112a23b5e21f567da4ee50aa"}, - {file = "aiohttp-3.11.16-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:54eb3aead72a5c19fad07219acd882c1643a1027fbcdefac9b502c267242f955"}, - {file = "aiohttp-3.11.16-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:38bea84ee4fe24ebcc8edeb7b54bf20f06fd53ce4d2cc8b74344c5b9620597fd"}, - {file = "aiohttp-3.11.16-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0666afbe984f6933fe72cd1f1c3560d8c55880a0bdd728ad774006eb4241ecd"}, - {file = "aiohttp-3.11.16-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7ba92a2d9ace559a0a14b03d87f47e021e4fa7681dc6970ebbc7b447c7d4b7cd"}, - {file = "aiohttp-3.11.16-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3ad1d59fd7114e6a08c4814983bb498f391c699f3c78712770077518cae63ff7"}, - {file = "aiohttp-3.11.16-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b88a2bf26965f2015a771381624dd4b0839034b70d406dc74fd8be4cc053e3"}, - {file = "aiohttp-3.11.16-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:576f5ca28d1b3276026f7df3ec841ae460e0fc3aac2a47cbf72eabcfc0f102e1"}, - {file = "aiohttp-3.11.16-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a2a450bcce4931b295fc0848f384834c3f9b00edfc2150baafb4488c27953de6"}, - {file = "aiohttp-3.11.16-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:37dcee4906454ae377be5937ab2a66a9a88377b11dd7c072df7a7c142b63c37c"}, - {file = "aiohttp-3.11.16-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4d0c970c0d602b1017e2067ff3b7dac41c98fef4f7472ec2ea26fd8a4e8c2149"}, - {file = "aiohttp-3.11.16-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:004511d3413737700835e949433536a2fe95a7d0297edd911a1e9705c5b5ea43"}, - {file = "aiohttp-3.11.16-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:c15b2271c44da77ee9d822552201180779e5e942f3a71fb74e026bf6172ff287"}, - {file = "aiohttp-3.11.16-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ad9509ffb2396483ceacb1eee9134724443ee45b92141105a4645857244aecc8"}, - {file = "aiohttp-3.11.16-cp310-cp310-win32.whl", hash = "sha256:634d96869be6c4dc232fc503e03e40c42d32cfaa51712aee181e922e61d74814"}, - {file = "aiohttp-3.11.16-cp310-cp310-win_amd64.whl", hash = "sha256:938f756c2b9374bbcc262a37eea521d8a0e6458162f2a9c26329cc87fdf06534"}, - {file = "aiohttp-3.11.16-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:8cb0688a8d81c63d716e867d59a9ccc389e97ac7037ebef904c2b89334407180"}, - {file = "aiohttp-3.11.16-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0ad1fb47da60ae1ddfb316f0ff16d1f3b8e844d1a1e154641928ea0583d486ed"}, - {file = "aiohttp-3.11.16-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:df7db76400bf46ec6a0a73192b14c8295bdb9812053f4fe53f4e789f3ea66bbb"}, - {file = "aiohttp-3.11.16-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc3a145479a76ad0ed646434d09216d33d08eef0d8c9a11f5ae5cdc37caa3540"}, - {file = "aiohttp-3.11.16-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d007aa39a52d62373bd23428ba4a2546eed0e7643d7bf2e41ddcefd54519842c"}, - {file = "aiohttp-3.11.16-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f6ddd90d9fb4b501c97a4458f1c1720e42432c26cb76d28177c5b5ad4e332601"}, - {file = "aiohttp-3.11.16-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0a2f451849e6b39e5c226803dcacfa9c7133e9825dcefd2f4e837a2ec5a3bb98"}, - {file = "aiohttp-3.11.16-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8df6612df74409080575dca38a5237282865408016e65636a76a2eb9348c2567"}, - {file = "aiohttp-3.11.16-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:78e6e23b954644737e385befa0deb20233e2dfddf95dd11e9db752bdd2a294d3"}, - {file = "aiohttp-3.11.16-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:696ef00e8a1f0cec5e30640e64eca75d8e777933d1438f4facc9c0cdf288a810"}, - {file = "aiohttp-3.11.16-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e3538bc9fe1b902bef51372462e3d7c96fce2b566642512138a480b7adc9d508"}, - {file = "aiohttp-3.11.16-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:3ab3367bb7f61ad18793fea2ef71f2d181c528c87948638366bf1de26e239183"}, - {file = "aiohttp-3.11.16-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:56a3443aca82abda0e07be2e1ecb76a050714faf2be84256dae291182ba59049"}, - {file = "aiohttp-3.11.16-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:61c721764e41af907c9d16b6daa05a458f066015abd35923051be8705108ed17"}, - {file = "aiohttp-3.11.16-cp311-cp311-win32.whl", hash = "sha256:3e061b09f6fa42997cf627307f220315e313ece74907d35776ec4373ed718b86"}, - {file = "aiohttp-3.11.16-cp311-cp311-win_amd64.whl", hash = "sha256:745f1ed5e2c687baefc3c5e7b4304e91bf3e2f32834d07baaee243e349624b24"}, - {file = "aiohttp-3.11.16-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:911a6e91d08bb2c72938bc17f0a2d97864c531536b7832abee6429d5296e5b27"}, - {file = "aiohttp-3.11.16-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:6ac13b71761e49d5f9e4d05d33683bbafef753e876e8e5a7ef26e937dd766713"}, - {file = "aiohttp-3.11.16-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:fd36c119c5d6551bce374fcb5c19269638f8d09862445f85a5a48596fd59f4bb"}, - {file = "aiohttp-3.11.16-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d489d9778522fbd0f8d6a5c6e48e3514f11be81cb0a5954bdda06f7e1594b321"}, - {file = "aiohttp-3.11.16-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:69a2cbd61788d26f8f1e626e188044834f37f6ae3f937bd9f08b65fc9d7e514e"}, - {file = "aiohttp-3.11.16-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cd464ba806e27ee24a91362ba3621bfc39dbbb8b79f2e1340201615197370f7c"}, - {file = "aiohttp-3.11.16-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ce63ae04719513dd2651202352a2beb9f67f55cb8490c40f056cea3c5c355ce"}, - {file = "aiohttp-3.11.16-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:09b00dd520d88eac9d1768439a59ab3d145065c91a8fab97f900d1b5f802895e"}, - {file = "aiohttp-3.11.16-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:7f6428fee52d2bcf96a8aa7b62095b190ee341ab0e6b1bcf50c615d7966fd45b"}, - {file = "aiohttp-3.11.16-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:13ceac2c5cdcc3f64b9015710221ddf81c900c5febc505dbd8f810e770011540"}, - {file = "aiohttp-3.11.16-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:fadbb8f1d4140825069db3fedbbb843290fd5f5bc0a5dbd7eaf81d91bf1b003b"}, - {file = "aiohttp-3.11.16-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6a792ce34b999fbe04a7a71a90c74f10c57ae4c51f65461a411faa70e154154e"}, - {file = "aiohttp-3.11.16-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:f4065145bf69de124accdd17ea5f4dc770da0a6a6e440c53f6e0a8c27b3e635c"}, - {file = "aiohttp-3.11.16-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fa73e8c2656a3653ae6c307b3f4e878a21f87859a9afab228280ddccd7369d71"}, - {file = "aiohttp-3.11.16-cp312-cp312-win32.whl", hash = "sha256:f244b8e541f414664889e2c87cac11a07b918cb4b540c36f7ada7bfa76571ea2"}, - {file = "aiohttp-3.11.16-cp312-cp312-win_amd64.whl", hash = "sha256:23a15727fbfccab973343b6d1b7181bfb0b4aa7ae280f36fd2f90f5476805682"}, - {file = "aiohttp-3.11.16-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:a3814760a1a700f3cfd2f977249f1032301d0a12c92aba74605cfa6ce9f78489"}, - {file = "aiohttp-3.11.16-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:9b751a6306f330801665ae69270a8a3993654a85569b3469662efaad6cf5cc50"}, - {file = "aiohttp-3.11.16-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:ad497f38a0d6c329cb621774788583ee12321863cd4bd9feee1effd60f2ad133"}, - {file = "aiohttp-3.11.16-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca37057625693d097543bd88076ceebeb248291df9d6ca8481349efc0b05dcd0"}, - {file = "aiohttp-3.11.16-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a5abcbba9f4b463a45c8ca8b7720891200658f6f46894f79517e6cd11f3405ca"}, - {file = "aiohttp-3.11.16-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f420bfe862fb357a6d76f2065447ef6f484bc489292ac91e29bc65d2d7a2c84d"}, - {file = "aiohttp-3.11.16-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58ede86453a6cf2d6ce40ef0ca15481677a66950e73b0a788917916f7e35a0bb"}, - {file = "aiohttp-3.11.16-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6fdec0213244c39973674ca2a7f5435bf74369e7d4e104d6c7473c81c9bcc8c4"}, - {file = "aiohttp-3.11.16-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:72b1b03fb4655c1960403c131740755ec19c5898c82abd3961c364c2afd59fe7"}, - {file = "aiohttp-3.11.16-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:780df0d837276276226a1ff803f8d0fa5f8996c479aeef52eb040179f3156cbd"}, - {file = "aiohttp-3.11.16-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ecdb8173e6c7aa09eee342ac62e193e6904923bd232e76b4157ac0bfa670609f"}, - {file = "aiohttp-3.11.16-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:a6db7458ab89c7d80bc1f4e930cc9df6edee2200127cfa6f6e080cf619eddfbd"}, - {file = "aiohttp-3.11.16-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:2540ddc83cc724b13d1838026f6a5ad178510953302a49e6d647f6e1de82bc34"}, - {file = "aiohttp-3.11.16-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3b4e6db8dc4879015b9955778cfb9881897339c8fab7b3676f8433f849425913"}, - {file = "aiohttp-3.11.16-cp313-cp313-win32.whl", hash = "sha256:493910ceb2764f792db4dc6e8e4b375dae1b08f72e18e8f10f18b34ca17d0979"}, - {file = "aiohttp-3.11.16-cp313-cp313-win_amd64.whl", hash = "sha256:42864e70a248f5f6a49fdaf417d9bc62d6e4d8ee9695b24c5916cb4bb666c802"}, - {file = "aiohttp-3.11.16-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:bbcba75fe879ad6fd2e0d6a8d937f34a571f116a0e4db37df8079e738ea95c71"}, - {file = "aiohttp-3.11.16-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:87a6e922b2b2401e0b0cf6b976b97f11ec7f136bfed445e16384fbf6fd5e8602"}, - {file = "aiohttp-3.11.16-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ccf10f16ab498d20e28bc2b5c1306e9c1512f2840f7b6a67000a517a4b37d5ee"}, - {file = "aiohttp-3.11.16-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb3d0cc5cdb926090748ea60172fa8a213cec728bd6c54eae18b96040fcd6227"}, - {file = "aiohttp-3.11.16-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d07502cc14ecd64f52b2a74ebbc106893d9a9717120057ea9ea1fd6568a747e7"}, - {file = "aiohttp-3.11.16-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:776c8e959a01e5e8321f1dec77964cb6101020a69d5a94cd3d34db6d555e01f7"}, - {file = "aiohttp-3.11.16-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0902e887b0e1d50424112f200eb9ae3dfed6c0d0a19fc60f633ae5a57c809656"}, - {file = "aiohttp-3.11.16-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e87fd812899aa78252866ae03a048e77bd11b80fb4878ce27c23cade239b42b2"}, - {file = "aiohttp-3.11.16-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:0a950c2eb8ff17361abd8c85987fd6076d9f47d040ebffce67dce4993285e973"}, - {file = "aiohttp-3.11.16-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:c10d85e81d0b9ef87970ecbdbfaeec14a361a7fa947118817fcea8e45335fa46"}, - {file = "aiohttp-3.11.16-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:7951decace76a9271a1ef181b04aa77d3cc309a02a51d73826039003210bdc86"}, - {file = "aiohttp-3.11.16-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:14461157d8426bcb40bd94deb0450a6fa16f05129f7da546090cebf8f3123b0f"}, - {file = "aiohttp-3.11.16-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:9756d9b9d4547e091f99d554fbba0d2a920aab98caa82a8fb3d3d9bee3c9ae85"}, - {file = "aiohttp-3.11.16-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:87944bd16b7fe6160607f6a17808abd25f17f61ae1e26c47a491b970fb66d8cb"}, - {file = "aiohttp-3.11.16-cp39-cp39-win32.whl", hash = "sha256:92b7ee222e2b903e0a4b329a9943d432b3767f2d5029dbe4ca59fb75223bbe2e"}, - {file = "aiohttp-3.11.16-cp39-cp39-win_amd64.whl", hash = "sha256:17ae4664031aadfbcb34fd40ffd90976671fa0c0286e6c4113989f78bebab37a"}, - {file = "aiohttp-3.11.16.tar.gz", hash = "sha256:16f8a2c9538c14a557b4d309ed4d0a7c60f0253e8ed7b6c9a2859a7582f8b1b8"}, -] - -[package.dependencies] -aiohappyeyeballs = ">=2.3.0" -aiosignal = ">=1.1.2" -async-timeout = {version = ">=4.0,<6.0", markers = "python_version < \"3.11\""} -attrs = ">=17.3.0" -frozenlist = ">=1.1.1" -multidict = ">=4.5,<7.0" -propcache = ">=0.2.0" -yarl = ">=1.17.0,<2.0" - -[package.extras] -speedups = ["Brotli ; platform_python_implementation == \"CPython\"", "aiodns (>=3.2.0) ; sys_platform == \"linux\" or sys_platform == \"darwin\"", "brotlicffi ; platform_python_implementation != \"CPython\""] - -[[package]] -name = "aiosignal" -version = "1.3.2" -description = "aiosignal: a list of registered asynchronous callbacks" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "aiosignal-1.3.2-py2.py3-none-any.whl", hash = "sha256:45cde58e409a301715980c2b01d0c28bdde3770d8290b5eb2173759d9acb31a5"}, - {file = "aiosignal-1.3.2.tar.gz", hash = "sha256:a8c255c66fafb1e499c9351d0bf32ff2d8a0321595ebac3b93713656d2436f54"}, -] - -[package.dependencies] -frozenlist = ">=1.1.0" - -[[package]] -name = "alembic" -version = "1.15.2" -description = "A database migration tool for SQLAlchemy." -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "alembic-1.15.2-py3-none-any.whl", hash = "sha256:2e76bd916d547f6900ec4bb5a90aeac1485d2c92536923d0b138c02b126edc53"}, - {file = "alembic-1.15.2.tar.gz", hash = "sha256:1c72391bbdeffccfe317eefba686cb9a3c078005478885413b95c3b26c57a8a7"}, -] - -[package.dependencies] -Mako = "*" -SQLAlchemy = ">=1.4.0" -typing-extensions = ">=4.12" - -[package.extras] -tz = ["tzdata"] - [[package]] name = "annotated-types" version = "0.7.0" @@ -215,35 +60,6 @@ files = [ {file = "appnope-0.1.4.tar.gz", hash = "sha256:1de3860566df9caf38f01f86f65e0e13e379af54f9e4bee1e66b48f2efffd1ee"}, ] -[[package]] -name = "apscheduler" -version = "3.11.0" -description = "In-process task scheduler with Cron-like capabilities" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "APScheduler-3.11.0-py3-none-any.whl", hash = "sha256:fc134ca32e50f5eadcc4938e3a4545ab19131435e851abb40b34d63d5141c6da"}, - {file = "apscheduler-3.11.0.tar.gz", hash = "sha256:4c622d250b0955a65d5d0eb91c33e6d43fd879834bf541e0a18661ae60460133"}, -] - -[package.dependencies] -tzlocal = ">=3.0" - -[package.extras] -doc = ["packaging", "sphinx", "sphinx-rtd-theme (>=1.3.0)"] -etcd = ["etcd3", "protobuf (<=3.21.0)"] -gevent = ["gevent"] -mongodb = ["pymongo (>=3.0)"] -redis = ["redis (>=3.0)"] -rethinkdb = ["rethinkdb (>=2.4.0)"] -sqlalchemy = ["sqlalchemy (>=1.4)"] -test = ["APScheduler[etcd,mongodb,redis,rethinkdb,sqlalchemy,tornado,zookeeper]", "PySide6 ; platform_python_implementation == \"CPython\" and python_version < \"3.14\"", "anyio (>=4.5.2)", "gevent ; python_version < \"3.14\"", "pytest", "pytz", "twisted ; python_version < \"3.14\""] -tornado = ["tornado (>=4.3)"] -twisted = ["twisted"] -zookeeper = ["kazoo"] - [[package]] name = "argon2-cffi" version = "23.1.0" @@ -354,47 +170,17 @@ files = [ [package.dependencies] typing_extensions = {version = ">=4.0.0", markers = "python_version < \"3.11\""} -[[package]] -name = "async-timeout" -version = "5.0.1" -description = "Timeout context manager for asyncio programs" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "python_full_version < \"3.11.3\" and extra == \"llm\"" -files = [ - {file = "async_timeout-5.0.1-py3-none-any.whl", hash = "sha256:39e3809566ff85354557ec2398b55e096c8364bacac9405a7a1fa429e77fe76c"}, - {file = "async_timeout-5.0.1.tar.gz", hash = "sha256:d9321a7a3d5a6a5e187e824d2fa0793ce379a202935782d555d6e9d2735677d3"}, -] - -[[package]] -name = "asyncer" -version = "0.0.8" -description = "Asyncer, async and await, focused on developer experience." -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "asyncer-0.0.8-py3-none-any.whl", hash = "sha256:5920d48fc99c8f8f0f1576e1882f5022885589c5fcbc46ce4224ec3e53776eeb"}, - {file = "asyncer-0.0.8.tar.gz", hash = "sha256:a589d980f57e20efb07ed91d0dbe67f1d2fd343e7142c66d3a099f05c620739c"}, -] - -[package.dependencies] -anyio = ">=3.4.0,<5.0" - [[package]] name = "attrs" version = "25.3.0" description = "Classes Without Boilerplate" optional = false python-versions = ">=3.8" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "attrs-25.3.0-py3-none-any.whl", hash = "sha256:427318ce031701fea540783410126f03899a97ffc6f61596ad581ac2e40e3bc3"}, {file = "attrs-25.3.0.tar.gz", hash = "sha256:75d7cefc7fb576747b2c81b4442d4d4a1ce0900973527c011d1030fd3bf4af1b"}, ] -markers = {main = "extra == \"llm\""} [package.extras] benchmark = ["cloudpickle ; platform_python_implementation == \"CPython\"", "hypothesis", "mypy (>=1.11.1) ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pympler", "pytest (>=4.3.0)", "pytest-codspeed", "pytest-mypy-plugins ; platform_python_implementation == \"CPython\" and python_version >= \"3.10\"", "pytest-xdist[psutil]"] @@ -419,19 +205,6 @@ files = [ [package.extras] dev = ["backports.zoneinfo ; python_version < \"3.9\"", "freezegun (>=1.0,<2.0)", "jinja2 (>=3.0)", "pytest (>=6.0)", "pytest-cov", "pytz", "setuptools", "tzdata ; sys_platform == \"win32\""] -[[package]] -name = "backoff" -version = "2.2.1" -description = "Function decoration for backoff and retry" -optional = true -python-versions = ">=3.7,<4.0" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "backoff-2.2.1-py3-none-any.whl", hash = "sha256:63579f9a0628e06278f7e47b7d7d5b6ce20dc65c5e96a6f3ca99a6adca0396e8"}, - {file = "backoff-2.2.1.tar.gz", hash = "sha256:03f829f5bb1923180821643f8753b0502c3b682293992485b0eef2807afa5cba"}, -] - [[package]] name = "beautifulsoup4" version = "4.13.3" @@ -521,19 +294,6 @@ webencodings = "*" [package.extras] css = ["tinycss2 (>=1.1.0,<1.5)"] -[[package]] -name = "cachetools" -version = "5.5.2" -description = "Extensible memoizing collections and decorators" -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "cachetools-5.5.2-py3-none-any.whl", hash = "sha256:d26a22bcc62eb95c3beabd9f1ee5e820d3d2704fe2967cbe350e20c8ffcd3f0a"}, - {file = "cachetools-5.5.2.tar.gz", hash = "sha256:1a661caa9175d26759571b2e19580f9d6393969e5dfca11fdb1f947a23e640d4"}, -] - [[package]] name = "certifi" version = "2025.1.31" @@ -552,7 +312,7 @@ version = "1.17.1" description = "Foreign Function Interface for Python calling C code." optional = false python-versions = ">=3.8" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14"}, {file = "cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67"}, @@ -622,7 +382,6 @@ files = [ {file = "cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662"}, {file = "cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824"}, ] -markers = {main = "extra == \"llm\""} [package.dependencies] pycparser = "*" @@ -747,29 +506,15 @@ version = "8.1.8" description = "Composable command line interface toolkit" optional = false python-versions = ">=3.7" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2"}, {file = "click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a"}, ] -markers = {main = "extra == \"llm\""} [package.dependencies] colorama = {version = "*", markers = "platform_system == \"Windows\""} -[[package]] -name = "cloudpickle" -version = "3.1.1" -description = "Pickler class to extend the standard pickle.Pickler functionality" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "cloudpickle-3.1.1-py3-none-any.whl", hash = "sha256:c8c5a44295039331ee9dad40ba100a9c7297b6f988e50e87ccdf3765a668350e"}, - {file = "cloudpickle-3.1.1.tar.gz", hash = "sha256:b216fa8ae4019d5482a8ac3c95d8f6346115d8835911fd4aefd1a445e4242c64"}, -] - [[package]] name = "colorama" version = "0.4.6" @@ -784,23 +529,22 @@ files = [ markers = {main = "sys_platform == \"win32\" or platform_system == \"Windows\""} [[package]] -name = "colorlog" -version = "6.9.0" -description = "Add colours to the output of Python's logging module." -optional = true -python-versions = ">=3.6" +name = "coloredlogs" +version = "15.0.1" +description = "Colored terminal output for Python's logging module" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" groups = ["main"] -markers = "extra == \"llm\"" files = [ - {file = "colorlog-6.9.0-py3-none-any.whl", hash = "sha256:5906e71acd67cb07a71e779c47c4bcb45fb8c2993eebe9e5adcd6a6f1b283eff"}, - {file = "colorlog-6.9.0.tar.gz", hash = "sha256:bfba54a1b93b94f54e1f4fe48395725a3d92fd2a4af702f6bd70946bdc0c6ac2"}, + {file = "coloredlogs-15.0.1-py2.py3-none-any.whl", hash = "sha256:612ee75c546f53e92e70049c9dbfcc18c935a2b9a53b66085ce9ef6a6e5c0934"}, + {file = "coloredlogs-15.0.1.tar.gz", hash = "sha256:7c991aa71a4577af2f82600d8f8f3a89f936baeaf9b50a9c197da014e5bf16b0"}, ] [package.dependencies] -colorama = {version = "*", markers = "sys_platform == \"win32\""} +humanfriendly = ">=9.1" [package.extras] -development = ["black", "flake8", "mypy", "pytest", "types-colorama"] +cron = ["capturer (>=2.4)"] [[package]] name = "comm" @@ -973,60 +717,23 @@ tomli = {version = "*", optional = true, markers = "python_full_version <= \"3.1 toml = ["tomli ; python_full_version <= \"3.11.0a6\""] [[package]] -name = "cryptography" -version = "42.0.8" -description = "cryptography is a package which provides cryptographic recipes and primitives to Python developers." -optional = true +name = "craft-text-detector-updated" +version = "0.4.7" +description = "Fast and accurate text detection library built on CRAFT implementation" +optional = false python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "cryptography-42.0.8-cp37-abi3-macosx_10_12_universal2.whl", hash = "sha256:81d8a521705787afe7a18d5bfb47ea9d9cc068206270aad0b96a725022e18d2e"}, - {file = "cryptography-42.0.8-cp37-abi3-macosx_10_12_x86_64.whl", hash = "sha256:961e61cefdcb06e0c6d7e3a1b22ebe8b996eb2bf50614e89384be54c48c6b63d"}, - {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e3ec3672626e1b9e55afd0df6d774ff0e953452886e06e0f1eb7eb0c832e8902"}, - {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e599b53fd95357d92304510fb7bda8523ed1f79ca98dce2f43c115950aa78801"}, - {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:5226d5d21ab681f432a9c1cf8b658c0cb02533eece706b155e5fbd8a0cdd3949"}, - {file = "cryptography-42.0.8-cp37-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:6b7c4f03ce01afd3b76cf69a5455caa9cfa3de8c8f493e0d3ab7d20611c8dae9"}, - {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:2346b911eb349ab547076f47f2e035fc8ff2c02380a7cbbf8d87114fa0f1c583"}, - {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:ad803773e9df0b92e0a817d22fd8a3675493f690b96130a5e24f1b8fabbea9c7"}, - {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:2f66d9cd9147ee495a8374a45ca445819f8929a3efcd2e3df6428e46c3cbb10b"}, - {file = "cryptography-42.0.8-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:d45b940883a03e19e944456a558b67a41160e367a719833c53de6911cabba2b7"}, - {file = "cryptography-42.0.8-cp37-abi3-win32.whl", hash = "sha256:a0c5b2b0585b6af82d7e385f55a8bc568abff8923af147ee3c07bd8b42cda8b2"}, - {file = "cryptography-42.0.8-cp37-abi3-win_amd64.whl", hash = "sha256:57080dee41209e556a9a4ce60d229244f7a66ef52750f813bfbe18959770cfba"}, - {file = "cryptography-42.0.8-cp39-abi3-macosx_10_12_universal2.whl", hash = "sha256:dea567d1b0e8bc5764b9443858b673b734100c2871dc93163f58c46a97a83d28"}, - {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4783183f7cb757b73b2ae9aed6599b96338eb957233c58ca8f49a49cc32fd5e"}, - {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0608251135d0e03111152e41f0cc2392d1e74e35703960d4190b2e0f4ca9c70"}, - {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:dc0fdf6787f37b1c6b08e6dfc892d9d068b5bdb671198c72072828b80bd5fe4c"}, - {file = "cryptography-42.0.8-cp39-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:9c0c1716c8447ee7dbf08d6db2e5c41c688544c61074b54fc4564196f55c25a7"}, - {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fff12c88a672ab9c9c1cf7b0c80e3ad9e2ebd9d828d955c126be4fd3e5578c9e"}, - {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:cafb92b2bc622cd1aa6a1dce4b93307792633f4c5fe1f46c6b97cf67073ec961"}, - {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:31f721658a29331f895a5a54e7e82075554ccfb8b163a18719d342f5ffe5ecb1"}, - {file = "cryptography-42.0.8-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:b297f90c5723d04bcc8265fc2a0f86d4ea2e0f7ab4b6994459548d3a6b992a14"}, - {file = "cryptography-42.0.8-cp39-abi3-win32.whl", hash = "sha256:2f88d197e66c65be5e42cd72e5c18afbfae3f741742070e3019ac8f4ac57262c"}, - {file = "cryptography-42.0.8-cp39-abi3-win_amd64.whl", hash = "sha256:fa76fbb7596cc5839320000cdd5d0955313696d9511debab7ee7278fc8b5c84a"}, - {file = "cryptography-42.0.8-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:ba4f0a211697362e89ad822e667d8d340b4d8d55fae72cdd619389fb5912eefe"}, - {file = "cryptography-42.0.8-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:81884c4d096c272f00aeb1f11cf62ccd39763581645b0812e99a91505fa48e0c"}, - {file = "cryptography-42.0.8-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:c9bb2ae11bfbab395bdd072985abde58ea9860ed84e59dbc0463a5d0159f5b71"}, - {file = "cryptography-42.0.8-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:7016f837e15b0a1c119d27ecd89b3515f01f90a8615ed5e9427e30d9cdbfed3d"}, - {file = "cryptography-42.0.8-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:5a94eccb2a81a309806027e1670a358b99b8fe8bfe9f8d329f27d72c094dde8c"}, - {file = "cryptography-42.0.8-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dec9b018df185f08483f294cae6ccac29e7a6e0678996587363dc352dc65c842"}, - {file = "cryptography-42.0.8-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:343728aac38decfdeecf55ecab3264b015be68fc2816ca800db649607aeee648"}, - {file = "cryptography-42.0.8-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:013629ae70b40af70c9a7a5db40abe5d9054e6f4380e50ce769947b73bf3caad"}, - {file = "cryptography-42.0.8.tar.gz", hash = "sha256:8d09d05439ce7baa8e9e95b07ec5b6c886f548deb7e0f69ef25f64b3bce842f2"}, +groups = ["test"] +files = [ + {file = "craft-text-detector_updated-0.4.7.tar.gz", hash = "sha256:e8811a7bfc70df5aa1a70ded0aaaa82acd7693eced8862dbc40273d8458ac102"}, + {file = "craft_text_detector_updated-0.4.7-py3-none-any.whl", hash = "sha256:0b1d59a42c9e6cb421416465bc98ef34fac9bae5c767576b0a3362adad13121e"}, ] [package.dependencies] -cffi = {version = ">=1.12", markers = "platform_python_implementation != \"PyPy\""} - -[package.extras] -docs = ["sphinx (>=5.3.0)", "sphinx-rtd-theme (>=1.1.1)"] -docstest = ["pyenchant (>=1.6.11)", "readme-renderer", "sphinxcontrib-spelling (>=4.0.1)"] -nox = ["nox"] -pep8test = ["check-sdist", "click", "mypy", "ruff"] -sdist = ["build"] -ssh = ["bcrypt (>=3.1.5)"] -test = ["certifi", "pretend", "pytest (>=6.2.0)", "pytest-benchmark", "pytest-cov", "pytest-xdist"] -test-randomorder = ["pytest-randomly"] +gdown = ">=3.10.1" +opencv-python = ">=3.4.8.29" +scipy = ">=1.3.2" +torch = ">=1.6.0" +torchvision = ">=0.7.0" [[package]] name = "cycler" @@ -1044,51 +751,6 @@ files = [ docs = ["ipython", "matplotlib", "numpydoc", "sphinx"] tests = ["pytest", "pytest-cov", "pytest-xdist"] -[[package]] -name = "datasets" -version = "3.5.0" -description = "HuggingFace community-driven open-source library of datasets" -optional = true -python-versions = ">=3.9.0" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "datasets-3.5.0-py3-none-any.whl", hash = "sha256:b3b7f163acc6ac4e01a1b00eef26d48bd4039288ceea3601d169272bd5581006"}, - {file = "datasets-3.5.0.tar.gz", hash = "sha256:9e39560e34f83a64e48ceca7adeb645ede3c3055c5cf48ed2b454f8ed2b89754"}, -] - -[package.dependencies] -aiohttp = "*" -dill = ">=0.3.0,<0.3.9" -filelock = "*" -fsspec = {version = ">=2023.1.0,<=2024.12.0", extras = ["http"]} -huggingface-hub = ">=0.24.0" -multiprocess = "<0.70.17" -numpy = ">=1.17" -packaging = "*" -pandas = "*" -pyarrow = ">=15.0.0" -pyyaml = ">=5.1" -requests = ">=2.32.2" -tqdm = ">=4.66.3" -xxhash = "*" - -[package.extras] -audio = ["librosa", "soundfile (>=0.12.1)", "soxr (>=0.4.0) ; python_version >= \"3.9\""] -benchmarks = ["tensorflow (==2.12.0)", "torch (==2.0.1)", "transformers (==4.30.1)"] -dev = ["Pillow (>=9.4.0)", "absl-py", "decorator", "elasticsearch (>=7.17.12,<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14) ; sys_platform != \"win32\"", "jaxlib (>=0.3.14) ; sys_platform != \"win32\"", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyav", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "ruff (>=0.3.0)", "s3fs", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0) ; python_version >= \"3.9\"", "sqlalchemy", "tensorflow (>=2.16.0) ; python_version >= \"3.10\"", "tensorflow (>=2.6.0)", "tensorflow (>=2.6.0) ; python_version < \"3.10\"", "tiktoken", "torch", "torch (>=2.0.0)", "torchdata", "torchvision", "transformers", "transformers (>=4.42.0)", "zstandard"] -docs = ["s3fs", "tensorflow (>=2.6.0)", "torch", "transformers"] -jax = ["jax (>=0.3.14)", "jaxlib (>=0.3.14)"] -pdfs = ["pdfplumber (>=0.11.4)"] -quality = ["ruff (>=0.3.0)"] -s3 = ["s3fs"] -tensorflow = ["tensorflow (>=2.6.0)"] -tensorflow-gpu = ["tensorflow (>=2.6.0)"] -tests = ["Pillow (>=9.4.0)", "absl-py", "decorator", "elasticsearch (>=7.17.12,<8.0.0)", "faiss-cpu (>=1.8.0.post1)", "jax (>=0.3.14) ; sys_platform != \"win32\"", "jaxlib (>=0.3.14) ; sys_platform != \"win32\"", "joblib (<1.3.0)", "joblibspark", "librosa", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyav", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0) ; python_version >= \"3.9\"", "sqlalchemy", "tensorflow (>=2.16.0) ; python_version >= \"3.10\"", "tensorflow (>=2.6.0) ; python_version < \"3.10\"", "tiktoken", "torch (>=2.0.0)", "torchdata", "torchvision", "transformers (>=4.42.0)", "zstandard"] -tests-numpy2 = ["Pillow (>=9.4.0)", "absl-py", "decorator", "elasticsearch (>=7.17.12,<8.0.0)", "jax (>=0.3.14) ; sys_platform != \"win32\"", "jaxlib (>=0.3.14) ; sys_platform != \"win32\"", "joblib (<1.3.0)", "joblibspark", "lz4", "moto[server]", "polars[timezone] (>=0.20.0)", "protobuf (<4.0.0)", "py7zr", "pyav", "pyspark (>=3.4)", "pytest", "pytest-datadir", "pytest-xdist", "rarfile (>=4.0)", "s3fs (>=2021.11.1)", "soundfile (>=0.12.1)", "soundfile (>=0.12.1)", "soxr (>=0.4.0) ; python_version >= \"3.9\"", "sqlalchemy", "tiktoken", "torch (>=2.0.0)", "torchdata", "torchvision", "transformers (>=4.42.0)", "zstandard"] -torch = ["torch"] -vision = ["Pillow (>=9.4.0)"] - [[package]] name = "debugpy" version = "1.8.13" @@ -1167,36 +829,6 @@ wrapt = ">=1.10,<2" [package.extras] dev = ["PyTest", "PyTest-Cov", "bump2version (<1)", "setuptools ; python_version >= \"3.12\"", "tox"] -[[package]] -name = "dill" -version = "0.3.8" -description = "serialize all of Python" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"}, - {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"}, -] - -[package.extras] -graph = ["objgraph (>=1.7.2)"] -profile = ["gprof2dot (>=2022.7.29)"] - -[[package]] -name = "diskcache" -version = "5.6.3" -description = "Disk Cache -- Disk and file backed persistent cache." -optional = true -python-versions = ">=3" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "diskcache-5.6.3-py3-none-any.whl", hash = "sha256:5e31b2d5fbad117cc363ebaf6b689474db18a1f6438bc82358b024abd4c2ca19"}, - {file = "diskcache-5.6.3.tar.gz", hash = "sha256:2c3a3fa2743d8535d832ec61c2054a1641f41775aa7c556758a109941e33e4fc"}, -] - [[package]] name = "distlib" version = "0.3.9" @@ -1221,84 +853,6 @@ files = [ {file = "distro-1.9.0.tar.gz", hash = "sha256:2fa77c6fd8940f116ee1d6b94a2f90b13b5ea8d019b98bc8bafdcabcdd9bdbed"}, ] -[[package]] -name = "dnspython" -version = "2.7.0" -description = "DNS toolkit" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "dnspython-2.7.0-py3-none-any.whl", hash = "sha256:b4c34b7d10b51bcc3a5071e7b8dee77939f1e878477eeecc965e9835f63c6c86"}, - {file = "dnspython-2.7.0.tar.gz", hash = "sha256:ce9c432eda0dc91cf618a5cedf1a4e142651196bbcd2c80e89ed5a907e5cfaf1"}, -] - -[package.extras] -dev = ["black (>=23.1.0)", "coverage (>=7.0)", "flake8 (>=7)", "hypercorn (>=0.16.0)", "mypy (>=1.8)", "pylint (>=3)", "pytest (>=7.4)", "pytest-cov (>=4.1.0)", "quart-trio (>=0.11.0)", "sphinx (>=7.2.0)", "sphinx-rtd-theme (>=2.0.0)", "twine (>=4.0.0)", "wheel (>=0.42.0)"] -dnssec = ["cryptography (>=43)"] -doh = ["h2 (>=4.1.0)", "httpcore (>=1.0.0)", "httpx (>=0.26.0)"] -doq = ["aioquic (>=1.0.0)"] -idna = ["idna (>=3.7)"] -trio = ["trio (>=0.23)"] -wmi = ["wmi (>=1.5.1)"] - -[[package]] -name = "dspy" -version = "2.5.43" -description = "DSPy" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "dspy-2.5.43-py3-none-any.whl", hash = "sha256:fe04b7188b5185db20d4b75e646b8d831fa8a50a0f8693b1d6317d33b0e02508"}, - {file = "dspy-2.5.43.tar.gz", hash = "sha256:cdae20d2b2e6cba46c9cdc2220dc6315ef1a375baa4fcaf61e5ca2943a9205be"}, -] - -[package.dependencies] -anyio = "*" -asyncer = "0.0.8" -backoff = "*" -cachetools = "*" -cloudpickle = "*" -datasets = "*" -diskcache = "*" -httpx = "*" -jinja2 = "*" -joblib = ">=1.3,<2.0" -json-repair = "*" -litellm = {version = "1.53.7", extras = ["proxy"]} -magicattr = ">=0.1.6,<0.2.0" -openai = "*" -optuna = "*" -pandas = "*" -pydantic = ">=2.0,<3.0" -regex = "*" -requests = "*" -tenacity = ">=8.2.3" -tqdm = "*" -ujson = "*" - -[package.extras] -chromadb = ["chromadb (>=0.4.14,<0.5.0)"] -faiss-cpu = ["faiss-cpu", "sentence-transformers"] -falkordb = ["async-timeout", "falkordb", "redis"] -fastembed = ["fastembed"] -google-vertex-ai = ["google-cloud-aiplatform (==1.43.0)"] -groq = ["groq (>=0.8.0,<0.9.0)"] -lancedb = ["lancedb (>=0.11.0,<0.12.0)"] -langfuse = ["langfuse (>=2.36.1,<2.37.0)"] -marqo = ["marqo (>=3.1.0,<3.2.0)"] -milvus = ["pymilvus (>=2.3.7,<2.4.0)"] -mongodb = ["pymongo (>=3.12.0,<3.13.0)"] -myscale = ["clickhouse-connect"] -pgvector = ["pgvector (>=0.2.5,<0.3.0)", "psycopg2 (>=2.9.9,<2.10.0)"] -pinecone = ["pinecone-client (>=2.2.4,<2.3.0)"] -qdrant = ["fastembed", "qdrant-client"] -snowflake = ["snowflake-snowpark-python"] -weaviate = ["weaviate-client (>=4.6.5,<4.7.0)"] - [[package]] name = "easyocr" version = "1.7.2" @@ -1325,23 +879,6 @@ Shapely = "*" torch = "*" torchvision = ">=0.5" -[[package]] -name = "email-validator" -version = "2.2.0" -description = "A robust email address syntax and deliverability validation library." -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "email_validator-2.2.0-py3-none-any.whl", hash = "sha256:561977c2d73ce3611850a06fa56b414621e0c8faa9d66f2611407d87465da631"}, - {file = "email_validator-2.2.0.tar.gz", hash = "sha256:cb690f344c617a714f22e66ae771445a1ceb46821152df8e165c5f9a364582b7"}, -] - -[package.dependencies] -dnspython = ">=2.0.0" -idna = ">=2.0.0" - [[package]] name = "exceptiongroup" version = "1.2.2" @@ -1373,73 +910,6 @@ files = [ [package.extras] tests = ["asttokens (>=2.1.0)", "coverage", "coverage-enable-subprocess", "ipython", "littleutils", "pytest", "rich ; python_version >= \"3.11\""] -[[package]] -name = "fastapi" -version = "0.111.1" -description = "FastAPI framework, high performance, easy to learn, fast to code, ready for production" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "fastapi-0.111.1-py3-none-any.whl", hash = "sha256:4f51cfa25d72f9fbc3280832e84b32494cf186f50158d364a8765aabf22587bf"}, - {file = "fastapi-0.111.1.tar.gz", hash = "sha256:ddd1ac34cb1f76c2e2d7f8545a4bcb5463bce4834e81abf0b189e0c359ab2413"}, -] - -[package.dependencies] -email_validator = ">=2.0.0" -fastapi-cli = ">=0.0.2" -httpx = ">=0.23.0" -jinja2 = ">=2.11.2" -pydantic = ">=1.7.4,<1.8 || >1.8,<1.8.1 || >1.8.1,<2.0.0 || >2.0.0,<2.0.1 || >2.0.1,<2.1.0 || >2.1.0,<3.0.0" -python-multipart = ">=0.0.7" -starlette = ">=0.37.2,<0.38.0" -typing-extensions = ">=4.8.0" -uvicorn = {version = ">=0.12.0", extras = ["standard"]} - -[package.extras] -all = ["email_validator (>=2.0.0)", "httpx (>=0.23.0)", "itsdangerous (>=1.1.0)", "jinja2 (>=2.11.2)", "orjson (>=3.2.1)", "pydantic-extra-types (>=2.0.0)", "pydantic-settings (>=2.0.0)", "python-multipart (>=0.0.7)", "pyyaml (>=5.3.1)", "ujson (>=4.0.1,!=4.0.2,!=4.1.0,!=4.2.0,!=4.3.0,!=5.0.0,!=5.1.0)", "uvicorn[standard] (>=0.12.0)"] - -[[package]] -name = "fastapi-cli" -version = "0.0.7" -description = "Run and manage FastAPI apps from the command line with FastAPI CLI. 🚀" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "fastapi_cli-0.0.7-py3-none-any.whl", hash = "sha256:d549368ff584b2804336c61f192d86ddea080c11255f375959627911944804f4"}, - {file = "fastapi_cli-0.0.7.tar.gz", hash = "sha256:02b3b65956f526412515907a0793c9094abd4bfb5457b389f645b0ea6ba3605e"}, -] - -[package.dependencies] -rich-toolkit = ">=0.11.1" -typer = ">=0.12.3" -uvicorn = {version = ">=0.15.0", extras = ["standard"]} - -[package.extras] -standard = ["uvicorn[standard] (>=0.15.0)"] - -[[package]] -name = "fastapi-sso" -version = "0.10.0" -description = "FastAPI plugin to enable SSO to most common providers (such as Facebook login, Google login and login via Microsoft Office 365 Account)" -optional = true -python-versions = ">=3.8,<4.0" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "fastapi_sso-0.10.0-py3-none-any.whl", hash = "sha256:579bbcf84157f394a9b30a45dbca74e623cd432054c6f63c55996a775711388e"}, - {file = "fastapi_sso-0.10.0.tar.gz", hash = "sha256:8029c2c58abd861268edc3710ac45827699789bae062a5be52bbbb7a6918c637"}, -] - -[package.dependencies] -fastapi = ">=0.80" -httpx = ">=0.23.0" -oauthlib = ">=3.1.0" -pydantic = {version = ">=1.8.0", extras = ["email"]} - [[package]] name = "fastjsonschema" version = "2.21.1" @@ -1496,6 +966,18 @@ files = [ {file = "findspark-2.0.1.tar.gz", hash = "sha256:aa10a96cb616cab329181d72e8ef13d2dc453b4babd02b5482471a0882c1195e"}, ] +[[package]] +name = "flatbuffers" +version = "25.2.10" +description = "The FlatBuffers serialization format for Python" +optional = false +python-versions = "*" +groups = ["main"] +files = [ + {file = "flatbuffers-25.2.10-py2.py3-none-any.whl", hash = "sha256:ebba5f4d5ea615af3f7fd70fc310636fbb2bbd1f566ac0a23d98dd412de50051"}, + {file = "flatbuffers-25.2.10.tar.gz", hash = "sha256:97e451377a41262f8d9bd4295cc836133415cc03d8cb966410a4af92eb00d26e"}, +] + [[package]] name = "fonttools" version = "4.57.0" @@ -1582,109 +1064,6 @@ files = [ {file = "fqdn-1.5.1.tar.gz", hash = "sha256:105ed3677e767fb5ca086a0c1f4bb66ebc3c100be518f0e0d755d9eae164d89f"}, ] -[[package]] -name = "frozenlist" -version = "1.5.0" -description = "A list-like structure which implements collections.abc.MutableSequence" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "frozenlist-1.5.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:5b6a66c18b5b9dd261ca98dffcb826a525334b2f29e7caa54e182255c5f6a65a"}, - {file = "frozenlist-1.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d1b3eb7b05ea246510b43a7e53ed1653e55c2121019a97e60cad7efb881a97bb"}, - {file = "frozenlist-1.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:15538c0cbf0e4fa11d1e3a71f823524b0c46299aed6e10ebb4c2089abd8c3bec"}, - {file = "frozenlist-1.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e79225373c317ff1e35f210dd5f1344ff31066ba8067c307ab60254cd3a78ad5"}, - {file = "frozenlist-1.5.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9272fa73ca71266702c4c3e2d4a28553ea03418e591e377a03b8e3659d94fa76"}, - {file = "frozenlist-1.5.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:498524025a5b8ba81695761d78c8dd7382ac0b052f34e66939c42df860b8ff17"}, - {file = "frozenlist-1.5.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:92b5278ed9d50fe610185ecd23c55d8b307d75ca18e94c0e7de328089ac5dcba"}, - {file = "frozenlist-1.5.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7f3c8c1dacd037df16e85227bac13cca58c30da836c6f936ba1df0c05d046d8d"}, - {file = "frozenlist-1.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f2ac49a9bedb996086057b75bf93538240538c6d9b38e57c82d51f75a73409d2"}, - {file = "frozenlist-1.5.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e66cc454f97053b79c2ab09c17fbe3c825ea6b4de20baf1be28919460dd7877f"}, - {file = "frozenlist-1.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:5a3ba5f9a0dfed20337d3e966dc359784c9f96503674c2faf015f7fe8e96798c"}, - {file = "frozenlist-1.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:6321899477db90bdeb9299ac3627a6a53c7399c8cd58d25da094007402b039ab"}, - {file = "frozenlist-1.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:76e4753701248476e6286f2ef492af900ea67d9706a0155335a40ea21bf3b2f5"}, - {file = "frozenlist-1.5.0-cp310-cp310-win32.whl", hash = "sha256:977701c081c0241d0955c9586ffdd9ce44f7a7795df39b9151cd9a6fd0ce4cfb"}, - {file = "frozenlist-1.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:189f03b53e64144f90990d29a27ec4f7997d91ed3d01b51fa39d2dbe77540fd4"}, - {file = "frozenlist-1.5.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:fd74520371c3c4175142d02a976aee0b4cb4a7cc912a60586ffd8d5929979b30"}, - {file = "frozenlist-1.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2f3f7a0fbc219fb4455264cae4d9f01ad41ae6ee8524500f381de64ffaa077d5"}, - {file = "frozenlist-1.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:f47c9c9028f55a04ac254346e92977bf0f166c483c74b4232bee19a6697e4778"}, - {file = "frozenlist-1.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0996c66760924da6e88922756d99b47512a71cfd45215f3570bf1e0b694c206a"}, - {file = "frozenlist-1.5.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a2fe128eb4edeabe11896cb6af88fca5346059f6c8d807e3b910069f39157869"}, - {file = "frozenlist-1.5.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a8ea951bbb6cacd492e3948b8da8c502a3f814f5d20935aae74b5df2b19cf3d"}, - {file = "frozenlist-1.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:de537c11e4aa01d37db0d403b57bd6f0546e71a82347a97c6a9f0dcc532b3a45"}, - {file = "frozenlist-1.5.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c2623347b933fcb9095841f1cc5d4ff0b278addd743e0e966cb3d460278840d"}, - {file = "frozenlist-1.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:cee6798eaf8b1416ef6909b06f7dc04b60755206bddc599f52232606e18179d3"}, - {file = "frozenlist-1.5.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f5f9da7f5dbc00a604fe74aa02ae7c98bcede8a3b8b9666f9f86fc13993bc71a"}, - {file = "frozenlist-1.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:90646abbc7a5d5c7c19461d2e3eeb76eb0b204919e6ece342feb6032c9325ae9"}, - {file = "frozenlist-1.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:bdac3c7d9b705d253b2ce370fde941836a5f8b3c5c2b8fd70940a3ea3af7f4f2"}, - {file = "frozenlist-1.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:03d33c2ddbc1816237a67f66336616416e2bbb6beb306e5f890f2eb22b959cdf"}, - {file = "frozenlist-1.5.0-cp311-cp311-win32.whl", hash = "sha256:237f6b23ee0f44066219dae14c70ae38a63f0440ce6750f868ee08775073f942"}, - {file = "frozenlist-1.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:0cc974cc93d32c42e7b0f6cf242a6bd941c57c61b618e78b6c0a96cb72788c1d"}, - {file = "frozenlist-1.5.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:31115ba75889723431aa9a4e77d5f398f5cf976eea3bdf61749731f62d4a4a21"}, - {file = "frozenlist-1.5.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7437601c4d89d070eac8323f121fcf25f88674627505334654fd027b091db09d"}, - {file = "frozenlist-1.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:7948140d9f8ece1745be806f2bfdf390127cf1a763b925c4a805c603df5e697e"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:feeb64bc9bcc6b45c6311c9e9b99406660a9c05ca8a5b30d14a78555088b0b3a"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:683173d371daad49cffb8309779e886e59c2f369430ad28fe715f66d08d4ab1a"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7d57d8f702221405a9d9b40f9da8ac2e4a1a8b5285aac6100f3393675f0a85ee"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:30c72000fbcc35b129cb09956836c7d7abf78ab5416595e4857d1cae8d6251a6"}, - {file = "frozenlist-1.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:000a77d6034fbad9b6bb880f7ec073027908f1b40254b5d6f26210d2dab1240e"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5d7f5a50342475962eb18b740f3beecc685a15b52c91f7d975257e13e029eca9"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:87f724d055eb4785d9be84e9ebf0f24e392ddfad00b3fe036e43f489fafc9039"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:6e9080bb2fb195a046e5177f10d9d82b8a204c0736a97a153c2466127de87784"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:9b93d7aaa36c966fa42efcaf716e6b3900438632a626fb09c049f6a2f09fc631"}, - {file = "frozenlist-1.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:52ef692a4bc60a6dd57f507429636c2af8b6046db8b31b18dac02cbc8f507f7f"}, - {file = "frozenlist-1.5.0-cp312-cp312-win32.whl", hash = "sha256:29d94c256679247b33a3dc96cce0f93cbc69c23bf75ff715919332fdbb6a32b8"}, - {file = "frozenlist-1.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:8969190d709e7c48ea386db202d708eb94bdb29207a1f269bab1196ce0dcca1f"}, - {file = "frozenlist-1.5.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:7a1a048f9215c90973402e26c01d1cff8a209e1f1b53f72b95c13db61b00f953"}, - {file = "frozenlist-1.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dd47a5181ce5fcb463b5d9e17ecfdb02b678cca31280639255ce9d0e5aa67af0"}, - {file = "frozenlist-1.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1431d60b36d15cda188ea222033eec8e0eab488f39a272461f2e6d9e1a8e63c2"}, - {file = "frozenlist-1.5.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6482a5851f5d72767fbd0e507e80737f9c8646ae7fd303def99bfe813f76cf7f"}, - {file = "frozenlist-1.5.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:44c49271a937625619e862baacbd037a7ef86dd1ee215afc298a417ff3270608"}, - {file = "frozenlist-1.5.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:12f78f98c2f1c2429d42e6a485f433722b0061d5c0b0139efa64f396efb5886b"}, - {file = "frozenlist-1.5.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ce3aa154c452d2467487765e3adc730a8c153af77ad84096bc19ce19a2400840"}, - {file = "frozenlist-1.5.0-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9b7dc0c4338e6b8b091e8faf0db3168a37101943e687f373dce00959583f7439"}, - {file = "frozenlist-1.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:45e0896250900b5aa25180f9aec243e84e92ac84bd4a74d9ad4138ef3f5c97de"}, - {file = "frozenlist-1.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:561eb1c9579d495fddb6da8959fd2a1fca2c6d060d4113f5844b433fc02f2641"}, - {file = "frozenlist-1.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:df6e2f325bfee1f49f81aaac97d2aa757c7646534a06f8f577ce184afe2f0a9e"}, - {file = "frozenlist-1.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:140228863501b44b809fb39ec56b5d4071f4d0aa6d216c19cbb08b8c5a7eadb9"}, - {file = "frozenlist-1.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:7707a25d6a77f5d27ea7dc7d1fc608aa0a478193823f88511ef5e6b8a48f9d03"}, - {file = "frozenlist-1.5.0-cp313-cp313-win32.whl", hash = "sha256:31a9ac2b38ab9b5a8933b693db4939764ad3f299fcaa931a3e605bc3460e693c"}, - {file = "frozenlist-1.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:11aabdd62b8b9c4b84081a3c246506d1cddd2dd93ff0ad53ede5defec7886b28"}, - {file = "frozenlist-1.5.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:dd94994fc91a6177bfaafd7d9fd951bc8689b0a98168aa26b5f543868548d3ca"}, - {file = "frozenlist-1.5.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:2d0da8bbec082bf6bf18345b180958775363588678f64998c2b7609e34719b10"}, - {file = "frozenlist-1.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:73f2e31ea8dd7df61a359b731716018c2be196e5bb3b74ddba107f694fbd7604"}, - {file = "frozenlist-1.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:828afae9f17e6de596825cf4228ff28fbdf6065974e5ac1410cecc22f699d2b3"}, - {file = "frozenlist-1.5.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f1577515d35ed5649d52ab4319db757bb881ce3b2b796d7283e6634d99ace307"}, - {file = "frozenlist-1.5.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2150cc6305a2c2ab33299453e2968611dacb970d2283a14955923062c8d00b10"}, - {file = "frozenlist-1.5.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a72b7a6e3cd2725eff67cd64c8f13335ee18fc3c7befc05aed043d24c7b9ccb9"}, - {file = "frozenlist-1.5.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c16d2fa63e0800723139137d667e1056bee1a1cf7965153d2d104b62855e9b99"}, - {file = "frozenlist-1.5.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:17dcc32fc7bda7ce5875435003220a457bcfa34ab7924a49a1c19f55b6ee185c"}, - {file = "frozenlist-1.5.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:97160e245ea33d8609cd2b8fd997c850b56db147a304a262abc2b3be021a9171"}, - {file = "frozenlist-1.5.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:f1e6540b7fa044eee0bb5111ada694cf3dc15f2b0347ca125ee9ca984d5e9e6e"}, - {file = "frozenlist-1.5.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:91d6c171862df0a6c61479d9724f22efb6109111017c87567cfeb7b5d1449fdf"}, - {file = "frozenlist-1.5.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:c1fac3e2ace2eb1052e9f7c7db480818371134410e1f5c55d65e8f3ac6d1407e"}, - {file = "frozenlist-1.5.0-cp38-cp38-win32.whl", hash = "sha256:b97f7b575ab4a8af9b7bc1d2ef7f29d3afee2226bd03ca3875c16451ad5a7723"}, - {file = "frozenlist-1.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:374ca2dabdccad8e2a76d40b1d037f5bd16824933bf7bcea3e59c891fd4a0923"}, - {file = "frozenlist-1.5.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:9bbcdfaf4af7ce002694a4e10a0159d5a8d20056a12b05b45cea944a4953f972"}, - {file = "frozenlist-1.5.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1893f948bf6681733aaccf36c5232c231e3b5166d607c5fa77773611df6dc336"}, - {file = "frozenlist-1.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2b5e23253bb709ef57a8e95e6ae48daa9ac5f265637529e4ce6b003a37b2621f"}, - {file = "frozenlist-1.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f253985bb515ecd89629db13cb58d702035ecd8cfbca7d7a7e29a0e6d39af5f"}, - {file = "frozenlist-1.5.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:04a5c6babd5e8fb7d3c871dc8b321166b80e41b637c31a995ed844a6139942b6"}, - {file = "frozenlist-1.5.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a9fe0f1c29ba24ba6ff6abf688cb0b7cf1efab6b6aa6adc55441773c252f7411"}, - {file = "frozenlist-1.5.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:226d72559fa19babe2ccd920273e767c96a49b9d3d38badd7c91a0fdeda8ea08"}, - {file = "frozenlist-1.5.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:15b731db116ab3aedec558573c1a5eec78822b32292fe4f2f0345b7f697745c2"}, - {file = "frozenlist-1.5.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:366d8f93e3edfe5a918c874702f78faac300209a4d5bf38352b2c1bdc07a766d"}, - {file = "frozenlist-1.5.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:1b96af8c582b94d381a1c1f51ffaedeb77c821c690ea5f01da3d70a487dd0a9b"}, - {file = "frozenlist-1.5.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:c03eff4a41bd4e38415cbed054bbaff4a075b093e2394b6915dca34a40d1e38b"}, - {file = "frozenlist-1.5.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:50cf5e7ee9b98f22bdecbabf3800ae78ddcc26e4a435515fc72d97903e8488e0"}, - {file = "frozenlist-1.5.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:1e76bfbc72353269c44e0bc2cfe171900fbf7f722ad74c9a7b638052afe6a00c"}, - {file = "frozenlist-1.5.0-cp39-cp39-win32.whl", hash = "sha256:666534d15ba8f0fda3f53969117383d5dc021266b3c1a42c9ec4855e4b58b9d3"}, - {file = "frozenlist-1.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:5c28f4b5dbef8a0d8aad0d4de24d1e9e981728628afaf4ea0792f5d0939372f0"}, - {file = "frozenlist-1.5.0-py3-none-any.whl", hash = "sha256:d994863bba198a4a518b467bb971c56e1db3f180a25c6cf7bb1949c267f748c3"}, - {file = "frozenlist-1.5.0.tar.gz", hash = "sha256:81d5af29e61b9c8348e876d442253723928dce6433e0e76cd925cd83f1b4b817"}, -] - [[package]] name = "fsspec" version = "2024.12.0" @@ -1697,9 +1076,6 @@ files = [ {file = "fsspec-2024.12.0.tar.gz", hash = "sha256:670700c977ed2fb51e0d9f9253177ed20cbde4a3e5c0283cc5385b5870c8533f"}, ] -[package.dependencies] -aiohttp = {version = "<4.0.0a0 || >4.0.0a0,<4.0.0a1 || >4.0.0a1", optional = true, markers = "extra == \"http\""} - [package.extras] abfs = ["adlfs"] adl = ["adlfs"] @@ -1744,115 +1120,25 @@ files = [ wcwidth = "*" [[package]] -name = "greenlet" -version = "3.1.1" -description = "Lightweight in-process concurrent programming" -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "python_version < \"3.14\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\") and extra == \"llm\"" -files = [ - {file = "greenlet-3.1.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:0bbae94a29c9e5c7e4a2b7f0aae5c17e8e90acbfd3bf6270eeba60c39fce3563"}, - {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fde093fb93f35ca72a556cf72c92ea3ebfda3d79fc35bb19fbe685853869a83"}, - {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36b89d13c49216cadb828db8dfa6ce86bbbc476a82d3a6c397f0efae0525bdd0"}, - {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94b6150a85e1b33b40b1464a3f9988dcc5251d6ed06842abff82e42632fac120"}, - {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93147c513fac16385d1036b7e5b102c7fbbdb163d556b791f0f11eada7ba65dc"}, - {file = "greenlet-3.1.1-cp310-cp310-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:da7a9bff22ce038e19bf62c4dd1ec8391062878710ded0a845bcf47cc0200617"}, - {file = "greenlet-3.1.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:b2795058c23988728eec1f36a4e5e4ebad22f8320c85f3587b539b9ac84128d7"}, - {file = "greenlet-3.1.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:ed10eac5830befbdd0c32f83e8aa6288361597550ba669b04c48f0f9a2c843c6"}, - {file = "greenlet-3.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:77c386de38a60d1dfb8e55b8c1101d68c79dfdd25c7095d51fec2dd800892b80"}, - {file = "greenlet-3.1.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:e4d333e558953648ca09d64f13e6d8f0523fa705f51cae3f03b5983489958c70"}, - {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09fc016b73c94e98e29af67ab7b9a879c307c6731a2c9da0db5a7d9b7edd1159"}, - {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d5e975ca70269d66d17dd995dafc06f1b06e8cb1ec1e9ed54c1d1e4a7c4cf26e"}, - {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3b2813dc3de8c1ee3f924e4d4227999285fd335d1bcc0d2be6dc3f1f6a318ec1"}, - {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e347b3bfcf985a05e8c0b7d462ba6f15b1ee1c909e2dcad795e49e91b152c383"}, - {file = "greenlet-3.1.1-cp311-cp311-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e8f8c9cb53cdac7ba9793c276acd90168f416b9ce36799b9b885790f8ad6c0a"}, - {file = "greenlet-3.1.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:62ee94988d6b4722ce0028644418d93a52429e977d742ca2ccbe1c4f4a792511"}, - {file = "greenlet-3.1.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:1776fd7f989fc6b8d8c8cb8da1f6b82c5814957264d1f6cf818d475ec2bf6395"}, - {file = "greenlet-3.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:48ca08c771c268a768087b408658e216133aecd835c0ded47ce955381105ba39"}, - {file = "greenlet-3.1.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:4afe7ea89de619adc868e087b4d2359282058479d7cfb94970adf4b55284574d"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f406b22b7c9a9b4f8aa9d2ab13d6ae0ac3e85c9a809bd590ad53fed2bf70dc79"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c3a701fe5a9695b238503ce5bbe8218e03c3bcccf7e204e455e7462d770268aa"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:2846930c65b47d70b9d178e89c7e1a69c95c1f68ea5aa0a58646b7a96df12441"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99cfaa2110534e2cf3ba31a7abcac9d328d1d9f1b95beede58294a60348fba36"}, - {file = "greenlet-3.1.1-cp312-cp312-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1443279c19fca463fc33e65ef2a935a5b09bb90f978beab37729e1c3c6c25fe9"}, - {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:b7cede291382a78f7bb5f04a529cb18e068dd29e0fb27376074b6d0317bf4dd0"}, - {file = "greenlet-3.1.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:23f20bb60ae298d7d8656c6ec6db134bca379ecefadb0b19ce6f19d1f232a942"}, - {file = "greenlet-3.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:7124e16b4c55d417577c2077be379514321916d5790fa287c9ed6f23bd2ffd01"}, - {file = "greenlet-3.1.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:05175c27cb459dcfc05d026c4232f9de8913ed006d42713cb8a5137bd49375f1"}, - {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:935e943ec47c4afab8965954bf49bfa639c05d4ccf9ef6e924188f762145c0ff"}, - {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:667a9706c970cb552ede35aee17339a18e8f2a87a51fba2ed39ceeeb1004798a"}, - {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b8a678974d1f3aa55f6cc34dc480169d58f2e6d8958895d68845fa4ab566509e"}, - {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efc0f674aa41b92da8c49e0346318c6075d734994c3c4e4430b1c3f853e498e4"}, - {file = "greenlet-3.1.1-cp313-cp313-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0153404a4bb921f0ff1abeb5ce8a5131da56b953eda6e14b88dc6bbc04d2049e"}, - {file = "greenlet-3.1.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:275f72decf9932639c1c6dd1013a1bc266438eb32710016a1c742df5da6e60a1"}, - {file = "greenlet-3.1.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:c4aab7f6381f38a4b42f269057aee279ab0fc7bf2e929e3d4abfae97b682a12c"}, - {file = "greenlet-3.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:b42703b1cf69f2aa1df7d1030b9d77d3e584a70755674d60e710f0af570f3761"}, - {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f1695e76146579f8c06c1509c7ce4dfe0706f49c6831a817ac04eebb2fd02011"}, - {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7876452af029456b3f3549b696bb36a06db7c90747740c5302f74a9e9fa14b13"}, - {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4ead44c85f8ab905852d3de8d86f6f8baf77109f9da589cb4fa142bd3b57b475"}, - {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8320f64b777d00dd7ccdade271eaf0cad6636343293a25074cc5566160e4de7b"}, - {file = "greenlet-3.1.1-cp313-cp313t-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6510bf84a6b643dabba74d3049ead221257603a253d0a9873f55f6a59a65f822"}, - {file = "greenlet-3.1.1-cp313-cp313t-musllinux_1_1_aarch64.whl", hash = "sha256:04b013dc07c96f83134b1e99888e7a79979f1a247e2a9f59697fa14b5862ed01"}, - {file = "greenlet-3.1.1-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:411f015496fec93c1c8cd4e5238da364e1da7a124bcb293f085bf2860c32c6f6"}, - {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:47da355d8687fd65240c364c90a31569a133b7b60de111c255ef5b606f2ae291"}, - {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:98884ecf2ffb7d7fe6bd517e8eb99d31ff7855a840fa6d0d63cd07c037f6a981"}, - {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f1d4aeb8891338e60d1ab6127af1fe45def5259def8094b9c7e34690c8858803"}, - {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db32b5348615a04b82240cc67983cb315309e88d444a288934ee6ceaebcad6cc"}, - {file = "greenlet-3.1.1-cp37-cp37m-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:dcc62f31eae24de7f8dce72134c8651c58000d3b1868e01392baea7c32c247de"}, - {file = "greenlet-3.1.1-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:1d3755bcb2e02de341c55b4fca7a745a24a9e7212ac953f6b3a48d117d7257aa"}, - {file = "greenlet-3.1.1-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:b8da394b34370874b4572676f36acabac172602abf054cbc4ac910219f3340af"}, - {file = "greenlet-3.1.1-cp37-cp37m-win32.whl", hash = "sha256:a0dfc6c143b519113354e780a50381508139b07d2177cb6ad6a08278ec655798"}, - {file = "greenlet-3.1.1-cp37-cp37m-win_amd64.whl", hash = "sha256:54558ea205654b50c438029505def3834e80f0869a70fb15b871c29b4575ddef"}, - {file = "greenlet-3.1.1-cp38-cp38-macosx_11_0_universal2.whl", hash = "sha256:346bed03fe47414091be4ad44786d1bd8bef0c3fcad6ed3dee074a032ab408a9"}, - {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfc59d69fc48664bc693842bd57acfdd490acafda1ab52c7836e3fc75c90a111"}, - {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d21e10da6ec19b457b82636209cbe2331ff4306b54d06fa04b7c138ba18c8a81"}, - {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:37b9de5a96111fc15418819ab4c4432e4f3c2ede61e660b1e33971eba26ef9ba"}, - {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6ef9ea3f137e5711f0dbe5f9263e8c009b7069d8a1acea822bd5e9dae0ae49c8"}, - {file = "greenlet-3.1.1-cp38-cp38-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:85f3ff71e2e60bd4b4932a043fbbe0f499e263c628390b285cb599154a3b03b1"}, - {file = "greenlet-3.1.1-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:95ffcf719966dd7c453f908e208e14cde192e09fde6c7186c8f1896ef778d8cd"}, - {file = "greenlet-3.1.1-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:03a088b9de532cbfe2ba2034b2b85e82df37874681e8c470d6fb2f8c04d7e4b7"}, - {file = "greenlet-3.1.1-cp38-cp38-win32.whl", hash = "sha256:8b8b36671f10ba80e159378df9c4f15c14098c4fd73a36b9ad715f057272fbef"}, - {file = "greenlet-3.1.1-cp38-cp38-win_amd64.whl", hash = "sha256:7017b2be767b9d43cc31416aba48aab0d2309ee31b4dbf10a1d38fb7972bdf9d"}, - {file = "greenlet-3.1.1-cp39-cp39-macosx_11_0_universal2.whl", hash = "sha256:396979749bd95f018296af156201d6211240e7a23090f50a8d5d18c370084dc3"}, - {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca9d0ff5ad43e785350894d97e13633a66e2b50000e8a183a50a88d834752d42"}, - {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f6ff3b14f2df4c41660a7dec01045a045653998784bf8cfcb5a525bdffffbc8f"}, - {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94ebba31df2aa506d7b14866fed00ac141a867e63143fe5bca82a8e503b36437"}, - {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:73aaad12ac0ff500f62cebed98d8789198ea0e6f233421059fa68a5aa7220145"}, - {file = "greenlet-3.1.1-cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:63e4844797b975b9af3a3fb8f7866ff08775f5426925e1e0bbcfe7932059a12c"}, - {file = "greenlet-3.1.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:7939aa3ca7d2a1593596e7ac6d59391ff30281ef280d8632fa03d81f7c5f955e"}, - {file = "greenlet-3.1.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d0028e725ee18175c6e422797c407874da24381ce0690d6b9396c204c7f7276e"}, - {file = "greenlet-3.1.1-cp39-cp39-win32.whl", hash = "sha256:5e06afd14cbaf9e00899fae69b24a32f2196c19de08fcb9f4779dd4f004e5e7c"}, - {file = "greenlet-3.1.1-cp39-cp39-win_amd64.whl", hash = "sha256:3319aa75e0e0639bc15ff54ca327e8dc7a6fe404003496e3c6925cd3142e0e22"}, - {file = "greenlet-3.1.1.tar.gz", hash = "sha256:4ce3ac6cdb6adf7946475d7ef31777c26d94bccc377e070a7986bd2d5c515467"}, -] - -[package.extras] -docs = ["Sphinx", "furo"] -test = ["objgraph", "psutil"] - -[[package]] -name = "gunicorn" -version = "22.0.0" -description = "WSGI HTTP Server for UNIX" -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" +name = "gdown" +version = "5.2.0" +description = "Google Drive Public File/Folder Downloader" +optional = false +python-versions = ">=3.8" +groups = ["test"] files = [ - {file = "gunicorn-22.0.0-py3-none-any.whl", hash = "sha256:350679f91b24062c86e386e198a15438d53a7a8207235a78ba1b53df4c4378d9"}, - {file = "gunicorn-22.0.0.tar.gz", hash = "sha256:4a0b436239ff76fb33f11c07a16482c521a7e09c1ce3cc293c2330afe01bec63"}, + {file = "gdown-5.2.0-py3-none-any.whl", hash = "sha256:33083832d82b1101bdd0e9df3edd0fbc0e1c5f14c9d8c38d2a35bf1683b526d6"}, + {file = "gdown-5.2.0.tar.gz", hash = "sha256:2145165062d85520a3cd98b356c9ed522c5e7984d408535409fd46f94defc787"}, ] [package.dependencies] -packaging = "*" +beautifulsoup4 = "*" +filelock = "*" +requests = {version = "*", extras = ["socks"]} +tqdm = "*" [package.extras] -eventlet = ["eventlet (>=0.24.1,!=0.36.0)"] -gevent = ["gevent (>=1.4.0)"] -setproctitle = ["setproctitle"] -testing = ["coverage", "eventlet", "gevent", "pytest", "pytest-cov"] -tornado = ["tornado (>=0.2)"] +test = ["build", "mypy", "pytest", "pytest-xdist", "ruff", "twine", "types-requests", "types-setuptools"] [[package]] name = "h11" @@ -1927,73 +1213,16 @@ http2 = ["h2 (>=3,<5)"] socks = ["socksio (==1.*)"] trio = ["trio (>=0.22.0,<1.0)"] -[[package]] -name = "httptools" -version = "0.6.4" -description = "A collection of framework independent HTTP protocol utils." -optional = true -python-versions = ">=3.8.0" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "httptools-0.6.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:3c73ce323711a6ffb0d247dcd5a550b8babf0f757e86a52558fe5b86d6fefcc0"}, - {file = "httptools-0.6.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:345c288418f0944a6fe67be8e6afa9262b18c7626c3ef3c28adc5eabc06a68da"}, - {file = "httptools-0.6.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:deee0e3343f98ee8047e9f4c5bc7cedbf69f5734454a94c38ee829fb2d5fa3c1"}, - {file = "httptools-0.6.4-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ca80b7485c76f768a3bc83ea58373f8db7b015551117375e4918e2aa77ea9b50"}, - {file = "httptools-0.6.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:90d96a385fa941283ebd231464045187a31ad932ebfa541be8edf5b3c2328959"}, - {file = "httptools-0.6.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:59e724f8b332319e2875efd360e61ac07f33b492889284a3e05e6d13746876f4"}, - {file = "httptools-0.6.4-cp310-cp310-win_amd64.whl", hash = "sha256:c26f313951f6e26147833fc923f78f95604bbec812a43e5ee37f26dc9e5a686c"}, - {file = "httptools-0.6.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:f47f8ed67cc0ff862b84a1189831d1d33c963fb3ce1ee0c65d3b0cbe7b711069"}, - {file = "httptools-0.6.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:0614154d5454c21b6410fdf5262b4a3ddb0f53f1e1721cfd59d55f32138c578a"}, - {file = "httptools-0.6.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f8787367fbdfccae38e35abf7641dafc5310310a5987b689f4c32cc8cc3ee975"}, - {file = "httptools-0.6.4-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40b0f7fe4fd38e6a507bdb751db0379df1e99120c65fbdc8ee6c1d044897a636"}, - {file = "httptools-0.6.4-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:40a5ec98d3f49904b9fe36827dcf1aadfef3b89e2bd05b0e35e94f97c2b14721"}, - {file = "httptools-0.6.4-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:dacdd3d10ea1b4ca9df97a0a303cbacafc04b5cd375fa98732678151643d4988"}, - {file = "httptools-0.6.4-cp311-cp311-win_amd64.whl", hash = "sha256:288cd628406cc53f9a541cfaf06041b4c71d751856bab45e3702191f931ccd17"}, - {file = "httptools-0.6.4-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:df017d6c780287d5c80601dafa31f17bddb170232d85c066604d8558683711a2"}, - {file = "httptools-0.6.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:85071a1e8c2d051b507161f6c3e26155b5c790e4e28d7f236422dbacc2a9cc44"}, - {file = "httptools-0.6.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69422b7f458c5af875922cdb5bd586cc1f1033295aa9ff63ee196a87519ac8e1"}, - {file = "httptools-0.6.4-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:16e603a3bff50db08cd578d54f07032ca1631450ceb972c2f834c2b860c28ea2"}, - {file = "httptools-0.6.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec4f178901fa1834d4a060320d2f3abc5c9e39766953d038f1458cb885f47e81"}, - {file = "httptools-0.6.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:f9eb89ecf8b290f2e293325c646a211ff1c2493222798bb80a530c5e7502494f"}, - {file = "httptools-0.6.4-cp312-cp312-win_amd64.whl", hash = "sha256:db78cb9ca56b59b016e64b6031eda5653be0589dba2b1b43453f6e8b405a0970"}, - {file = "httptools-0.6.4-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ade273d7e767d5fae13fa637f4d53b6e961fb7fd93c7797562663f0171c26660"}, - {file = "httptools-0.6.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:856f4bc0478ae143bad54a4242fccb1f3f86a6e1be5548fecfd4102061b3a083"}, - {file = "httptools-0.6.4-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:322d20ea9cdd1fa98bd6a74b77e2ec5b818abdc3d36695ab402a0de8ef2865a3"}, - {file = "httptools-0.6.4-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4d87b29bd4486c0093fc64dea80231f7c7f7eb4dc70ae394d70a495ab8436071"}, - {file = "httptools-0.6.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:342dd6946aa6bda4b8f18c734576106b8a31f2fe31492881a9a160ec84ff4bd5"}, - {file = "httptools-0.6.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b36913ba52008249223042dca46e69967985fb4051951f94357ea681e1f5dc0"}, - {file = "httptools-0.6.4-cp313-cp313-win_amd64.whl", hash = "sha256:28908df1b9bb8187393d5b5db91435ccc9c8e891657f9cbb42a2541b44c82fc8"}, - {file = "httptools-0.6.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:d3f0d369e7ffbe59c4b6116a44d6a8eb4783aae027f2c0b366cf0aa964185dba"}, - {file = "httptools-0.6.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:94978a49b8f4569ad607cd4946b759d90b285e39c0d4640c6b36ca7a3ddf2efc"}, - {file = "httptools-0.6.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40dc6a8e399e15ea525305a2ddba998b0af5caa2566bcd79dcbe8948181eeaff"}, - {file = "httptools-0.6.4-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab9ba8dcf59de5181f6be44a77458e45a578fc99c31510b8c65b7d5acc3cf490"}, - {file = "httptools-0.6.4-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:fc411e1c0a7dcd2f902c7c48cf079947a7e65b5485dea9decb82b9105ca71a43"}, - {file = "httptools-0.6.4-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:d54efd20338ac52ba31e7da78e4a72570cf729fac82bc31ff9199bedf1dc7440"}, - {file = "httptools-0.6.4-cp38-cp38-win_amd64.whl", hash = "sha256:df959752a0c2748a65ab5387d08287abf6779ae9165916fe053e68ae1fbdc47f"}, - {file = "httptools-0.6.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:85797e37e8eeaa5439d33e556662cc370e474445d5fab24dcadc65a8ffb04003"}, - {file = "httptools-0.6.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:db353d22843cf1028f43c3651581e4bb49374d85692a85f95f7b9a130e1b2cab"}, - {file = "httptools-0.6.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1ffd262a73d7c28424252381a5b854c19d9de5f56f075445d33919a637e3547"}, - {file = "httptools-0.6.4-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:703c346571fa50d2e9856a37d7cd9435a25e7fd15e236c397bf224afaa355fe9"}, - {file = "httptools-0.6.4-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:aafe0f1918ed07b67c1e838f950b1c1fabc683030477e60b335649b8020e1076"}, - {file = "httptools-0.6.4-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:0e563e54979e97b6d13f1bbc05a96109923e76b901f786a5eae36e99c01237bd"}, - {file = "httptools-0.6.4-cp39-cp39-win_amd64.whl", hash = "sha256:b799de31416ecc589ad79dd85a0b2657a8fe39327944998dea368c1d4c9e55e6"}, - {file = "httptools-0.6.4.tar.gz", hash = "sha256:4e93eee4add6493b59a5c514da98c939b244fce4a0d8879cd3f466562f4b7d5c"}, -] - -[package.extras] -test = ["Cython (>=0.29.24)"] - [[package]] name = "httpx" -version = "0.27.2" +version = "0.28.1" description = "The next generation HTTP client." optional = false python-versions = ">=3.8" groups = ["main", "test"] files = [ - {file = "httpx-0.27.2-py3-none-any.whl", hash = "sha256:7bb2708e112d8fdd7829cd4243970f0c223274051cb35ee80c03301ee29a3df0"}, - {file = "httpx-0.27.2.tar.gz", hash = "sha256:f7c2be1d2f3c3c3160d441802406b206c2b76f5947b11115e6df10c6c65e66c2"}, + {file = "httpx-0.28.1-py3-none-any.whl", hash = "sha256:d909fcccc110f8c7faf814ca82a9a4d816bc5a6dbfea25d6591d6985b8ba59ad"}, + {file = "httpx-0.28.1.tar.gz", hash = "sha256:75e98c5f16b0f35b567856f597f06ff2270a374470a5c2392242528e3e3e42fc"}, ] [package.dependencies] @@ -2001,7 +1230,6 @@ anyio = "*" certifi = "*" httpcore = "==1.*" idna = "*" -sniffio = "*" [package.extras] brotli = ["brotli ; platform_python_implementation == \"CPython\"", "brotlicffi ; platform_python_implementation != \"CPython\""] @@ -2045,6 +1273,21 @@ testing = ["InquirerPy (==0.3.4)", "Jinja2", "Pillow", "aiohttp", "fastapi", "gr torch = ["safetensors[torch]", "torch"] typing = ["types-PyYAML", "types-requests", "types-simplejson", "types-toml", "types-tqdm", "types-urllib3", "typing-extensions (>=4.8.0)"] +[[package]] +name = "humanfriendly" +version = "10.0" +description = "Human friendly output for text interfaces using Python" +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*" +groups = ["main"] +files = [ + {file = "humanfriendly-10.0-py2.py3-none-any.whl", hash = "sha256:1697e1a8a8f550fd43c2865cd84542fc175a61dcb779b6fee18cf6b6ccba1477"}, + {file = "humanfriendly-10.0.tar.gz", hash = "sha256:6b0b831ce8f15f7300721aa49829fc4e83921a9a301cc7f606be6686a2288ddc"}, +] + +[package.dependencies] +pyreadline3 = {version = "*", markers = "sys_platform == \"win32\" and python_version >= \"3.8\""} + [[package]] name = "identify" version = "2.6.9" @@ -2140,31 +1383,6 @@ Pillow = "*" [package.extras] gui = ["tkinter"] -[[package]] -name = "importlib-metadata" -version = "8.6.1" -description = "Read metadata from Python packages" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "importlib_metadata-8.6.1-py3-none-any.whl", hash = "sha256:02a89390c1e15fdfdc0d7c6b25cb3e62650d0494005c97d6f148bf5b9787525e"}, - {file = "importlib_metadata-8.6.1.tar.gz", hash = "sha256:310b41d755445d74569f993ccfc22838295d9fe005425094fad953d7f15c8580"}, -] - -[package.dependencies] -zipp = ">=3.20" - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -enabler = ["pytest-enabler (>=2.2)"] -perf = ["ipython"] -test = ["flufl.flake8", "importlib_resources (>=1.3) ; python_version < \"3.9\"", "jaraco.test (>=5.4)", "packaging", "pyfakefs", "pytest (>=6,!=8.1.*)", "pytest-perf (>=0.9.2)"] -type = ["pytest-mypy"] - [[package]] name = "iniconfig" version = "2.1.0" @@ -2423,32 +1641,6 @@ files = [ {file = "jmespath-1.0.1.tar.gz", hash = "sha256:90261b206d6defd58fdd5e85f478bf633a2901798906be2ad389150c5c60edbe"}, ] -[[package]] -name = "joblib" -version = "1.4.2" -description = "Lightweight pipelining with Python functions" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "joblib-1.4.2-py3-none-any.whl", hash = "sha256:06d478d5674cbc267e7496a410ee875abd68e4340feff4490bcb7afb88060ae6"}, - {file = "joblib-1.4.2.tar.gz", hash = "sha256:2382c5816b2636fbd20a09e0f4e9dad4736765fdfb7dca582943b9c1366b3f0e"}, -] - -[[package]] -name = "json-repair" -version = "0.40.0" -description = "A package to repair broken json strings" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "json_repair-0.40.0-py3-none-any.whl", hash = "sha256:46955bfd22338ba60cc5239c0b01462ba419871b19fcd68d8881aca4fa3b0d2f"}, - {file = "json_repair-0.40.0.tar.gz", hash = "sha256:ce3cdef63f033d072295ca892cba51487292cd937da42dc20a8d629ecf5eb82d"}, -] - [[package]] name = "json5" version = "0.12.0" @@ -2482,12 +1674,11 @@ version = "4.23.0" description = "An implementation of JSON Schema validation for Python" optional = false python-versions = ">=3.8" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "jsonschema-4.23.0-py3-none-any.whl", hash = "sha256:fbadb6f8b144a8f8cf9f0b89ba94501d143e50411a1278633f56a7acf7fd5566"}, {file = "jsonschema-4.23.0.tar.gz", hash = "sha256:d71497fef26351a33265337fa77ffeb82423f3ea21283cd9467bb03999266bc4"}, ] -markers = {main = "extra == \"llm\""} [package.dependencies] attrs = ">=22.2.0" @@ -2513,12 +1704,11 @@ version = "2024.10.1" description = "The JSON Schema meta-schemas and vocabularies, exposed as a Registry" optional = false python-versions = ">=3.9" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "jsonschema_specifications-2024.10.1-py3-none-any.whl", hash = "sha256:a09a0680616357d9a0ecf05c12ad234479f549239d0f5b55f3deea67475da9bf"}, {file = "jsonschema_specifications-2024.10.1.tar.gz", hash = "sha256:0f38b83639958ce1152d02a7f062902c41c8fd20d558b0c34344292d417ae272"}, ] -markers = {main = "extra == \"llm\""} [package.dependencies] referencing = ">=0.31.0" @@ -3029,50 +2219,6 @@ files = [ [package.dependencies] rapidfuzz = ">=3.9.0,<4.0.0" -[[package]] -name = "litellm" -version = "1.53.7" -description = "Library to easily interface with LLM API providers" -optional = true -python-versions = "!=2.7.*,!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,!=3.7.*,>=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "litellm-1.53.7-py3-none-any.whl", hash = "sha256:f6d58a6bebe8cb530d6e3d45ae6f2f648546687d5fd3eb2e064ac8292b50b9c1"}, - {file = "litellm-1.53.7.tar.gz", hash = "sha256:1b00bb3b7f8f35b0843abc1ced98e7bb0580430ca027f6710128dc1346fb1073"}, -] - -[package.dependencies] -aiohttp = "*" -apscheduler = {version = ">=3.10.4,<4.0.0", optional = true, markers = "extra == \"proxy\""} -backoff = {version = "*", optional = true, markers = "extra == \"proxy\""} -click = "*" -cryptography = {version = ">=42.0.5,<43.0.0", optional = true, markers = "extra == \"proxy\""} -fastapi = {version = ">=0.111.0,<0.112.0", optional = true, markers = "extra == \"proxy\""} -fastapi-sso = {version = ">=0.10.0,<0.11.0", optional = true, markers = "extra == \"proxy\""} -gunicorn = {version = ">=22.0.0,<23.0.0", optional = true, markers = "extra == \"proxy\""} -httpx = ">=0.23.0,<0.28.0" -importlib-metadata = ">=6.8.0" -jinja2 = ">=3.1.2,<4.0.0" -jsonschema = ">=4.22.0,<5.0.0" -openai = ">=1.55.3" -orjson = {version = ">=3.9.7,<4.0.0", optional = true, markers = "extra == \"proxy\""} -pydantic = ">=2.0.0,<3.0.0" -PyJWT = {version = ">=2.8.0,<3.0.0", optional = true, markers = "extra == \"proxy\""} -pynacl = {version = ">=1.5.0,<2.0.0", optional = true, markers = "extra == \"proxy\""} -python-dotenv = ">=0.2.0" -python-multipart = {version = ">=0.0.9,<0.0.10", optional = true, markers = "extra == \"proxy\""} -pyyaml = {version = ">=6.0.1,<7.0.0", optional = true, markers = "extra == \"proxy\""} -requests = ">=2.31.0,<3.0.0" -rq = {version = "*", optional = true, markers = "extra == \"proxy\""} -tiktoken = ">=0.7.0" -tokenizers = "*" -uvicorn = {version = ">=0.22.0,<0.23.0", optional = true, markers = "extra == \"proxy\""} - -[package.extras] -extra-proxy = ["azure-identity (>=1.15.0,<2.0.0)", "azure-keyvault-secrets (>=4.8.0,<5.0.0)", "google-cloud-kms (>=2.21.3,<3.0.0)", "prisma (==0.11.0)", "resend (>=0.8.0,<0.9.0)"] -proxy = ["PyJWT (>=2.8.0,<3.0.0)", "apscheduler (>=3.10.4,<4.0.0)", "backoff", "cryptography (>=42.0.5,<43.0.0)", "fastapi (>=0.111.0,<0.112.0)", "fastapi-sso (>=0.10.0,<0.11.0)", "gunicorn (>=22.0.0,<23.0.0)", "orjson (>=3.9.7,<4.0.0)", "pynacl (>=1.5.0,<2.0.0)", "python-multipart (>=0.0.9,<0.0.10)", "pyyaml (>=6.0.1,<7.0.0)", "rq", "uvicorn (>=0.22.0,<0.23.0)"] - [[package]] name = "lxml" version = "5.4.0" @@ -3222,65 +2368,6 @@ html5 = ["html5lib"] htmlsoup = ["BeautifulSoup4"] source = ["Cython (>=3.0.11,<3.1.0)"] -[[package]] -name = "magicattr" -version = "0.1.6" -description = "A getattr and setattr that works on nested objects, lists, dicts, and any combination thereof without resorting to eval" -optional = true -python-versions = "*" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "magicattr-0.1.6-py2.py3-none-any.whl", hash = "sha256:d96b18ee45b5ee83b09c17e15d3459a64de62d538808c2f71182777dd9dbbbdf"}, -] - -[[package]] -name = "mako" -version = "1.3.9" -description = "A super-fast templating language that borrows the best ideas from the existing templating languages." -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "Mako-1.3.9-py3-none-any.whl", hash = "sha256:95920acccb578427a9aa38e37a186b1e43156c87260d7ba18ca63aa4c7cbd3a1"}, - {file = "mako-1.3.9.tar.gz", hash = "sha256:b5d65ff3462870feec922dbccf38f6efb44e5714d7b593a656be86663d8600ac"}, -] - -[package.dependencies] -MarkupSafe = ">=0.9.2" - -[package.extras] -babel = ["Babel"] -lingua = ["lingua"] -testing = ["pytest"] - -[[package]] -name = "markdown-it-py" -version = "3.0.0" -description = "Python port of markdown-it. Markdown parsing, done right!" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb"}, - {file = "markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1"}, -] - -[package.dependencies] -mdurl = ">=0.1,<1.0" - -[package.extras] -benchmarking = ["psutil", "pytest", "pytest-benchmark"] -code-style = ["pre-commit (>=3.0,<4.0)"] -compare = ["commonmark (>=0.9,<1.0)", "markdown (>=3.4,<4.0)", "mistletoe (>=1.0,<2.0)", "mistune (>=2.0,<3.0)", "panflute (>=2.3,<3.0)"] -linkify = ["linkify-it-py (>=1,<3)"] -plugins = ["mdit-py-plugins"] -profiling = ["gprof2dot"] -rtd = ["jupyter_sphinx", "mdit-py-plugins", "myst-parser", "pyyaml", "sphinx", "sphinx-copybutton", "sphinx-design", "sphinx_book_theme"] -testing = ["coverage", "pytest", "pytest-cov", "pytest-regressions"] - [[package]] name = "markupsafe" version = "3.0.2" @@ -3425,19 +2512,6 @@ files = [ [package.dependencies] traitlets = "*" -[[package]] -name = "mdurl" -version = "0.1.2" -description = "Markdown URL utilities" -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8"}, - {file = "mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba"}, -] - [[package]] name = "mistune" version = "3.1.3" @@ -3471,138 +2545,6 @@ docs = ["sphinx"] gmpy = ["gmpy2 (>=2.1.0a4) ; platform_python_implementation != \"PyPy\""] tests = ["pytest (>=4.6)"] -[[package]] -name = "multidict" -version = "6.3.2" -description = "multidict implementation" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "multidict-6.3.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8b3dc0eec9304fa04d84a51ea13b0ec170bace5b7ddeaac748149efd316f1504"}, - {file = "multidict-6.3.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9534f3d84addd3b6018fa83f97c9d4247aaa94ac917d1ed7b2523306f99f5c16"}, - {file = "multidict-6.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a003ce1413ae01f0b8789c1c987991346a94620a4d22210f7a8fe753646d3209"}, - {file = "multidict-6.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b43f7384e68b1b982c99f489921a459467b5584bdb963b25e0df57c9039d0ad"}, - {file = "multidict-6.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d142ae84047262dc75c1f92eaf95b20680f85ce11d35571b4c97e267f96fadc4"}, - {file = "multidict-6.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:ec7e86fbc48aa1d6d686501a8547818ba8d645e7e40eaa98232a5d43ee4380ad"}, - {file = "multidict-6.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fe019fb437632b016e6cac67a7e964f1ef827ef4023f1ca0227b54be354da97e"}, - {file = "multidict-6.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2b60cb81214a9da7cfd8ae2853d5e6e47225ece55fe5833142fe0af321c35299"}, - {file = "multidict-6.3.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:32d9e8ef2e0312d4e96ca9adc88e0675b6d8e144349efce4a7c95d5ccb6d88e0"}, - {file = "multidict-6.3.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:335d584312e3fa43633d63175dfc1a5f137dd7aa03d38d1310237d54c3032774"}, - {file = "multidict-6.3.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:b8df917faa6b8cac3d6870fc21cb7e4d169faca68e43ffe568c156c9c6408a4d"}, - {file = "multidict-6.3.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:cc060b9b89b701dd8fedef5b99e1f1002b8cb95072693233a63389d37e48212d"}, - {file = "multidict-6.3.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f2ce3be2500658f3c644494b934628bb0c82e549dde250d2119689ce791cc8b8"}, - {file = "multidict-6.3.2-cp310-cp310-win32.whl", hash = "sha256:dbcb4490d8e74b484449abd51751b8f560dd0a4812eb5dacc6a588498222a9ab"}, - {file = "multidict-6.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:06944f9ced30f8602be873563ed4df7e3f40958f60b2db39732c11d615a33687"}, - {file = "multidict-6.3.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:45a034f41fcd16968c0470d8912d293d7b0d0822fc25739c5c2ff7835b85bc56"}, - {file = "multidict-6.3.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:352585cec45f5d83d886fc522955492bb436fca032b11d487b12d31c5a81b9e3"}, - {file = "multidict-6.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:da9d89d293511fd0a83a90559dc131f8b3292b6975eb80feff19e5f4663647e2"}, - {file = "multidict-6.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79fa716592224aa652b9347a586cfe018635229074565663894eb4eb21f8307f"}, - {file = "multidict-6.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0326278a44c56e94792475268e5cd3d47fbc0bd41ee56928c3bbb103ba7f58fe"}, - {file = "multidict-6.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:bb1ea87f7fe45e5079f6315e95d64d4ca8b43ef656d98bed63a02e3756853a22"}, - {file = "multidict-6.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7cff3c5a98d037024a9065aafc621a8599fad7b423393685dc83cf7a32f8b691"}, - {file = "multidict-6.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ed99834b053c655d980fb98029003cb24281e47a796052faad4543aa9e01b8e8"}, - {file = "multidict-6.3.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7048440e505d2b4741e5d0b32bd2f427c901f38c7760fc245918be2cf69b3b85"}, - {file = "multidict-6.3.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:27248c27b563f5889556da8a96e18e98a56ff807ac1a7d56cf4453c2c9e4cd91"}, - {file = "multidict-6.3.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:6323b4ba0e018bd266f776c35f3f0943fc4ee77e481593c9f93bd49888f24e94"}, - {file = "multidict-6.3.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:81f7ce5ec7c27d0b45c10449c8f0fed192b93251e2e98cb0b21fec779ef1dc4d"}, - {file = "multidict-6.3.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:03bfcf2825b3bed0ba08a9d854acd18b938cab0d2dba3372b51c78e496bac811"}, - {file = "multidict-6.3.2-cp311-cp311-win32.whl", hash = "sha256:f32c2790512cae6ca886920e58cdc8c784bdc4bb2a5ec74127c71980369d18dc"}, - {file = "multidict-6.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:0b0c15e58e038a2cd75ef7cf7e072bc39b5e0488b165902efb27978984bbad70"}, - {file = "multidict-6.3.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:d1e0ba1ce1b8cc79117196642d95f4365e118eaf5fb85f57cdbcc5a25640b2a4"}, - {file = "multidict-6.3.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:029bbd7d782251a78975214b78ee632672310f9233d49531fc93e8e99154af25"}, - {file = "multidict-6.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:d7db41e3b56817d9175264e5fe00192fbcb8e1265307a59f53dede86161b150e"}, - {file = "multidict-6.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1fcab18e65cc555ac29981a581518c23311f2b1e72d8f658f9891590465383be"}, - {file = "multidict-6.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0d50eff89aa4d145a5486b171a2177042d08ea5105f813027eb1050abe91839f"}, - {file = "multidict-6.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:643e57b403d3e240045a3681f9e6a04d35a33eddc501b4cbbbdbc9c70122e7bc"}, - {file = "multidict-6.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d17b37b9715b30605b5bab1460569742d0c309e5c20079263b440f5d7746e7e"}, - {file = "multidict-6.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:68acd51fa94e63312b8ddf84bfc9c3d3442fe1f9988bbe1b6c703043af8867fe"}, - {file = "multidict-6.3.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:347eea2852ab7f697cc5ed9b1aae96b08f8529cca0c6468f747f0781b1842898"}, - {file = "multidict-6.3.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e4d3f8e57027dcda84a1aa181501c15c45eab9566eb6fcc274cbd1e7561224f8"}, - {file = "multidict-6.3.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:9ca57a841ffcf712e47875d026aa49d6e67f9560624d54b51628603700d5d287"}, - {file = "multidict-6.3.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7cafdafb44c4e646118410368307693e49d19167e5f119cbe3a88697d2d1a636"}, - {file = "multidict-6.3.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:430120c6ce3715a9c6075cabcee557daccbcca8ba25a9fedf05c7bf564532f2d"}, - {file = "multidict-6.3.2-cp312-cp312-win32.whl", hash = "sha256:13bec31375235a68457ab887ce1bbf4f59d5810d838ae5d7e5b416242e1f3ed4"}, - {file = "multidict-6.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:c3b6d7620e6e90c6d97eaf3a63bf7fbd2ba253aab89120a4a9c660bf2d675391"}, - {file = "multidict-6.3.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:b9ca24700322816ae0d426aa33671cf68242f8cc85cee0d0e936465ddaee90b5"}, - {file = "multidict-6.3.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d9fbbe23667d596ff4f9f74d44b06e40ebb0ab6b262cf14a284f859a66f86457"}, - {file = "multidict-6.3.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9cb602c5bea0589570ad3a4a6f2649c4f13cc7a1e97b4c616e5e9ff8dc490987"}, - {file = "multidict-6.3.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:93ca81dd4d1542e20000ed90f4cc84b7713776f620d04c2b75b8efbe61106c99"}, - {file = "multidict-6.3.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:18b6310b5454c62242577a128c87df8897f39dd913311cf2e1298e47dfc089eb"}, - {file = "multidict-6.3.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7a6dda57de1fc9aedfdb600a8640c99385cdab59a5716cb714b52b6005797f77"}, - {file = "multidict-6.3.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d8ec42d03cc6b29845552a68151f9e623c541f1708328353220af571e24a247"}, - {file = "multidict-6.3.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80681969cee2fa84dafeb53615d51d24246849984e3e87fbe4fe39956f2e23bf"}, - {file = "multidict-6.3.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:01489b0c3592bb9d238e5690e9566db7f77a5380f054b57077d2c4deeaade0eb"}, - {file = "multidict-6.3.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:522d9f1fd995d04dfedc0a40bca7e2591bc577d920079df50b56245a4a252c1c"}, - {file = "multidict-6.3.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:2014e9cf0b4e9c75bbad49c1758e5a9bf967a56184fc5fcc51527425baf5abba"}, - {file = "multidict-6.3.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:78ced9fcbee79e446ff4bb3018ac7ba1670703de7873d9c1f6f9883db53c71bc"}, - {file = "multidict-6.3.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1faf01af972bd01216a107c195f5294f9f393531bc3e4faddc9b333581255d4d"}, - {file = "multidict-6.3.2-cp313-cp313-win32.whl", hash = "sha256:7a699ab13d8d8e1f885de1535b4f477fb93836c87168318244c2685da7b7f655"}, - {file = "multidict-6.3.2-cp313-cp313-win_amd64.whl", hash = "sha256:8666bb0d883310c83be01676e302587834dfd185b52758caeab32ef0eb387bc6"}, - {file = "multidict-6.3.2-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:d82c95aabee29612b1c4f48b98be98181686eb7d6c0152301f72715705cc787b"}, - {file = "multidict-6.3.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:f47709173ea9e87a7fd05cd7e5cf1e5d4158924ff988a9a8e0fbd853705f0e68"}, - {file = "multidict-6.3.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0c7f9d0276ceaab41b8ae78534ff28ea33d5de85db551cbf80c44371f2b55d13"}, - {file = "multidict-6.3.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a6eab22df44a25acab2e738f882f5ec551282ab45b2bbda5301e6d2cfb323036"}, - {file = "multidict-6.3.2-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a947cb7c657f57874021b9b70c7aac049c877fb576955a40afa8df71d01a1390"}, - {file = "multidict-6.3.2-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5faa346e8e1c371187cf345ab1e02a75889f9f510c9cbc575c31b779f7df084d"}, - {file = "multidict-6.3.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dc6e08d977aebf1718540533b4ba5b351ccec2db093370958a653b1f7f9219cc"}, - {file = "multidict-6.3.2-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:98eab7acf55275b5bf09834125fa3a80b143a9f241cdcdd3f1295ffdc3c6d097"}, - {file = "multidict-6.3.2-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:36863655630becc224375c0b99364978a0f95aebfb27fb6dd500f7fb5fb36e79"}, - {file = "multidict-6.3.2-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:d9c0979c096c0d46a963331b0e400d3a9e560e41219df4b35f0d7a2f28f39710"}, - {file = "multidict-6.3.2-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:0efc04f70f05e70e5945890767e8874da5953a196f5b07c552d305afae0f3bf6"}, - {file = "multidict-6.3.2-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:2c519b3b82c34539fae3e22e4ea965869ac6b628794b1eb487780dde37637ab7"}, - {file = "multidict-6.3.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:329160e301f2afd7b43725d3dda8a7ef8ee41d4ceac2083fc0d8c1cc8a4bd56b"}, - {file = "multidict-6.3.2-cp313-cp313t-win32.whl", hash = "sha256:420e5144a5f598dad8db3128f1695cd42a38a0026c2991091dab91697832f8cc"}, - {file = "multidict-6.3.2-cp313-cp313t-win_amd64.whl", hash = "sha256:875faded2861c7af2682c67088e6313fec35ede811e071c96d36b081873cea14"}, - {file = "multidict-6.3.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:2516c5eb5732d6c4e29fa93323bfdc55186895124bc569e2404e3820934be378"}, - {file = "multidict-6.3.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:be5c8622e665cc5491c13c0fcd52915cdbae991a3514251d71129691338cdfb2"}, - {file = "multidict-6.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3ef33150eea7953cfdb571d862cff894e0ad97ab80d97731eb4b9328fc32d52b"}, - {file = "multidict-6.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:40b357738ce46e998f1b1bad9c4b79b2a9755915f71b87a8c01ce123a22a4f99"}, - {file = "multidict-6.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:27c60e059fcd3655a653ba99fec2556cd0260ec57f9cb138d3e6ffc413638a2e"}, - {file = "multidict-6.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:629e7c5e75bde83e54a22c7043ce89d68691d1f103be6d09a1c82b870df3b4b8"}, - {file = "multidict-6.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ee6c8fc97d893fdf1fff15a619fee8de2f31c9b289ef7594730e35074fa0cefb"}, - {file = "multidict-6.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:52081d2f27e0652265d4637b03f09b82f6da5ce5e1474f07dc64674ff8bfc04c"}, - {file = "multidict-6.3.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:64529dc395b5fd0a7826ffa70d2d9a7f4abd8f5333d6aaaba67fdf7bedde9f21"}, - {file = "multidict-6.3.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2b7c3fad827770840f5399348c89635ed6d6e9bba363baad7d3c7f86a9cf1da3"}, - {file = "multidict-6.3.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:24aa42b1651c654ae9e5273e06c3b7ccffe9f7cc76fbde40c37e9ae65f170818"}, - {file = "multidict-6.3.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:04ceea01e9991357164b12882e120ce6b4d63a0424bb9f9cd37910aa56d30830"}, - {file = "multidict-6.3.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:943897a41160945416617db567d867ab34e9258adaffc56a25a4c3f99d919598"}, - {file = "multidict-6.3.2-cp39-cp39-win32.whl", hash = "sha256:76157a9a0c5380aadd3b5ff7b8deee355ff5adecc66c837b444fa633b4d409a2"}, - {file = "multidict-6.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:d091d123e44035cd5664554308477aff0b58db37e701e7598a67e907b98d1925"}, - {file = "multidict-6.3.2-py3-none-any.whl", hash = "sha256:71409d4579f716217f23be2f5e7afca5ca926aaeb398aa11b72d793bff637a1f"}, - {file = "multidict-6.3.2.tar.gz", hash = "sha256:c1035eea471f759fa853dd6e76aaa1e389f93b3e1403093fa0fd3ab4db490678"}, -] - -[package.dependencies] -typing-extensions = {version = ">=4.1.0", markers = "python_version < \"3.11\""} - -[[package]] -name = "multiprocess" -version = "0.70.16" -description = "better multiprocessing and multithreading in Python" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "multiprocess-0.70.16-pp310-pypy310_pp73-macosx_10_13_x86_64.whl", hash = "sha256:476887be10e2f59ff183c006af746cb6f1fd0eadcfd4ef49e605cbe2659920ee"}, - {file = "multiprocess-0.70.16-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:d951bed82c8f73929ac82c61f01a7b5ce8f3e5ef40f5b52553b4f547ce2b08ec"}, - {file = "multiprocess-0.70.16-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:37b55f71c07e2d741374998c043b9520b626a8dddc8b3129222ca4f1a06ef67a"}, - {file = "multiprocess-0.70.16-pp38-pypy38_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:ba8c31889abf4511c7308a8c52bb4a30b9d590e7f58523302ba00237702ca054"}, - {file = "multiprocess-0.70.16-pp39-pypy39_pp73-macosx_10_13_x86_64.whl", hash = "sha256:0dfd078c306e08d46d7a8d06fb120313d87aa43af60d66da43ffff40b44d2f41"}, - {file = "multiprocess-0.70.16-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e7b9d0f307cd9bd50851afaac0dba2cb6c44449efff697df7c7645f7d3f2be3a"}, - {file = "multiprocess-0.70.16-py310-none-any.whl", hash = "sha256:c4a9944c67bd49f823687463660a2d6daae94c289adff97e0f9d696ba6371d02"}, - {file = "multiprocess-0.70.16-py311-none-any.whl", hash = "sha256:af4cabb0dac72abfb1e794fa7855c325fd2b55a10a44628a3c1ad3311c04127a"}, - {file = "multiprocess-0.70.16-py312-none-any.whl", hash = "sha256:fc0544c531920dde3b00c29863377f87e1632601092ea2daca74e4beb40faa2e"}, - {file = "multiprocess-0.70.16-py38-none-any.whl", hash = "sha256:a71d82033454891091a226dfc319d0cfa8019a4e888ef9ca910372a446de4435"}, - {file = "multiprocess-0.70.16-py39-none-any.whl", hash = "sha256:a0bafd3ae1b732eac64be2e72038231c1ba97724b60b09400d68f229fcc2fbf3"}, - {file = "multiprocess-0.70.16.tar.gz", hash = "sha256:161af703d4652a0e1410be6abccecde4a7ddffd19341be0a7011b94aeb171ac1"}, -] - -[package.dependencies] -dill = ">=0.3.8" - [[package]] name = "mypy-extensions" version = "1.0.0" @@ -3858,33 +2800,57 @@ files = [ ] [[package]] -name = "oauthlib" -version = "3.2.2" -description = "A generic, spec-compliant, thorough implementation of the OAuth request-signing logic" -optional = true -python-versions = ">=3.6" +name = "onnxruntime" +version = "1.15.1" +description = "ONNX Runtime is a runtime accelerator for Machine Learning models" +optional = false +python-versions = "*" groups = ["main"] -markers = "extra == \"llm\"" files = [ - {file = "oauthlib-3.2.2-py3-none-any.whl", hash = "sha256:8139f29aac13e25d502680e9e19963e83f16838d48a0d71c287fe40e7067fbca"}, - {file = "oauthlib-3.2.2.tar.gz", hash = "sha256:9859c40929662bec5d64f34d01c99e093149682a3f38915dc0655d5a633dd918"}, -] - -[package.extras] -rsa = ["cryptography (>=3.0.0)"] -signals = ["blinker (>=1.4.0)"] -signedtoken = ["cryptography (>=3.0.0)", "pyjwt (>=2.0.0,<3)"] + {file = "onnxruntime-1.15.1-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:baad59e6a763237fa39545325d29c16f98b8a45d2dfc524c67631e2e3ba44d16"}, + {file = "onnxruntime-1.15.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:568c2db848f619a0a93e843c028e9fb4879929d40b04bd60f9ba6eb8d2e93421"}, + {file = "onnxruntime-1.15.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:69088d7784bb04dedfd9e883e2c96e4adf8ae0451acdd0abb78d68f59ecc6d9d"}, + {file = "onnxruntime-1.15.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3cef43737b2cd886d5d718d100f56ec78c9c476c5db5f8f946e95024978fe754"}, + {file = "onnxruntime-1.15.1-cp310-cp310-win32.whl", hash = "sha256:79d7e65abb44a47c633ede8e53fe7b9756c272efaf169758c482c983cca98d7e"}, + {file = "onnxruntime-1.15.1-cp310-cp310-win_amd64.whl", hash = "sha256:8bc4c47682933a7a2c79808688aad5f12581305e182be552de50783b5438e6bd"}, + {file = "onnxruntime-1.15.1-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:652b2cb777f76446e3cc41072dd3d1585a6388aeff92b9de656724bc22e241e4"}, + {file = "onnxruntime-1.15.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:89b86dbed15740abc385055a29c9673a212600248d702737ce856515bdeddc88"}, + {file = "onnxruntime-1.15.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed5cdd9ee748149a57f4cdfa67187a0d68f75240645a3c688299dcd08742cc98"}, + {file = "onnxruntime-1.15.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2f748cce6a70ed38c19658615c55f4eedb9192765a4e9c4bd2682adfe980698d"}, + {file = "onnxruntime-1.15.1-cp311-cp311-win32.whl", hash = "sha256:e0312046e814c40066e7823da58075992d51364cbe739eeeb2345ec440c3ac59"}, + {file = "onnxruntime-1.15.1-cp311-cp311-win_amd64.whl", hash = "sha256:f0980969689cb956c22bd1318b271e1be260060b37f3ddd82c7d63bd7f2d9a79"}, + {file = "onnxruntime-1.15.1-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:345986cfdbd6f4b20a89b6a6cd9abd3e2ced2926ae0b6e91fefa8149f95c0f09"}, + {file = "onnxruntime-1.15.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a4d7b3ad75e040f1e95757f69826a11051737b31584938a26d466a0234c6de98"}, + {file = "onnxruntime-1.15.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3603d07b829bcc1c14963a76103e257aade8861eb208173b300cc26e118ec2f8"}, + {file = "onnxruntime-1.15.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d3df0625b9295daf1f7409ea55f72e1eeb38d54f5769add53372e79ddc3cf98d"}, + {file = "onnxruntime-1.15.1-cp38-cp38-win32.whl", hash = "sha256:f68b47fdf1a0406c0292f81ac993e2a2ae3e8b166b436d590eb221f64e8e187a"}, + {file = "onnxruntime-1.15.1-cp38-cp38-win_amd64.whl", hash = "sha256:52d762d297cc3f731f54fa65a3e329b813164970671547bef6414d0ed52765c9"}, + {file = "onnxruntime-1.15.1-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:99228f9f03dc1fc8af89a28c9f942e8bd3e97e894e263abe1a32e4ddb1f6363b"}, + {file = "onnxruntime-1.15.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:45db7f96febb0cf23e3af147f35c4f8de1a37dd252d1cef853c242c2780250cd"}, + {file = "onnxruntime-1.15.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bafc112a36db25c821b90ab747644041cb4218f6575889775a2c12dd958b8c3"}, + {file = "onnxruntime-1.15.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:985693d18f2d46aa34fd44d7f65ff620660b2c8fa4b8ec365c2ca353f0fbdb27"}, + {file = "onnxruntime-1.15.1-cp39-cp39-win32.whl", hash = "sha256:708eb31b0c04724bf0f01c1309a9e69bbc09b85beb750e5662c8aed29f1ff9fd"}, + {file = "onnxruntime-1.15.1-cp39-cp39-win_amd64.whl", hash = "sha256:73d6de4c42dfde1e9dbea04773e6dc23346c8cda9c7e08c6554fafc97ac60138"}, +] + +[package.dependencies] +coloredlogs = "*" +flatbuffers = "*" +numpy = ">=1.21.6" +packaging = "*" +protobuf = "*" +sympy = "*" [[package]] name = "openai" -version = "1.71.0" +version = "1.88.0" description = "The official Python library for the openai API" optional = false python-versions = ">=3.8" groups = ["main"] files = [ - {file = "openai-1.71.0-py3-none-any.whl", hash = "sha256:e1c643738f1fff1af52bce6ef06a7716c95d089281e7011777179614f32937aa"}, - {file = "openai-1.71.0.tar.gz", hash = "sha256:52b20bb990a1780f9b0b8ccebac93416343ebd3e4e714e3eff730336833ca207"}, + {file = "openai-1.88.0-py3-none-any.whl", hash = "sha256:7edd7826b3b83f5846562a6f310f040c79576278bf8e3687b30ba05bb5dff978"}, + {file = "openai-1.88.0.tar.gz", hash = "sha256:122d35e42998255cf1fc84560f6ee49a844e65c054cd05d3e42fda506b832bb1"}, ] [package.dependencies] @@ -3927,138 +2893,28 @@ numpy = [ {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, ] -[[package]] -name = "opencv-python-headless" -version = "4.11.0.86" -description = "Wrapper package for OpenCV python bindings." -optional = true -python-versions = ">=3.6" -groups = ["main"] -markers = "extra == \"ocr\"" -files = [ - {file = "opencv-python-headless-4.11.0.86.tar.gz", hash = "sha256:996eb282ca4b43ec6a3972414de0e2331f5d9cda2b41091a49739c19fb843798"}, - {file = "opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_arm64.whl", hash = "sha256:48128188ade4a7e517237c8e1e11a9cdf5c282761473383e77beb875bb1e61ca"}, - {file = "opencv_python_headless-4.11.0.86-cp37-abi3-macosx_13_0_x86_64.whl", hash = "sha256:a66c1b286a9de872c343ee7c3553b084244299714ebb50fbdcd76f07ebbe6c81"}, - {file = "opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6efabcaa9df731f29e5ea9051776715b1bdd1845d7c9530065c7951d2a2899eb"}, - {file = "opencv_python_headless-4.11.0.86-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e0a27c19dd1f40ddff94976cfe43066fbbe9dfbb2ec1907d66c19caef42a57b"}, - {file = "opencv_python_headless-4.11.0.86-cp37-abi3-win32.whl", hash = "sha256:f447d8acbb0b6f2808da71fddd29c1cdd448d2bc98f72d9bb78a7a898fc9621b"}, - {file = "opencv_python_headless-4.11.0.86-cp37-abi3-win_amd64.whl", hash = "sha256:6c304df9caa7a6a5710b91709dd4786bf20a74d57672b3c31f7033cc638174ca"}, -] - -[package.dependencies] -numpy = [ - {version = ">=1.21.4", markers = "python_version >= \"3.10\" and platform_system == \"Darwin\""}, - {version = ">=1.21.2", markers = "platform_system != \"Darwin\" and python_version >= \"3.10\""}, - {version = ">=1.23.5", markers = "python_version >= \"3.11\""}, - {version = ">=1.26.0", markers = "python_version >= \"3.12\""}, -] - -[[package]] -name = "optuna" -version = "4.2.1" -description = "A hyperparameter optimization framework" -optional = true -python-versions = ">=3.8" +[[package]] +name = "opencv-python-headless" +version = "4.8.1.78" +description = "Wrapper package for OpenCV python bindings." +optional = false +python-versions = ">=3.6" groups = ["main"] -markers = "extra == \"llm\"" files = [ - {file = "optuna-4.2.1-py3-none-any.whl", hash = "sha256:6d38199013441d3f70fac27136e05c0188c5f4ec3848db708ac311cbdeb30dbf"}, - {file = "optuna-4.2.1.tar.gz", hash = "sha256:2ecd74cdc8aaf5dda1f2b9e267999bab21def9a33e0a4f415ecae0c468c401e0"}, + {file = "opencv-python-headless-4.8.1.78.tar.gz", hash = "sha256:bc7197b42352f6f865c302a49140b889ec7cd957dd697e2d7fc016ad0d3f28f1"}, + {file = "opencv_python_headless-4.8.1.78-cp37-abi3-macosx_10_16_x86_64.whl", hash = "sha256:f3a33f644249f9ce1c913eac580e4b3ef4ce7cab0a71900274708959c2feb5e3"}, + {file = "opencv_python_headless-4.8.1.78-cp37-abi3-macosx_11_0_arm64.whl", hash = "sha256:2c7d45721df9801c4dcd34683a15caa0e30f38b185263fec04a6eb274bc720f0"}, + {file = "opencv_python_headless-4.8.1.78-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3b6bd6e1132b6f5dcb3a5bfe30fc4d341a7bfb26134da349a06c9255288ded94"}, + {file = "opencv_python_headless-4.8.1.78-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:58e70d2f0915fe23e02c6e405588276c9397844a47d38b9c87fac5f7f9ba2dcc"}, + {file = "opencv_python_headless-4.8.1.78-cp37-abi3-win32.whl", hash = "sha256:382f8c7a6a14f80091284eecedd52cee4812231ee0eff1118592197b538d9252"}, + {file = "opencv_python_headless-4.8.1.78-cp37-abi3-win_amd64.whl", hash = "sha256:0a0f1e9f836f7d5bad1dd164694944c8761711cbdf4b36ebbd4815a8ef731079"}, ] [package.dependencies] -alembic = ">=1.5.0" -colorlog = "*" -numpy = "*" -packaging = ">=20.0" -PyYAML = "*" -sqlalchemy = ">=1.4.2" -tqdm = "*" - -[package.extras] -benchmark = ["asv (>=0.5.0)", "cma", "virtualenv"] -checking = ["black", "blackdoc", "flake8", "isort", "mypy", "mypy_boto3_s3", "types-PyYAML", "types-redis", "types-setuptools", "types-tqdm", "typing_extensions (>=3.10.0.0)"] -document = ["ase", "cmaes (>=0.10.0)", "fvcore", "kaleido (<0.4)", "lightgbm", "matplotlib (!=3.6.0)", "pandas", "pillow", "plotly (>=4.9.0)", "scikit-learn", "sphinx", "sphinx-copybutton", "sphinx-gallery", "sphinx-notfound-page", "sphinx_rtd_theme (>=1.2.0)", "torch", "torchvision"] -optional = ["boto3", "cmaes (>=0.10.0)", "google-cloud-storage", "grpcio", "matplotlib (!=3.6.0)", "pandas", "plotly (>=4.9.0)", "protobuf (>=5.28.1)", "redis", "scikit-learn (>=0.24.2)", "scipy", "torch ; python_version <= \"3.12\""] -test = ["coverage", "fakeredis[lua]", "grpcio", "kaleido (<0.4)", "moto", "protobuf (>=5.28.1)", "pytest", "scipy (>=1.9.2)", "torch ; python_version <= \"3.12\""] - -[[package]] -name = "orjson" -version = "3.10.16" -description = "Fast, correct Python JSON library supporting dataclasses, datetimes, and numpy" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "orjson-3.10.16-cp310-cp310-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:4cb473b8e79154fa778fb56d2d73763d977be3dcc140587e07dbc545bbfc38f8"}, - {file = "orjson-3.10.16-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:622a8e85eeec1948690409a19ca1c7d9fd8ff116f4861d261e6ae2094fe59a00"}, - {file = "orjson-3.10.16-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c682d852d0ce77613993dc967e90e151899fe2d8e71c20e9be164080f468e370"}, - {file = "orjson-3.10.16-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8c520ae736acd2e32df193bcff73491e64c936f3e44a2916b548da048a48b46b"}, - {file = "orjson-3.10.16-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:134f87c76bfae00f2094d85cfab261b289b76d78c6da8a7a3b3c09d362fd1e06"}, - {file = "orjson-3.10.16-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:b59afde79563e2cf37cfe62ee3b71c063fd5546c8e662d7fcfc2a3d5031a5c4c"}, - {file = "orjson-3.10.16-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:113602f8241daaff05d6fad25bd481d54c42d8d72ef4c831bb3ab682a54d9e15"}, - {file = "orjson-3.10.16-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4fc0077d101f8fab4031e6554fc17b4c2ad8fdbc56ee64a727f3c95b379e31da"}, - {file = "orjson-3.10.16-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:9c6bf6ff180cd69e93f3f50380224218cfab79953a868ea3908430bcfaf9cb5e"}, - {file = "orjson-3.10.16-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:5673eadfa952f95a7cd76418ff189df11b0a9c34b1995dff43a6fdbce5d63bf4"}, - {file = "orjson-3.10.16-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:5fe638a423d852b0ae1e1a79895851696cb0d9fa0946fdbfd5da5072d9bb9551"}, - {file = "orjson-3.10.16-cp310-cp310-win32.whl", hash = "sha256:33af58f479b3c6435ab8f8b57999874b4b40c804c7a36b5cc6b54d8f28e1d3dd"}, - {file = "orjson-3.10.16-cp310-cp310-win_amd64.whl", hash = "sha256:0338356b3f56d71293c583350af26f053017071836b07e064e92819ecf1aa055"}, - {file = "orjson-3.10.16-cp311-cp311-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:44fcbe1a1884f8bc9e2e863168b0f84230c3d634afe41c678637d2728ea8e739"}, - {file = "orjson-3.10.16-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78177bf0a9d0192e0b34c3d78bcff7fe21d1b5d84aeb5ebdfe0dbe637b885225"}, - {file = "orjson-3.10.16-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:12824073a010a754bb27330cad21d6e9b98374f497f391b8707752b96f72e741"}, - {file = "orjson-3.10.16-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ddd41007e56284e9867864aa2f29f3136bb1dd19a49ca43c0b4eda22a579cf53"}, - {file = "orjson-3.10.16-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:0877c4d35de639645de83666458ca1f12560d9fa7aa9b25d8bb8f52f61627d14"}, - {file = "orjson-3.10.16-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9a09a539e9cc3beead3e7107093b4ac176d015bec64f811afb5965fce077a03c"}, - {file = "orjson-3.10.16-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:31b98bc9b40610fec971d9a4d67bb2ed02eec0a8ae35f8ccd2086320c28526ca"}, - {file = "orjson-3.10.16-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0ce243f5a8739f3a18830bc62dc2e05b69a7545bafd3e3249f86668b2bcd8e50"}, - {file = "orjson-3.10.16-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:64792c0025bae049b3074c6abe0cf06f23c8e9f5a445f4bab31dc5ca23dbf9e1"}, - {file = "orjson-3.10.16-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ea53f7e68eec718b8e17e942f7ca56c6bd43562eb19db3f22d90d75e13f0431d"}, - {file = "orjson-3.10.16-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a741ba1a9488c92227711bde8c8c2b63d7d3816883268c808fbeada00400c164"}, - {file = "orjson-3.10.16-cp311-cp311-win32.whl", hash = "sha256:c7ed2c61bb8226384c3fdf1fb01c51b47b03e3f4536c985078cccc2fd19f1619"}, - {file = "orjson-3.10.16-cp311-cp311-win_amd64.whl", hash = "sha256:cd67d8b3e0e56222a2e7b7f7da9031e30ecd1fe251c023340b9f12caca85ab60"}, - {file = "orjson-3.10.16-cp312-cp312-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:6d3444abbfa71ba21bb042caa4b062535b122248259fdb9deea567969140abca"}, - {file = "orjson-3.10.16-cp312-cp312-macosx_15_0_arm64.whl", hash = "sha256:30245c08d818fdcaa48b7d5b81499b8cae09acabb216fe61ca619876b128e184"}, - {file = "orjson-3.10.16-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a0ba1d0baa71bf7579a4ccdcf503e6f3098ef9542106a0eca82395898c8a500a"}, - {file = "orjson-3.10.16-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:eb0beefa5ef3af8845f3a69ff2a4aa62529b5acec1cfe5f8a6b4141033fd46ef"}, - {file = "orjson-3.10.16-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6daa0e1c9bf2e030e93c98394de94506f2a4d12e1e9dadd7c53d5e44d0f9628e"}, - {file = "orjson-3.10.16-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9da9019afb21e02410ef600e56666652b73eb3e4d213a0ec919ff391a7dd52aa"}, - {file = "orjson-3.10.16-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:daeb3a1ee17b69981d3aae30c3b4e786b0f8c9e6c71f2b48f1aef934f63f38f4"}, - {file = "orjson-3.10.16-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80fed80eaf0e20a31942ae5d0728849862446512769692474be5e6b73123a23b"}, - {file = "orjson-3.10.16-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:73390ed838f03764540a7bdc4071fe0123914c2cc02fb6abf35182d5fd1b7a42"}, - {file = "orjson-3.10.16-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:a22bba012a0c94ec02a7768953020ab0d3e2b884760f859176343a36c01adf87"}, - {file = "orjson-3.10.16-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5385bbfdbc90ff5b2635b7e6bebf259652db00a92b5e3c45b616df75b9058e88"}, - {file = "orjson-3.10.16-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:02c6279016346e774dd92625d46c6c40db687b8a0d685aadb91e26e46cc33e1e"}, - {file = "orjson-3.10.16-cp312-cp312-win32.whl", hash = "sha256:7ca55097a11426db80f79378e873a8c51f4dde9ffc22de44850f9696b7eb0e8c"}, - {file = "orjson-3.10.16-cp312-cp312-win_amd64.whl", hash = "sha256:86d127efdd3f9bf5f04809b70faca1e6836556ea3cc46e662b44dab3fe71f3d6"}, - {file = "orjson-3.10.16-cp313-cp313-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:148a97f7de811ba14bc6dbc4a433e0341ffd2cc285065199fb5f6a98013744bd"}, - {file = "orjson-3.10.16-cp313-cp313-macosx_15_0_arm64.whl", hash = "sha256:1d960c1bf0e734ea36d0adc880076de3846aaec45ffad29b78c7f1b7962516b8"}, - {file = "orjson-3.10.16-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a318cd184d1269f68634464b12871386808dc8b7c27de8565234d25975a7a137"}, - {file = "orjson-3.10.16-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:df23f8df3ef9223d1d6748bea63fca55aae7da30a875700809c500a05975522b"}, - {file = "orjson-3.10.16-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b94dda8dd6d1378f1037d7f3f6b21db769ef911c4567cbaa962bb6dc5021cf90"}, - {file = "orjson-3.10.16-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f12970a26666a8775346003fd94347d03ccb98ab8aa063036818381acf5f523e"}, - {file = "orjson-3.10.16-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:15a1431a245d856bd56e4d29ea0023eb4d2c8f71efe914beb3dee8ab3f0cd7fb"}, - {file = "orjson-3.10.16-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c83655cfc247f399a222567d146524674a7b217af7ef8289c0ff53cfe8db09f0"}, - {file = "orjson-3.10.16-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:fa59ae64cb6ddde8f09bdbf7baf933c4cd05734ad84dcf4e43b887eb24e37652"}, - {file = "orjson-3.10.16-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:ca5426e5aacc2e9507d341bc169d8af9c3cbe88f4cd4c1cf2f87e8564730eb56"}, - {file = "orjson-3.10.16-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:6fd5da4edf98a400946cd3a195680de56f1e7575109b9acb9493331047157430"}, - {file = "orjson-3.10.16-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:980ecc7a53e567169282a5e0ff078393bac78320d44238da4e246d71a4e0e8f5"}, - {file = "orjson-3.10.16-cp313-cp313-win32.whl", hash = "sha256:28f79944dd006ac540a6465ebd5f8f45dfdf0948ff998eac7a908275b4c1add6"}, - {file = "orjson-3.10.16-cp313-cp313-win_amd64.whl", hash = "sha256:fe0a145e96d51971407cb8ba947e63ead2aa915db59d6631a355f5f2150b56b7"}, - {file = "orjson-3.10.16-cp39-cp39-macosx_10_15_x86_64.macosx_11_0_arm64.macosx_10_15_universal2.whl", hash = "sha256:c35b5c1fb5a5d6d2fea825dec5d3d16bea3c06ac744708a8e1ff41d4ba10cdf1"}, - {file = "orjson-3.10.16-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c9aac7ecc86218b4b3048c768f227a9452287001d7548500150bb75ee21bf55d"}, - {file = "orjson-3.10.16-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6e19f5102fff36f923b6dfdb3236ec710b649da975ed57c29833cb910c5a73ab"}, - {file = "orjson-3.10.16-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:17210490408eb62755a334a6f20ed17c39f27b4f45d89a38cd144cd458eba80b"}, - {file = "orjson-3.10.16-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fbbe04451db85916e52a9f720bd89bf41f803cf63b038595674691680cbebd1b"}, - {file = "orjson-3.10.16-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6a966eba501a3a1f309f5a6af32ed9eb8f316fa19d9947bac3e6350dc63a6f0a"}, - {file = "orjson-3.10.16-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:01e0d22f06c81e6c435723343e1eefc710e0510a35d897856766d475f2a15687"}, - {file = "orjson-3.10.16-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:7c1e602d028ee285dbd300fb9820b342b937df64d5a3336e1618b354e95a2569"}, - {file = "orjson-3.10.16-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:d230e5020666a6725629df81e210dc11c3eae7d52fe909a7157b3875238484f3"}, - {file = "orjson-3.10.16-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:0f8baac07d4555f57d44746a7d80fbe6b2c4fe2ed68136b4abb51cfec512a5e9"}, - {file = "orjson-3.10.16-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:524e48420b90fc66953e91b660b3d05faaf921277d6707e328fde1c218b31250"}, - {file = "orjson-3.10.16-cp39-cp39-win32.whl", hash = "sha256:a9f614e31423d7292dbca966a53b2d775c64528c7d91424ab2747d8ab8ce5c72"}, - {file = "orjson-3.10.16-cp39-cp39-win_amd64.whl", hash = "sha256:c338dc2296d1ed0d5c5c27dfb22d00b330555cb706c2e0be1e1c3940a0895905"}, - {file = "orjson-3.10.16.tar.gz", hash = "sha256:d2aaa5c495e11d17b9b93205f5fa196737ee3202f000aaebf028dc9a73750f10"}, +numpy = [ + {version = ">=1.21.4", markers = "python_version >= \"3.10\" and platform_system == \"Darwin\""}, + {version = ">=1.21.2", markers = "platform_system != \"Darwin\" and python_version >= \"3.10\""}, + {version = ">=1.23.5", markers = "python_version >= \"3.11\""}, ] [[package]] @@ -4485,112 +3341,22 @@ files = [ wcwidth = "*" [[package]] -name = "propcache" -version = "0.3.1" -description = "Accelerated property cache" -optional = true +name = "protobuf" +version = "6.31.1" +description = "" +optional = false python-versions = ">=3.9" groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "propcache-0.3.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:f27785888d2fdd918bc36de8b8739f2d6c791399552333721b58193f68ea3e98"}, - {file = "propcache-0.3.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d4e89cde74154c7b5957f87a355bb9c8ec929c167b59c83d90654ea36aeb6180"}, - {file = "propcache-0.3.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:730178f476ef03d3d4d255f0c9fa186cb1d13fd33ffe89d39f2cda4da90ceb71"}, - {file = "propcache-0.3.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:967a8eec513dbe08330f10137eacb427b2ca52118769e82ebcfcab0fba92a649"}, - {file = "propcache-0.3.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5b9145c35cc87313b5fd480144f8078716007656093d23059e8993d3a8fa730f"}, - {file = "propcache-0.3.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9e64e948ab41411958670f1093c0a57acfdc3bee5cf5b935671bbd5313bcf229"}, - {file = "propcache-0.3.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:319fa8765bfd6a265e5fa661547556da381e53274bc05094fc9ea50da51bfd46"}, - {file = "propcache-0.3.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c66d8ccbc902ad548312b96ed8d5d266d0d2c6d006fd0f66323e9d8f2dd49be7"}, - {file = "propcache-0.3.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:2d219b0dbabe75e15e581fc1ae796109b07c8ba7d25b9ae8d650da582bed01b0"}, - {file = "propcache-0.3.1-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:cd6a55f65241c551eb53f8cf4d2f4af33512c39da5d9777694e9d9c60872f519"}, - {file = "propcache-0.3.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:9979643ffc69b799d50d3a7b72b5164a2e97e117009d7af6dfdd2ab906cb72cd"}, - {file = "propcache-0.3.1-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:4cf9e93a81979f1424f1a3d155213dc928f1069d697e4353edb8a5eba67c6259"}, - {file = "propcache-0.3.1-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:2fce1df66915909ff6c824bbb5eb403d2d15f98f1518e583074671a30fe0c21e"}, - {file = "propcache-0.3.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4d0dfdd9a2ebc77b869a0b04423591ea8823f791293b527dc1bb896c1d6f1136"}, - {file = "propcache-0.3.1-cp310-cp310-win32.whl", hash = "sha256:1f6cc0ad7b4560e5637eb2c994e97b4fa41ba8226069c9277eb5ea7101845b42"}, - {file = "propcache-0.3.1-cp310-cp310-win_amd64.whl", hash = "sha256:47ef24aa6511e388e9894ec16f0fbf3313a53ee68402bc428744a367ec55b833"}, - {file = "propcache-0.3.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:7f30241577d2fef2602113b70ef7231bf4c69a97e04693bde08ddab913ba0ce5"}, - {file = "propcache-0.3.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:43593c6772aa12abc3af7784bff4a41ffa921608dd38b77cf1dfd7f5c4e71371"}, - {file = "propcache-0.3.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a75801768bbe65499495660b777e018cbe90c7980f07f8aa57d6be79ea6f71da"}, - {file = "propcache-0.3.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6f1324db48f001c2ca26a25fa25af60711e09b9aaf4b28488602776f4f9a744"}, - {file = "propcache-0.3.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5cdb0f3e1eb6dfc9965d19734d8f9c481b294b5274337a8cb5cb01b462dcb7e0"}, - {file = "propcache-0.3.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1eb34d90aac9bfbced9a58b266f8946cb5935869ff01b164573a7634d39fbcb5"}, - {file = "propcache-0.3.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f35c7070eeec2cdaac6fd3fe245226ed2a6292d3ee8c938e5bb645b434c5f256"}, - {file = "propcache-0.3.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b23c11c2c9e6d4e7300c92e022046ad09b91fd00e36e83c44483df4afa990073"}, - {file = "propcache-0.3.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:3e19ea4ea0bf46179f8a3652ac1426e6dcbaf577ce4b4f65be581e237340420d"}, - {file = "propcache-0.3.1-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:bd39c92e4c8f6cbf5f08257d6360123af72af9f4da75a690bef50da77362d25f"}, - {file = "propcache-0.3.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:b0313e8b923b3814d1c4a524c93dfecea5f39fa95601f6a9b1ac96cd66f89ea0"}, - {file = "propcache-0.3.1-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e861ad82892408487be144906a368ddbe2dc6297074ade2d892341b35c59844a"}, - {file = "propcache-0.3.1-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:61014615c1274df8da5991a1e5da85a3ccb00c2d4701ac6f3383afd3ca47ab0a"}, - {file = "propcache-0.3.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:71ebe3fe42656a2328ab08933d420df5f3ab121772eef78f2dc63624157f0ed9"}, - {file = "propcache-0.3.1-cp311-cp311-win32.whl", hash = "sha256:58aa11f4ca8b60113d4b8e32d37e7e78bd8af4d1a5b5cb4979ed856a45e62005"}, - {file = "propcache-0.3.1-cp311-cp311-win_amd64.whl", hash = "sha256:9532ea0b26a401264b1365146c440a6d78269ed41f83f23818d4b79497aeabe7"}, - {file = "propcache-0.3.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:f78eb8422acc93d7b69964012ad7048764bb45a54ba7a39bb9e146c72ea29723"}, - {file = "propcache-0.3.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:89498dd49c2f9a026ee057965cdf8192e5ae070ce7d7a7bd4b66a8e257d0c976"}, - {file = "propcache-0.3.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:09400e98545c998d57d10035ff623266927cb784d13dd2b31fd33b8a5316b85b"}, - {file = "propcache-0.3.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa8efd8c5adc5a2c9d3b952815ff8f7710cefdcaf5f2c36d26aff51aeca2f12f"}, - {file = "propcache-0.3.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c2fe5c910f6007e716a06d269608d307b4f36e7babee5f36533722660e8c4a70"}, - {file = "propcache-0.3.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a0ab8cf8cdd2194f8ff979a43ab43049b1df0b37aa64ab7eca04ac14429baeb7"}, - {file = "propcache-0.3.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:563f9d8c03ad645597b8d010ef4e9eab359faeb11a0a2ac9f7b4bc8c28ebef25"}, - {file = "propcache-0.3.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fb6e0faf8cb6b4beea5d6ed7b5a578254c6d7df54c36ccd3d8b3eb00d6770277"}, - {file = "propcache-0.3.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1c5c7ab7f2bb3f573d1cb921993006ba2d39e8621019dffb1c5bc94cdbae81e8"}, - {file = "propcache-0.3.1-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:050b571b2e96ec942898f8eb46ea4bfbb19bd5502424747e83badc2d4a99a44e"}, - {file = "propcache-0.3.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:e1c4d24b804b3a87e9350f79e2371a705a188d292fd310e663483af6ee6718ee"}, - {file = "propcache-0.3.1-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:e4fe2a6d5ce975c117a6bb1e8ccda772d1e7029c1cca1acd209f91d30fa72815"}, - {file = "propcache-0.3.1-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:feccd282de1f6322f56f6845bf1207a537227812f0a9bf5571df52bb418d79d5"}, - {file = "propcache-0.3.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:ec314cde7314d2dd0510c6787326bbffcbdc317ecee6b7401ce218b3099075a7"}, - {file = "propcache-0.3.1-cp312-cp312-win32.whl", hash = "sha256:7d2d5a0028d920738372630870e7d9644ce437142197f8c827194fca404bf03b"}, - {file = "propcache-0.3.1-cp312-cp312-win_amd64.whl", hash = "sha256:88c423efef9d7a59dae0614eaed718449c09a5ac79a5f224a8b9664d603f04a3"}, - {file = "propcache-0.3.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:f1528ec4374617a7a753f90f20e2f551121bb558fcb35926f99e3c42367164b8"}, - {file = "propcache-0.3.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:dc1915ec523b3b494933b5424980831b636fe483d7d543f7afb7b3bf00f0c10f"}, - {file = "propcache-0.3.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a110205022d077da24e60b3df8bcee73971be9575dec5573dd17ae5d81751111"}, - {file = "propcache-0.3.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d249609e547c04d190e820d0d4c8ca03ed4582bcf8e4e160a6969ddfb57b62e5"}, - {file = "propcache-0.3.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5ced33d827625d0a589e831126ccb4f5c29dfdf6766cac441d23995a65825dcb"}, - {file = "propcache-0.3.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4114c4ada8f3181af20808bedb250da6bae56660e4b8dfd9cd95d4549c0962f7"}, - {file = "propcache-0.3.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:975af16f406ce48f1333ec5e912fe11064605d5c5b3f6746969077cc3adeb120"}, - {file = "propcache-0.3.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a34aa3a1abc50740be6ac0ab9d594e274f59960d3ad253cd318af76b996dd654"}, - {file = "propcache-0.3.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:9cec3239c85ed15bfaded997773fdad9fb5662b0a7cbc854a43f291eb183179e"}, - {file = "propcache-0.3.1-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:05543250deac8e61084234d5fc54f8ebd254e8f2b39a16b1dce48904f45b744b"}, - {file = "propcache-0.3.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:5cb5918253912e088edbf023788de539219718d3b10aef334476b62d2b53de53"}, - {file = "propcache-0.3.1-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:f3bbecd2f34d0e6d3c543fdb3b15d6b60dd69970c2b4c822379e5ec8f6f621d5"}, - {file = "propcache-0.3.1-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:aca63103895c7d960a5b9b044a83f544b233c95e0dcff114389d64d762017af7"}, - {file = "propcache-0.3.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:5a0a9898fdb99bf11786265468571e628ba60af80dc3f6eb89a3545540c6b0ef"}, - {file = "propcache-0.3.1-cp313-cp313-win32.whl", hash = "sha256:3a02a28095b5e63128bcae98eb59025924f121f048a62393db682f049bf4ac24"}, - {file = "propcache-0.3.1-cp313-cp313-win_amd64.whl", hash = "sha256:813fbb8b6aea2fc9659815e585e548fe706d6f663fa73dff59a1677d4595a037"}, - {file = "propcache-0.3.1-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:a444192f20f5ce8a5e52761a031b90f5ea6288b1eef42ad4c7e64fef33540b8f"}, - {file = "propcache-0.3.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0fbe94666e62ebe36cd652f5fc012abfbc2342de99b523f8267a678e4dfdee3c"}, - {file = "propcache-0.3.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:f011f104db880f4e2166bcdcf7f58250f7a465bc6b068dc84c824a3d4a5c94dc"}, - {file = "propcache-0.3.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e584b6d388aeb0001d6d5c2bd86b26304adde6d9bb9bfa9c4889805021b96de"}, - {file = "propcache-0.3.1-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:8a17583515a04358b034e241f952f1715243482fc2c2945fd99a1b03a0bd77d6"}, - {file = "propcache-0.3.1-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5aed8d8308215089c0734a2af4f2e95eeb360660184ad3912686c181e500b2e7"}, - {file = "propcache-0.3.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6d8e309ff9a0503ef70dc9a0ebd3e69cf7b3894c9ae2ae81fc10943c37762458"}, - {file = "propcache-0.3.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b655032b202028a582d27aeedc2e813299f82cb232f969f87a4fde491a233f11"}, - {file = "propcache-0.3.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f64d91b751df77931336b5ff7bafbe8845c5770b06630e27acd5dbb71e1931c"}, - {file = "propcache-0.3.1-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:19a06db789a4bd896ee91ebc50d059e23b3639c25d58eb35be3ca1cbe967c3bf"}, - {file = "propcache-0.3.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:bef100c88d8692864651b5f98e871fb090bd65c8a41a1cb0ff2322db39c96c27"}, - {file = "propcache-0.3.1-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:87380fb1f3089d2a0b8b00f006ed12bd41bd858fabfa7330c954c70f50ed8757"}, - {file = "propcache-0.3.1-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:e474fc718e73ba5ec5180358aa07f6aded0ff5f2abe700e3115c37d75c947e18"}, - {file = "propcache-0.3.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:17d1c688a443355234f3c031349da69444be052613483f3e4158eef751abcd8a"}, - {file = "propcache-0.3.1-cp313-cp313t-win32.whl", hash = "sha256:359e81a949a7619802eb601d66d37072b79b79c2505e6d3fd8b945538411400d"}, - {file = "propcache-0.3.1-cp313-cp313t-win_amd64.whl", hash = "sha256:e7fb9a84c9abbf2b2683fa3e7b0d7da4d8ecf139a1c635732a8bda29c5214b0e"}, - {file = "propcache-0.3.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:ed5f6d2edbf349bd8d630e81f474d33d6ae5d07760c44d33cd808e2f5c8f4ae6"}, - {file = "propcache-0.3.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:668ddddc9f3075af019f784456267eb504cb77c2c4bd46cc8402d723b4d200bf"}, - {file = "propcache-0.3.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:0c86e7ceea56376216eba345aa1fc6a8a6b27ac236181f840d1d7e6a1ea9ba5c"}, - {file = "propcache-0.3.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:83be47aa4e35b87c106fc0c84c0fc069d3f9b9b06d3c494cd404ec6747544894"}, - {file = "propcache-0.3.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:27c6ac6aa9fc7bc662f594ef380707494cb42c22786a558d95fcdedb9aa5d035"}, - {file = "propcache-0.3.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:64a956dff37080b352c1c40b2966b09defb014347043e740d420ca1eb7c9b908"}, - {file = "propcache-0.3.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82de5da8c8893056603ac2d6a89eb8b4df49abf1a7c19d536984c8dd63f481d5"}, - {file = "propcache-0.3.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0c3c3a203c375b08fd06a20da3cf7aac293b834b6f4f4db71190e8422750cca5"}, - {file = "propcache-0.3.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:b303b194c2e6f171cfddf8b8ba30baefccf03d36a4d9cab7fd0bb68ba476a3d7"}, - {file = "propcache-0.3.1-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:916cd229b0150129d645ec51614d38129ee74c03293a9f3f17537be0029a9641"}, - {file = "propcache-0.3.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:a461959ead5b38e2581998700b26346b78cd98540b5524796c175722f18b0294"}, - {file = "propcache-0.3.1-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:069e7212890b0bcf9b2be0a03afb0c2d5161d91e1bf51569a64f629acc7defbf"}, - {file = "propcache-0.3.1-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:ef2e4e91fb3945769e14ce82ed53007195e616a63aa43b40fb7ebaaf907c8d4c"}, - {file = "propcache-0.3.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:8638f99dca15b9dff328fb6273e09f03d1c50d9b6512f3b65a4154588a7595fe"}, - {file = "propcache-0.3.1-cp39-cp39-win32.whl", hash = "sha256:6f173bbfe976105aaa890b712d1759de339d8a7cef2fc0a1714cc1a1e1c47f64"}, - {file = "propcache-0.3.1-cp39-cp39-win_amd64.whl", hash = "sha256:603f1fe4144420374f1a69b907494c3acbc867a581c2d49d4175b0de7cc64566"}, - {file = "propcache-0.3.1-py3-none-any.whl", hash = "sha256:9a8ecf38de50a7f518c21568c80f985e776397b902f1ce0b01f799aba1608b40"}, - {file = "propcache-0.3.1.tar.gz", hash = "sha256:40d980c33765359098837527e18eddefc9a24cea5b45e078a7f3bb5b032c6ecf"}, +files = [ + {file = "protobuf-6.31.1-cp310-abi3-win32.whl", hash = "sha256:7fa17d5a29c2e04b7d90e5e32388b8bfd0e7107cd8e616feef7ed3fa6bdab5c9"}, + {file = "protobuf-6.31.1-cp310-abi3-win_amd64.whl", hash = "sha256:426f59d2964864a1a366254fa703b8632dcec0790d8862d30034d8245e1cd447"}, + {file = "protobuf-6.31.1-cp39-abi3-macosx_10_9_universal2.whl", hash = "sha256:6f1227473dc43d44ed644425268eb7c2e488ae245d51c6866d19fe158e207402"}, + {file = "protobuf-6.31.1-cp39-abi3-manylinux2014_aarch64.whl", hash = "sha256:a40fc12b84c154884d7d4c4ebd675d5b3b5283e155f324049ae396b95ddebc39"}, + {file = "protobuf-6.31.1-cp39-abi3-manylinux2014_x86_64.whl", hash = "sha256:4ee898bf66f7a8b0bd21bce523814e6fbd8c6add948045ce958b73af7e8878c6"}, + {file = "protobuf-6.31.1-cp39-cp39-win32.whl", hash = "sha256:0414e3aa5a5f3ff423828e1e6a6e907d6c65c1d5b7e6e975793d5590bdeecc16"}, + {file = "protobuf-6.31.1-cp39-cp39-win_amd64.whl", hash = "sha256:8764cf4587791e7564051b35524b72844f845ad0bb011704c3736cce762d8fe9"}, + {file = "protobuf-6.31.1-py3-none-any.whl", hash = "sha256:720a6c7e6b77288b85063569baae8536671b39f15cc22037ec7045658d80489e"}, + {file = "protobuf-6.31.1.tar.gz", hash = "sha256:d8cac4c982f0b957a4dc73a80e2ea24fab08e679c0de9deb835f4a12d69aca9a"}, ] [[package]] @@ -4787,12 +3553,26 @@ version = "2.22" description = "C parser in Python" optional = false python-versions = ">=3.8" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc"}, {file = "pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6"}, ] -markers = {main = "extra == \"llm\""} + +[[package]] +name = "pycrafter" +version = "0.0.7" +description = "Text extraction from images using ONNX runtime and CRAFT net" +optional = false +python-versions = ">=3.8" +groups = ["main"] +files = [ + {file = "pycrafter-0.0.7-py3-none-any.whl", hash = "sha256:3f11551ab195c96a6aff71190bbd9465e86a4bb8da218a37bdb180805291bc4b"}, +] + +[package.dependencies] +onnxruntime = ">=1.15.0,<1.16.0" +opencv-python-headless = ">=4.8.0.76,<4.9.0.0" [[package]] name = "pydantic" @@ -4808,7 +3588,6 @@ files = [ [package.dependencies] annotated-types = ">=0.6.0" -email-validator = {version = ">=2.0.0", optional = true, markers = "extra == \"email\""} pydantic-core = "2.33.1" typing-extensions = ">=4.12.2" typing-inspection = ">=0.4.0" @@ -4956,35 +3735,15 @@ version = "2.19.1" description = "Pygments is a syntax highlighting package written in Python." optional = false python-versions = ">=3.8" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c"}, {file = "pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f"}, ] -markers = {main = "extra == \"llm\""} [package.extras] windows-terminal = ["colorama (>=0.4.6)"] -[[package]] -name = "pyjwt" -version = "2.10.1" -description = "JSON Web Token implementation in Python" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "PyJWT-2.10.1-py3-none-any.whl", hash = "sha256:dcdd193e30abefd5debf142f9adfcdd2b58004e644f25406ffaebd50bd98dacb"}, - {file = "pyjwt-2.10.1.tar.gz", hash = "sha256:3cc5772eb20009233caf06e9d8a0577824723b44e6648ee0a2aedb6cf9381953"}, -] - -[package.extras] -crypto = ["cryptography (>=3.4.0)"] -dev = ["coverage[toml] (==5.0.4)", "cryptography (>=3.4.0)", "pre-commit", "pytest (>=6.0.0,<7.0.0)", "sphinx", "sphinx-rtd-theme", "zope.interface"] -docs = ["sphinx", "sphinx-rtd-theme", "zope.interface"] -tests = ["coverage[toml] (==5.0.4)", "pytest (>=6.0.0,<7.0.0)"] - [[package]] name = "pymupdf" version = "1.24.11" @@ -5003,34 +3762,6 @@ files = [ {file = "PyMuPDF-1.24.11.tar.gz", hash = "sha256:6e45e57f14ac902029d4aacf07684958d0e58c769f47d9045b2048d0a3d20155"}, ] -[[package]] -name = "pynacl" -version = "1.5.0" -description = "Python binding to the Networking and Cryptography (NaCl) library" -optional = true -python-versions = ">=3.6" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "PyNaCl-1.5.0-cp36-abi3-macosx_10_10_universal2.whl", hash = "sha256:401002a4aaa07c9414132aaed7f6836ff98f59277a234704ff66878c2ee4a0d1"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_24_aarch64.whl", hash = "sha256:52cb72a79269189d4e0dc537556f4740f7f0a9ec41c1322598799b0bdad4ef92"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a36d4a9dda1f19ce6e03c9a784a2921a4b726b02e1c736600ca9c22029474394"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_24_x86_64.whl", hash = "sha256:0c84947a22519e013607c9be43706dd42513f9e6ae5d39d3613ca1e142fba44d"}, - {file = "PyNaCl-1.5.0-cp36-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06b8f6fa7f5de8d5d2f7573fe8c863c051225a27b61e6860fd047b1775807858"}, - {file = "PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:a422368fc821589c228f4c49438a368831cb5bbc0eab5ebe1d7fac9dded6567b"}, - {file = "PyNaCl-1.5.0-cp36-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:61f642bf2378713e2c2e1de73444a3778e5f0a38be6fee0fe532fe30060282ff"}, - {file = "PyNaCl-1.5.0-cp36-abi3-win32.whl", hash = "sha256:e46dae94e34b085175f8abb3b0aaa7da40767865ac82c928eeb9e57e1ea8a543"}, - {file = "PyNaCl-1.5.0-cp36-abi3-win_amd64.whl", hash = "sha256:20f42270d27e1b6a29f54032090b972d97f0a1b0948cc52392041ef7831fee93"}, - {file = "PyNaCl-1.5.0.tar.gz", hash = "sha256:8ac7448f09ab85811607bdd21ec2464495ac8b7c66d146bf545b0f08fb9220ba"}, -] - -[package.dependencies] -cffi = ">=1.4.1" - -[package.extras] -docs = ["sphinx (>=1.6.5)", "sphinx-rtd-theme"] -tests = ["hypothesis (>=3.27.0)", "pytest (>=3.2.1,!=3.3.0)"] - [[package]] name = "pyparsing" version = "3.2.3" @@ -5069,6 +3800,35 @@ files = [ {file = "pypdfium2-4.30.1.tar.gz", hash = "sha256:5f5c7c6d03598e107d974f66b220a49436aceb191da34cda5f692be098a814ce"}, ] +[[package]] +name = "pyreadline3" +version = "3.5.4" +description = "A python implementation of GNU readline." +optional = false +python-versions = ">=3.8" +groups = ["main"] +markers = "sys_platform == \"win32\"" +files = [ + {file = "pyreadline3-3.5.4-py3-none-any.whl", hash = "sha256:eaf8e6cc3c49bcccf145fc6067ba8643d1df34d604a1ec0eccbf7a18e6d3fae6"}, + {file = "pyreadline3-3.5.4.tar.gz", hash = "sha256:8d57d53039a1c75adba8e50dd3d992b28143480816187ea5efbd5c78e6c885b7"}, +] + +[package.extras] +dev = ["build", "flake8", "mypy", "pytest", "twine"] + +[[package]] +name = "pysocks" +version = "1.7.1" +description = "A Python SOCKS client module. See https://github.com/Anorov/PySocks for more information." +optional = false +python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*" +groups = ["test"] +files = [ + {file = "PySocks-1.7.1-py27-none-any.whl", hash = "sha256:08e69f092cc6dbe92a0fdd16eeb9b9ffbc13cadfe5ca4c7bd92ffb078b293299"}, + {file = "PySocks-1.7.1-py3-none-any.whl", hash = "sha256:2725bd0a9925919b9b51739eea5f9e2bae91e83288108a9ad338b2e3a4435ee5"}, + {file = "PySocks-1.7.1.tar.gz", hash = "sha256:3f8804571ebe159c380ac6de37643bb4685970655d3bba243530d6558b799aa0"}, +] + [[package]] name = "pyspark" version = "3.5.5" @@ -5387,22 +4147,6 @@ files = [ [package.extras] dev = ["backports.zoneinfo ; python_version < \"3.9\"", "black", "build", "freezegun", "mdx_truly_sane_lists", "mike", "mkdocs", "mkdocs-awesome-pages-plugin", "mkdocs-gen-files", "mkdocs-literate-nav", "mkdocs-material (>=8.5)", "mkdocstrings[python]", "msgspec ; implementation_name != \"pypy\"", "mypy", "orjson ; implementation_name != \"pypy\"", "pylint", "pytest", "tzdata", "validate-pyproject[all]"] -[[package]] -name = "python-multipart" -version = "0.0.9" -description = "A streaming multipart parser for Python" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "python_multipart-0.0.9-py3-none-any.whl", hash = "sha256:97ca7b8ea7b05f977dc3849c3ba99d51689822fab725c3703af7c866a0c2b215"}, - {file = "python_multipart-0.0.9.tar.gz", hash = "sha256:03f54688c663f1b7977105f021043b0793151e4cb1c1a9d4a11fc13d622c4026"}, -] - -[package.extras] -dev = ["atomicwrites (==1.4.1)", "attrs (==23.2.0)", "coverage (==7.4.1)", "hatch", "invoke (==2.2.0)", "more-itertools (==10.2.0)", "pbr (==6.0.0)", "pluggy (==1.4.0)", "py (==1.11.0)", "pytest (==8.0.0)", "pytest-cov (==4.1.0)", "pytest-timeout (==2.2.0)", "pyyaml (==6.0.1)", "ruff (==0.2.1)"] - [[package]] name = "pytz" version = "2025.2" @@ -5736,38 +4480,17 @@ files = [ [package.extras] all = ["numpy"] -[[package]] -name = "redis" -version = "5.2.1" -description = "Python client for Redis database and key-value store" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "redis-5.2.1-py3-none-any.whl", hash = "sha256:ee7e1056b9aea0f04c6c2ed59452947f34c4940ee025f5dd83e6a6418b6989e4"}, - {file = "redis-5.2.1.tar.gz", hash = "sha256:16f2e22dff21d5125e8481515e386711a34cbec50f0e44413dd7d9c060a54e0f"}, -] - -[package.dependencies] -async-timeout = {version = ">=4.0.3", markers = "python_full_version < \"3.11.3\""} - -[package.extras] -hiredis = ["hiredis (>=3.0.0)"] -ocsp = ["cryptography (>=36.0.1)", "pyopenssl (==23.2.1)", "requests (>=2.31.0)"] - [[package]] name = "referencing" version = "0.36.2" description = "JSON Referencing + Python" optional = false python-versions = ">=3.9" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "referencing-0.36.2-py3-none-any.whl", hash = "sha256:e8699adbbf8b5c7de96d8ffa0eb5c158b3beafce084968e2ea8bb08c6794dcd0"}, {file = "referencing-0.36.2.tar.gz", hash = "sha256:df2e89862cd09deabbdba16944cc3f10feb6b3e6f18e902f7cc25609a34775aa"}, ] -markers = {main = "extra == \"llm\""} [package.dependencies] attrs = ">=22.2.0" @@ -5894,6 +4617,7 @@ files = [ certifi = ">=2017.4.17" charset-normalizer = ">=2,<4" idna = ">=2.5,<4" +PySocks = {version = ">=1.5.6,<1.5.7 || >1.5.7", optional = true, markers = "extra == \"socks\""} urllib3 = ">=1.21.1,<3" [package.extras] @@ -5927,52 +4651,13 @@ files = [ {file = "rfc3986_validator-0.1.1.tar.gz", hash = "sha256:3d44bde7921b3b9ec3ae4e3adca370438eccebc676456449b145d533b240d055"}, ] -[[package]] -name = "rich" -version = "14.0.0" -description = "Render rich text, tables, progress bars, syntax highlighting, markdown and more to the terminal" -optional = true -python-versions = ">=3.8.0" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "rich-14.0.0-py3-none-any.whl", hash = "sha256:1c9491e1951aac09caffd42f448ee3d04e58923ffe14993f6e83068dc395d7e0"}, - {file = "rich-14.0.0.tar.gz", hash = "sha256:82f1bc23a6a21ebca4ae0c45af9bdbc492ed20231dcb63f297d6d1021a9d5725"}, -] - -[package.dependencies] -markdown-it-py = ">=2.2.0" -pygments = ">=2.13.0,<3.0.0" -typing-extensions = {version = ">=4.0.0,<5.0", markers = "python_version < \"3.11\""} - -[package.extras] -jupyter = ["ipywidgets (>=7.5.1,<9)"] - -[[package]] -name = "rich-toolkit" -version = "0.14.1" -description = "Rich toolkit for building command-line applications" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "rich_toolkit-0.14.1-py3-none-any.whl", hash = "sha256:dc92c0117d752446d04fdc828dbca5873bcded213a091a5d3742a2beec2e6559"}, - {file = "rich_toolkit-0.14.1.tar.gz", hash = "sha256:9248e2d087bfc01f3e4c5c8987e05f7fa744d00dd22fa2be3aa6e50255790b3f"}, -] - -[package.dependencies] -click = ">=8.1.7" -rich = ">=13.7.1" -typing-extensions = ">=4.12.2" - [[package]] name = "rpds-py" version = "0.24.0" description = "Python bindings to Rust's persistent data structures (rpds)" optional = false python-versions = ">=3.9" -groups = ["main", "test"] +groups = ["test"] files = [ {file = "rpds_py-0.24.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:006f4342fe729a368c6df36578d7a348c7c716be1da0a1a0f86e3021f8e98724"}, {file = "rpds_py-0.24.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2d53747da70a4e4b17f559569d5f9506420966083a31c5fbd84e764461c4444b"}, @@ -6089,24 +4774,6 @@ files = [ {file = "rpds_py-0.24.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:24795c099453e3721fda5d8ddd45f5dfcc8e5a547ce7b8e9da06fecc3832e26f"}, {file = "rpds_py-0.24.0.tar.gz", hash = "sha256:772cc1b2cd963e7e17e6cc55fe0371fb9c704d63e44cacec7b9b7f523b78919e"}, ] -markers = {main = "extra == \"llm\""} - -[[package]] -name = "rq" -version = "2.3.1" -description = "RQ is a simple, lightweight, library for creating background jobs, and processing them." -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "rq-2.3.1-py3-none-any.whl", hash = "sha256:2bbd48b976fdd840865dcab4bed358eb94b4dd8a02e92add75a346a909c1793d"}, - {file = "rq-2.3.1.tar.gz", hash = "sha256:9cb33be7a90c6b36c0d6b9a6524aaf85b8855251ace476d74a076e6dfc5684d6"}, -] - -[package.dependencies] -click = ">=5" -redis = ">=3.5" [[package]] name = "ruff" @@ -6352,53 +5019,53 @@ type = ["importlib_metadata (>=7.0.2) ; python_version < \"3.10\"", "jaraco.deve [[package]] name = "shapely" -version = "2.1.0" +version = "2.1.1" description = "Manipulation and analysis of geometric objects" optional = false python-versions = ">=3.10" groups = ["main", "test"] files = [ - {file = "shapely-2.1.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d3e5c5e3864d4dc431dd85a8e5137ebd39c8ac287b009d3fa80a07017b29c940"}, - {file = "shapely-2.1.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d6eea89b16f5f3a064659126455d23fa3066bc3d6cd385c35214f06bf5871aa6"}, - {file = "shapely-2.1.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:183174ad0b21a81ee661f05e7c47aa92ebfae01814cd3cbe54adea7a4213f5f4"}, - {file = "shapely-2.1.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f239c1484af66bc14b81a76f2a8e0fada29d59010423253ff857d0ccefdaa93f"}, - {file = "shapely-2.1.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:6220a466d1475141dad0cd8065d2549a5c2ed3fa4e2e02fb8ea65d494cfd5b07"}, - {file = "shapely-2.1.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4822d3ed3efb06145c34d29d5b56792f72b7d713300f603bfd5d825892c6f79f"}, - {file = "shapely-2.1.0-cp310-cp310-win32.whl", hash = "sha256:ea51ddf3d3c60866dca746081b56c75f34ff1b01acbd4d44269071a673c735b9"}, - {file = "shapely-2.1.0-cp310-cp310-win_amd64.whl", hash = "sha256:a6f5e02e2cded9f4ec5709900a296c7f2cce5f8e9e9d80ba7d89ae2f4ed89d7b"}, - {file = "shapely-2.1.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c8323031ef7c1bdda7a92d5ddbc7b6b62702e73ba37e9a8ccc8da99ec2c0b87c"}, - {file = "shapely-2.1.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4da7c6cd748d86ec6aace99ad17129d30954ccf5e73e9911cdb5f0fa9658b4f8"}, - {file = "shapely-2.1.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1f0cdf85ff80831137067e7a237085a3ee72c225dba1b30beef87f7d396cf02b"}, - {file = "shapely-2.1.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:41f2be5d79aac39886f23000727cf02001aef3af8810176c29ee12cdc3ef3a50"}, - {file = "shapely-2.1.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:21a4515009f56d7a159cf5c2554264e82f56405b4721f9a422cb397237c5dca8"}, - {file = "shapely-2.1.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:15cebc323cec2cb6b2eaa310fdfc621f6dbbfaf6bde336d13838fcea76c885a9"}, - {file = "shapely-2.1.0-cp311-cp311-win32.whl", hash = "sha256:cad51b7a5c8f82f5640472944a74f0f239123dde9a63042b3c5ea311739b7d20"}, - {file = "shapely-2.1.0-cp311-cp311-win_amd64.whl", hash = "sha256:d4005309dde8658e287ad9c435c81877f6a95a9419b932fa7a1f34b120f270ae"}, - {file = "shapely-2.1.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:53e7ee8bd8609cf12ee6dce01ea5affe676976cf7049315751d53d8db6d2b4b2"}, - {file = "shapely-2.1.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3cab20b665d26dbec0b380e15749bea720885a481fa7b1eedc88195d4a98cfa4"}, - {file = "shapely-2.1.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f4a38b39a09340273c3c92b3b9a374272a12cc7e468aeeea22c1c46217a03e5c"}, - {file = "shapely-2.1.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:edaec656bdd9b71278b98e6f77c464b1c3b2daa9eace78012ff0f0b4b5b15b04"}, - {file = "shapely-2.1.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:c8a732ddd9b25e7a54aa748e7df8fd704e23e5d5d35b7d376d80bffbfc376d04"}, - {file = "shapely-2.1.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9c93693ad8adfdc9138a5a2d42da02da94f728dd2e82d2f0f442f10e25027f5f"}, - {file = "shapely-2.1.0-cp312-cp312-win32.whl", hash = "sha256:d8ac6604eefe807e71a908524de23a37920133a1729fe3a4dfe0ed82c044cbf4"}, - {file = "shapely-2.1.0-cp312-cp312-win_amd64.whl", hash = "sha256:f4f47e631aa4f9ec5576eac546eb3f38802e2f82aeb0552f9612cb9a14ece1db"}, - {file = "shapely-2.1.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b64423295b563f43a043eb786e7a03200ebe68698e36d2b4b1c39f31dfb50dfb"}, - {file = "shapely-2.1.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1b5578f45adc25b235b22d1ccb9a0348c8dc36f31983e57ea129a88f96f7b870"}, - {file = "shapely-2.1.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d1a7e83d383b27f02b684e50ab7f34e511c92e33b6ca164a6a9065705dd64bcb"}, - {file = "shapely-2.1.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:942031eb4d8f7b3b22f43ba42c09c7aa3d843aa10d5cc1619fe816e923b66e55"}, - {file = "shapely-2.1.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:d2843c456a2e5627ee6271800f07277c0d2652fb287bf66464571a057dbc00b3"}, - {file = "shapely-2.1.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8c4b17469b7f39a5e6a7cfea79f38ae08a275427f41fe8b48c372e1449147908"}, - {file = "shapely-2.1.0-cp313-cp313-win32.whl", hash = "sha256:30e967abd08fce49513d4187c01b19f139084019f33bec0673e8dbeb557c45e4"}, - {file = "shapely-2.1.0-cp313-cp313-win_amd64.whl", hash = "sha256:1dc8d4364483a14aba4c844b7bd16a6fa3728887e2c33dfa1afa34a3cf4d08a5"}, - {file = "shapely-2.1.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:673e073fea099d1c82f666fb7ab0a00a77eff2999130a69357ce11941260d855"}, - {file = "shapely-2.1.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6d1513f915a56de67659fe2047c1ad5ff0f8cbff3519d1e74fced69c9cb0e7da"}, - {file = "shapely-2.1.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d6a7043178890b9e028d80496ff4c79dc7629bff4d78a2f25323b661756bab8"}, - {file = "shapely-2.1.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cb638378dc3d76f7e85b67d7e2bb1366811912430ac9247ac00c127c2b444cdc"}, - {file = "shapely-2.1.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:737124e87d91d616acf9a911f74ac55e05db02a43a6a7245b3d663817b876055"}, - {file = "shapely-2.1.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:8e6c229e7bb87aae5df82fa00b6718987a43ec168cc5affe095cca59d233f314"}, - {file = "shapely-2.1.0-cp313-cp313t-win32.whl", hash = "sha256:a9580bda119b1f42f955aa8e52382d5c73f7957e0203bc0c0c60084846f3db94"}, - {file = "shapely-2.1.0-cp313-cp313t-win_amd64.whl", hash = "sha256:e8ff4e5cfd799ba5b6f37b5d5527dbd85b4a47c65b6d459a03d0962d2a9d4d10"}, - {file = "shapely-2.1.0.tar.gz", hash = "sha256:2cbe90e86fa8fc3ca8af6ffb00a77b246b918c7cf28677b7c21489b678f6b02e"}, + {file = "shapely-2.1.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:d8ccc872a632acb7bdcb69e5e78df27213f7efd195882668ffba5405497337c6"}, + {file = "shapely-2.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f24f2ecda1e6c091da64bcbef8dd121380948074875bd1b247b3d17e99407099"}, + {file = "shapely-2.1.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45112a5be0b745b49e50f8829ce490eb67fefb0cea8d4f8ac5764bfedaa83d2d"}, + {file = "shapely-2.1.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8c10ce6f11904d65e9bbb3e41e774903c944e20b3f0b282559885302f52f224a"}, + {file = "shapely-2.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:61168010dfe4e45f956ffbbaf080c88afce199ea81eb1f0ac43230065df320bd"}, + {file = "shapely-2.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:cacf067cdff741cd5c56a21c52f54ece4e4dad9d311130493a791997da4a886b"}, + {file = "shapely-2.1.1-cp310-cp310-win32.whl", hash = "sha256:23b8772c3b815e7790fb2eab75a0b3951f435bc0fce7bb146cb064f17d35ab4f"}, + {file = "shapely-2.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:2c7b2b6143abf4fa77851cef8ef690e03feade9a0d48acd6dc41d9e0e78d7ca6"}, + {file = "shapely-2.1.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:587a1aa72bc858fab9b8c20427b5f6027b7cbc92743b8e2c73b9de55aa71c7a7"}, + {file = "shapely-2.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9fa5c53b0791a4b998f9ad84aad456c988600757a96b0a05e14bba10cebaaaea"}, + {file = "shapely-2.1.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aabecd038841ab5310d23495253f01c2a82a3aedae5ab9ca489be214aa458aa7"}, + {file = "shapely-2.1.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:586f6aee1edec04e16227517a866df3e9a2e43c1f635efc32978bb3dc9c63753"}, + {file = "shapely-2.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b9878b9e37ad26c72aada8de0c9cfe418d9e2ff36992a1693b7f65a075b28647"}, + {file = "shapely-2.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d9a531c48f289ba355e37b134e98e28c557ff13965d4653a5228d0f42a09aed0"}, + {file = "shapely-2.1.1-cp311-cp311-win32.whl", hash = "sha256:4866de2673a971820c75c0167b1f1cd8fb76f2d641101c23d3ca021ad0449bab"}, + {file = "shapely-2.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:20a9d79958b3d6c70d8a886b250047ea32ff40489d7abb47d01498c704557a93"}, + {file = "shapely-2.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2827365b58bf98efb60affc94a8e01c56dd1995a80aabe4b701465d86dcbba43"}, + {file = "shapely-2.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9c551f7fa7f1e917af2347fe983f21f212863f1d04f08eece01e9c275903fad"}, + {file = "shapely-2.1.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78dec4d4fbe7b1db8dc36de3031767e7ece5911fb7782bc9e95c5cdec58fb1e9"}, + {file = "shapely-2.1.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:872d3c0a7b8b37da0e23d80496ec5973c4692920b90de9f502b5beb994bbaaef"}, + {file = "shapely-2.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2e2b9125ebfbc28ecf5353511de62f75a8515ae9470521c9a693e4bb9fbe0cf1"}, + {file = "shapely-2.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:4b96cea171b3d7f6786976a0520f178c42792897653ecca0c5422fb1e6946e6d"}, + {file = "shapely-2.1.1-cp312-cp312-win32.whl", hash = "sha256:39dca52201e02996df02e447f729da97cfb6ff41a03cb50f5547f19d02905af8"}, + {file = "shapely-2.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:13d643256f81d55a50013eff6321142781cf777eb6a9e207c2c9e6315ba6044a"}, + {file = "shapely-2.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3004a644d9e89e26c20286d5fdc10f41b1744c48ce910bd1867fdff963fe6c48"}, + {file = "shapely-2.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:1415146fa12d80a47d13cfad5310b3c8b9c2aa8c14a0c845c9d3d75e77cb54f6"}, + {file = "shapely-2.1.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:21fcab88b7520820ec16d09d6bea68652ca13993c84dffc6129dc3607c95594c"}, + {file = "shapely-2.1.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e5ce6a5cc52c974b291237a96c08c5592e50f066871704fb5b12be2639d9026a"}, + {file = "shapely-2.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:04e4c12a45a1d70aeb266618d8cf81a2de9c4df511b63e105b90bfdfb52146de"}, + {file = "shapely-2.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6ca74d851ca5264aae16c2b47e96735579686cb69fa93c4078070a0ec845b8d8"}, + {file = "shapely-2.1.1-cp313-cp313-win32.whl", hash = "sha256:fd9130501bf42ffb7e0695b9ea17a27ae8ce68d50b56b6941c7f9b3d3453bc52"}, + {file = "shapely-2.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:ab8d878687b438a2f4c138ed1a80941c6ab0029e0f4c785ecfe114413b498a97"}, + {file = "shapely-2.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0c062384316a47f776305ed2fa22182717508ffdeb4a56d0ff4087a77b2a0f6d"}, + {file = "shapely-2.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4ecf6c196b896e8f1360cc219ed4eee1c1e5f5883e505d449f263bd053fb8c05"}, + {file = "shapely-2.1.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb00070b4c4860f6743c600285109c273cca5241e970ad56bb87bef0be1ea3a0"}, + {file = "shapely-2.1.1-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d14a9afa5fa980fbe7bf63706fdfb8ff588f638f145a1d9dbc18374b5b7de913"}, + {file = "shapely-2.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b640e390dabde790e3fb947198b466e63223e0a9ccd787da5f07bcb14756c28d"}, + {file = "shapely-2.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:69e08bf9697c1b73ec6aa70437db922bafcea7baca131c90c26d59491a9760f9"}, + {file = "shapely-2.1.1-cp313-cp313t-win32.whl", hash = "sha256:ef2d09d5a964cc90c2c18b03566cf918a61c248596998a0301d5b632beadb9db"}, + {file = "shapely-2.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:8cb8f17c377260452e9d7720eeaf59082c5f8ea48cf104524d953e5d36d4bdb7"}, + {file = "shapely-2.1.1.tar.gz", hash = "sha256:500621967f2ffe9642454808009044c21e5b35db89ce69f8a2042c2ffd0e2772"}, ] [package.dependencies] @@ -6408,19 +5075,6 @@ numpy = ">=1.21" docs = ["matplotlib", "numpydoc (==1.1.*)", "sphinx", "sphinx-book-theme", "sphinx-remove-toctrees"] test = ["pytest", "pytest-cov", "scipy-doctest"] -[[package]] -name = "shellingham" -version = "1.5.4" -description = "Tool to Detect Surrounding Shell" -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "shellingham-1.5.4-py2.py3-none-any.whl", hash = "sha256:7ecfff8f2fd72616f7481040475a65b2bf8af90a56c89140852d1120324e8686"}, - {file = "shellingham-1.5.4.tar.gz", hash = "sha256:8dbca0739d487e5bd35ab3ca4b36e11c4078f3a234bfce294b0a0291363404de"}, -] - [[package]] name = "six" version = "1.17.0" @@ -6478,103 +5132,6 @@ pyparsing = ">=3.1.1,<4.0.0" [package.extras] pyspark = ["pyspark (>=3.3.0,<4.0.0)"] -[[package]] -name = "sqlalchemy" -version = "2.0.40" -description = "Database Abstraction Library" -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "SQLAlchemy-2.0.40-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:ae9597cab738e7cc823f04a704fb754a9249f0b6695a6aeb63b74055cd417a96"}, - {file = "SQLAlchemy-2.0.40-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:37a5c21ab099a83d669ebb251fddf8f5cee4d75ea40a5a1653d9c43d60e20867"}, - {file = "SQLAlchemy-2.0.40-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bece9527f5a98466d67fb5d34dc560c4da964240d8b09024bb21c1246545e04e"}, - {file = "SQLAlchemy-2.0.40-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:8bb131ffd2165fae48162c7bbd0d97c84ab961deea9b8bab16366543deeab625"}, - {file = "SQLAlchemy-2.0.40-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:9408fd453d5f8990405cc9def9af46bfbe3183e6110401b407c2d073c3388f47"}, - {file = "SQLAlchemy-2.0.40-cp37-cp37m-win32.whl", hash = "sha256:00a494ea6f42a44c326477b5bee4e0fc75f6a80c01570a32b57e89cf0fbef85a"}, - {file = "SQLAlchemy-2.0.40-cp37-cp37m-win_amd64.whl", hash = "sha256:c7b927155112ac858357ccf9d255dd8c044fd9ad2dc6ce4c4149527c901fa4c3"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:f1ea21bef99c703f44444ad29c2c1b6bd55d202750b6de8e06a955380f4725d7"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:afe63b208153f3a7a2d1a5b9df452b0673082588933e54e7c8aac457cf35e758"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a8aae085ea549a1eddbc9298b113cffb75e514eadbb542133dd2b99b5fb3b6af"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5ea9181284754d37db15156eb7be09c86e16e50fbe77610e9e7bee09291771a1"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5434223b795be5c5ef8244e5ac98056e290d3a99bdcc539b916e282b160dda00"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:15d08d5ef1b779af6a0909b97be6c1fd4298057504eb6461be88bd1696cb438e"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-win32.whl", hash = "sha256:cd2f75598ae70bcfca9117d9e51a3b06fe29edd972fdd7fd57cc97b4dbf3b08a"}, - {file = "sqlalchemy-2.0.40-cp310-cp310-win_amd64.whl", hash = "sha256:2cbafc8d39ff1abdfdda96435f38fab141892dc759a2165947d1a8fffa7ef596"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f6bacab7514de6146a1976bc56e1545bee247242fab030b89e5f70336fc0003e"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5654d1ac34e922b6c5711631f2da497d3a7bffd6f9f87ac23b35feea56098011"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:35904d63412db21088739510216e9349e335f142ce4a04b69e2528020ee19ed4"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9c7a80ed86d6aaacb8160a1caef6680d4ddd03c944d985aecee940d168c411d1"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:519624685a51525ddaa7d8ba8265a1540442a2ec71476f0e75241eb8263d6f51"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:2ee5f9999a5b0e9689bed96e60ee53c3384f1a05c2dd8068cc2e8361b0df5b7a"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-win32.whl", hash = "sha256:c0cae71e20e3c02c52f6b9e9722bca70e4a90a466d59477822739dc31ac18b4b"}, - {file = "sqlalchemy-2.0.40-cp311-cp311-win_amd64.whl", hash = "sha256:574aea2c54d8f1dd1699449f332c7d9b71c339e04ae50163a3eb5ce4c4325ee4"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:9d3b31d0a1c44b74d3ae27a3de422dfccd2b8f0b75e51ecb2faa2bf65ab1ba0d"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:37f7a0f506cf78c80450ed1e816978643d3969f99c4ac6b01104a6fe95c5490a"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0bb933a650323e476a2e4fbef8997a10d0003d4da996aad3fd7873e962fdde4d"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6959738971b4745eea16f818a2cd086fb35081383b078272c35ece2b07012716"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:110179728e442dae85dd39591beb74072ae4ad55a44eda2acc6ec98ead80d5f2"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:e8040680eaacdce4d635f12c55c714f3d4c7f57da2bc47a01229d115bd319191"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-win32.whl", hash = "sha256:650490653b110905c10adac69408380688cefc1f536a137d0d69aca1069dc1d1"}, - {file = "sqlalchemy-2.0.40-cp312-cp312-win_amd64.whl", hash = "sha256:2be94d75ee06548d2fc591a3513422b873490efb124048f50556369a834853b0"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:915866fd50dd868fdcc18d61d8258db1bf9ed7fbd6dfec960ba43365952f3b01"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4a4c5a2905a9ccdc67a8963e24abd2f7afcd4348829412483695c59e0af9a705"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:55028d7a3ebdf7ace492fab9895cbc5270153f75442a0472d8516e03159ab364"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6cfedff6878b0e0d1d0a50666a817ecd85051d12d56b43d9d425455e608b5ba0"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bb19e30fdae77d357ce92192a3504579abe48a66877f476880238a962e5b96db"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:16d325ea898f74b26ffcd1cf8c593b0beed8714f0317df2bed0d8d1de05a8f26"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-win32.whl", hash = "sha256:a669cbe5be3c63f75bcbee0b266779706f1a54bcb1000f302685b87d1b8c1500"}, - {file = "sqlalchemy-2.0.40-cp313-cp313-win_amd64.whl", hash = "sha256:641ee2e0834812d657862f3a7de95e0048bdcb6c55496f39c6fa3d435f6ac6ad"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:50f5885bbed261fc97e2e66c5156244f9704083a674b8d17f24c72217d29baf5"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cf0e99cdb600eabcd1d65cdba0d3c91418fee21c4aa1d28db47d095b1064a7d8"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe147fcd85aaed53ce90645c91ed5fca0cc88a797314c70dfd9d35925bd5d106"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:baf7cee56bd552385c1ee39af360772fbfc2f43be005c78d1140204ad6148438"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:4aeb939bcac234b88e2d25d5381655e8353fe06b4e50b1c55ecffe56951d18c2"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:c268b5100cfeaa222c40f55e169d484efa1384b44bf9ca415eae6d556f02cb08"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-win32.whl", hash = "sha256:46628ebcec4f23a1584fb52f2abe12ddb00f3bb3b7b337618b80fc1b51177aff"}, - {file = "sqlalchemy-2.0.40-cp38-cp38-win_amd64.whl", hash = "sha256:7e0505719939e52a7b0c65d20e84a6044eb3712bb6f239c6b1db77ba8e173a37"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:c884de19528e0fcd9dc34ee94c810581dd6e74aef75437ff17e696c2bfefae3e"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1abb387710283fc5983d8a1209d9696a4eae9db8d7ac94b402981fe2fe2e39ad"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5cfa124eda500ba4b0d3afc3e91ea27ed4754e727c7f025f293a22f512bcd4c9"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b6b28d303b9d57c17a5164eb1fd2d5119bb6ff4413d5894e74873280483eeb5"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:b5a5bbe29c10c5bfd63893747a1bf6f8049df607638c786252cb9243b86b6706"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:f0fda83e113bb0fb27dc003685f32a5dcb99c9c4f41f4fa0838ac35265c23b5c"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-win32.whl", hash = "sha256:957f8d85d5e834397ef78a6109550aeb0d27a53b5032f7a57f2451e1adc37e98"}, - {file = "sqlalchemy-2.0.40-cp39-cp39-win_amd64.whl", hash = "sha256:1ffdf9c91428e59744f8e6f98190516f8e1d05eec90e936eb08b257332c5e870"}, - {file = "sqlalchemy-2.0.40-py3-none-any.whl", hash = "sha256:32587e2e1e359276957e6fe5dad089758bc042a971a8a09ae8ecf7a8fe23d07a"}, - {file = "sqlalchemy-2.0.40.tar.gz", hash = "sha256:d827099289c64589418ebbcaead0145cd19f4e3e8a93919a0100247af245fa00"}, -] - -[package.dependencies] -greenlet = {version = ">=1", markers = "python_version < \"3.14\" and (platform_machine == \"aarch64\" or platform_machine == \"ppc64le\" or platform_machine == \"x86_64\" or platform_machine == \"amd64\" or platform_machine == \"AMD64\" or platform_machine == \"win32\" or platform_machine == \"WIN32\")"} -typing-extensions = ">=4.6.0" - -[package.extras] -aiomysql = ["aiomysql (>=0.2.0)", "greenlet (>=1)"] -aioodbc = ["aioodbc", "greenlet (>=1)"] -aiosqlite = ["aiosqlite", "greenlet (>=1)", "typing_extensions (!=3.10.0.1)"] -asyncio = ["greenlet (>=1)"] -asyncmy = ["asyncmy (>=0.2.3,!=0.2.4,!=0.2.6)", "greenlet (>=1)"] -mariadb-connector = ["mariadb (>=1.0.1,!=1.1.2,!=1.1.5,!=1.1.10)"] -mssql = ["pyodbc"] -mssql-pymssql = ["pymssql"] -mssql-pyodbc = ["pyodbc"] -mypy = ["mypy (>=0.910)"] -mysql = ["mysqlclient (>=1.4.0)"] -mysql-connector = ["mysql-connector-python"] -oracle = ["cx_oracle (>=8)"] -oracle-oracledb = ["oracledb (>=1.0.1)"] -postgresql = ["psycopg2 (>=2.7)"] -postgresql-asyncpg = ["asyncpg", "greenlet (>=1)"] -postgresql-pg8000 = ["pg8000 (>=1.29.1)"] -postgresql-psycopg = ["psycopg (>=3.0.7)"] -postgresql-psycopg2binary = ["psycopg2-binary"] -postgresql-psycopg2cffi = ["psycopg2cffi"] -postgresql-psycopgbinary = ["psycopg[binary] (>=3.0.7)"] -pymysql = ["pymysql"] -sqlcipher = ["sqlcipher3_binary"] - [[package]] name = "stack-data" version = "0.6.3" @@ -6595,25 +5152,6 @@ pure-eval = "*" [package.extras] tests = ["cython", "littleutils", "pygments", "pytest", "typeguard"] -[[package]] -name = "starlette" -version = "0.37.2" -description = "The little ASGI library that shines." -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "starlette-0.37.2-py3-none-any.whl", hash = "sha256:6fe59f29268538e5d0d182f2791a479a0c64638e6935d1c6989e63fb2699c6ee"}, - {file = "starlette-0.37.2.tar.gz", hash = "sha256:9af890290133b79fc3db55474ade20f6220a364a0402e0b556e7cd5e1e093823"}, -] - -[package.dependencies] -anyio = ">=3.4.0,<5" - -[package.extras] -full = ["httpx (>=0.22.0)", "itsdangerous", "jinja2", "python-multipart (>=0.0.7)", "pyyaml"] - [[package]] name = "surya-ocr" version = "0.8.1" @@ -6675,14 +5213,14 @@ widechars = ["wcwidth"] [[package]] name = "tenacity" -version = "9.1.2" +version = "8.5.0" description = "Retry code until it succeeds" optional = false -python-versions = ">=3.9" +python-versions = ">=3.8" groups = ["main"] files = [ - {file = "tenacity-9.1.2-py3-none-any.whl", hash = "sha256:f77bf36710d8b73a50b2dd155c97b870017ad21afe6ab300326b0371b3b05138"}, - {file = "tenacity-9.1.2.tar.gz", hash = "sha256:1169d376c297e7de388d18b4481760d478b0e99a777cad3a9c86e556f4b697cb"}, + {file = "tenacity-8.5.0-py3-none-any.whl", hash = "sha256:b594c2a5945830c267ce6b79a166228323ed52718f30302c1359836112346687"}, + {file = "tenacity-8.5.0.tar.gz", hash = "sha256:8bc6c0c8a09b31e6cad13c47afbed1a567518250a9a171418582ed8d9c20ca78"}, ] [package.extras] @@ -6771,55 +5309,6 @@ test = ["cmapfile", "czifile", "dask", "defusedxml", "fsspec", "imagecodecs", "l xml = ["defusedxml", "lxml"] zarr = ["fsspec", "zarr (<3)"] -[[package]] -name = "tiktoken" -version = "0.9.0" -description = "tiktoken is a fast BPE tokeniser for use with OpenAI's models" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "tiktoken-0.9.0-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:586c16358138b96ea804c034b8acf3f5d3f0258bd2bc3b0227af4af5d622e382"}, - {file = "tiktoken-0.9.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:d9c59ccc528c6c5dd51820b3474402f69d9a9e1d656226848ad68a8d5b2e5108"}, - {file = "tiktoken-0.9.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0968d5beeafbca2a72c595e8385a1a1f8af58feaebb02b227229b69ca5357fd"}, - {file = "tiktoken-0.9.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:92a5fb085a6a3b7350b8fc838baf493317ca0e17bd95e8642f95fc69ecfed1de"}, - {file = "tiktoken-0.9.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:15a2752dea63d93b0332fb0ddb05dd909371ededa145fe6a3242f46724fa7990"}, - {file = "tiktoken-0.9.0-cp310-cp310-win_amd64.whl", hash = "sha256:26113fec3bd7a352e4b33dbaf1bd8948de2507e30bd95a44e2b1156647bc01b4"}, - {file = "tiktoken-0.9.0-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:f32cc56168eac4851109e9b5d327637f15fd662aa30dd79f964b7c39fbadd26e"}, - {file = "tiktoken-0.9.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:45556bc41241e5294063508caf901bf92ba52d8ef9222023f83d2483a3055348"}, - {file = "tiktoken-0.9.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03935988a91d6d3216e2ec7c645afbb3d870b37bcb67ada1943ec48678e7ee33"}, - {file = "tiktoken-0.9.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b3d80aad8d2c6b9238fc1a5524542087c52b860b10cbf952429ffb714bc1136"}, - {file = "tiktoken-0.9.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b2a21133be05dc116b1d0372af051cd2c6aa1d2188250c9b553f9fa49301b336"}, - {file = "tiktoken-0.9.0-cp311-cp311-win_amd64.whl", hash = "sha256:11a20e67fdf58b0e2dea7b8654a288e481bb4fc0289d3ad21291f8d0849915fb"}, - {file = "tiktoken-0.9.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:e88f121c1c22b726649ce67c089b90ddda8b9662545a8aeb03cfef15967ddd03"}, - {file = "tiktoken-0.9.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a6600660f2f72369acb13a57fb3e212434ed38b045fd8cc6cdd74947b4b5d210"}, - {file = "tiktoken-0.9.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:95e811743b5dfa74f4b227927ed86cbc57cad4df859cb3b643be797914e41794"}, - {file = "tiktoken-0.9.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99376e1370d59bcf6935c933cb9ba64adc29033b7e73f5f7569f3aad86552b22"}, - {file = "tiktoken-0.9.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:badb947c32739fb6ddde173e14885fb3de4d32ab9d8c591cbd013c22b4c31dd2"}, - {file = "tiktoken-0.9.0-cp312-cp312-win_amd64.whl", hash = "sha256:5a62d7a25225bafed786a524c1b9f0910a1128f4232615bf3f8257a73aaa3b16"}, - {file = "tiktoken-0.9.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2b0e8e05a26eda1249e824156d537015480af7ae222ccb798e5234ae0285dbdb"}, - {file = "tiktoken-0.9.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:27d457f096f87685195eea0165a1807fae87b97b2161fe8c9b1df5bd74ca6f63"}, - {file = "tiktoken-0.9.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cf8ded49cddf825390e36dd1ad35cd49589e8161fdcb52aa25f0583e90a3e01"}, - {file = "tiktoken-0.9.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc156cb314119a8bb9748257a2eaebd5cc0753b6cb491d26694ed42fc7cb3139"}, - {file = "tiktoken-0.9.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:cd69372e8c9dd761f0ab873112aba55a0e3e506332dd9f7522ca466e817b1b7a"}, - {file = "tiktoken-0.9.0-cp313-cp313-win_amd64.whl", hash = "sha256:5ea0edb6f83dc56d794723286215918c1cde03712cbbafa0348b33448faf5b95"}, - {file = "tiktoken-0.9.0-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:c6386ca815e7d96ef5b4ac61e0048cd32ca5a92d5781255e13b31381d28667dc"}, - {file = "tiktoken-0.9.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:75f6d5db5bc2c6274b674ceab1615c1778e6416b14705827d19b40e6355f03e0"}, - {file = "tiktoken-0.9.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e15b16f61e6f4625a57a36496d28dd182a8a60ec20a534c5343ba3cafa156ac7"}, - {file = "tiktoken-0.9.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ebcec91babf21297022882344c3f7d9eed855931466c3311b1ad6b64befb3df"}, - {file = "tiktoken-0.9.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:e5fd49e7799579240f03913447c0cdfa1129625ebd5ac440787afc4345990427"}, - {file = "tiktoken-0.9.0-cp39-cp39-win_amd64.whl", hash = "sha256:26242ca9dc8b58e875ff4ca078b9a94d2f0813e6a535dcd2205df5d49d927cc7"}, - {file = "tiktoken-0.9.0.tar.gz", hash = "sha256:d02a5ca6a938e0490e1ff957bc48c8b078c88cb83977be1625b1fd8aac792c5d"}, -] - -[package.dependencies] -regex = ">=2022.1.18" -requests = ">=2.26.0" - -[package.extras] -blobfile = ["blobfile (>=2)"] - [[package]] name = "tinycss2" version = "1.4.0" @@ -7125,25 +5614,6 @@ torchhub = ["filelock", "huggingface-hub (>=0.26.0,<1.0)", "importlib-metadata", video = ["av"] vision = ["Pillow (>=10.0.1,<=15.0)"] -[[package]] -name = "typer" -version = "0.15.2" -description = "Typer, build great CLIs. Easy to code. Based on Python type hints." -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "typer-0.15.2-py3-none-any.whl", hash = "sha256:46a499c6107d645a9c13f7ee46c5d5096cae6f5fc57dd11eccbbb9ae3e44ddfc"}, - {file = "typer-0.15.2.tar.gz", hash = "sha256:ab2fab47533a813c49fe1f16b1a370fd5819099c00b119e0633df65f22144ba5"}, -] - -[package.dependencies] -click = ">=8.0.0" -rich = ">=10.11.0" -shellingham = ">=1.3.0" -typing-extensions = ">=3.7.4.3" - [[package]] name = "types-python-dateutil" version = "2.9.0.20241206" @@ -7195,114 +5665,6 @@ files = [ {file = "tzdata-2025.2.tar.gz", hash = "sha256:b60a638fcc0daffadf82fe0f57e53d06bdec2f36c4df66280ae79bce6bd6f2b9"}, ] -[[package]] -name = "tzlocal" -version = "5.3.1" -description = "tzinfo object for the local timezone" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "tzlocal-5.3.1-py3-none-any.whl", hash = "sha256:eb1a66c3ef5847adf7a834f1be0800581b683b5608e74f86ecbcef8ab91bb85d"}, - {file = "tzlocal-5.3.1.tar.gz", hash = "sha256:cceffc7edecefea1f595541dbd6e990cb1ea3d19bf01b2809f362a03dd7921fd"}, -] - -[package.dependencies] -tzdata = {version = "*", markers = "platform_system == \"Windows\""} - -[package.extras] -devenv = ["check-manifest", "pytest (>=4.3)", "pytest-cov", "pytest-mock (>=3.3)", "zest.releaser"] - -[[package]] -name = "ujson" -version = "5.10.0" -description = "Ultra fast JSON encoder and decoder for Python" -optional = true -python-versions = ">=3.8" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "ujson-5.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:2601aa9ecdbee1118a1c2065323bda35e2c5a2cf0797ef4522d485f9d3ef65bd"}, - {file = "ujson-5.10.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:348898dd702fc1c4f1051bc3aacbf894caa0927fe2c53e68679c073375f732cf"}, - {file = "ujson-5.10.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:22cffecf73391e8abd65ef5f4e4dd523162a3399d5e84faa6aebbf9583df86d6"}, - {file = "ujson-5.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26b0e2d2366543c1bb4fbd457446f00b0187a2bddf93148ac2da07a53fe51569"}, - {file = "ujson-5.10.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:caf270c6dba1be7a41125cd1e4fc7ba384bf564650beef0df2dd21a00b7f5770"}, - {file = "ujson-5.10.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a245d59f2ffe750446292b0094244df163c3dc96b3ce152a2c837a44e7cda9d1"}, - {file = "ujson-5.10.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:94a87f6e151c5f483d7d54ceef83b45d3a9cca7a9cb453dbdbb3f5a6f64033f5"}, - {file = "ujson-5.10.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:29b443c4c0a113bcbb792c88bea67b675c7ca3ca80c3474784e08bba01c18d51"}, - {file = "ujson-5.10.0-cp310-cp310-win32.whl", hash = "sha256:c18610b9ccd2874950faf474692deee4223a994251bc0a083c114671b64e6518"}, - {file = "ujson-5.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:924f7318c31874d6bb44d9ee1900167ca32aa9b69389b98ecbde34c1698a250f"}, - {file = "ujson-5.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a5b366812c90e69d0f379a53648be10a5db38f9d4ad212b60af00bd4048d0f00"}, - {file = "ujson-5.10.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:502bf475781e8167f0f9d0e41cd32879d120a524b22358e7f205294224c71126"}, - {file = "ujson-5.10.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5b91b5d0d9d283e085e821651184a647699430705b15bf274c7896f23fe9c9d8"}, - {file = "ujson-5.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:129e39af3a6d85b9c26d5577169c21d53821d8cf68e079060602e861c6e5da1b"}, - {file = "ujson-5.10.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f77b74475c462cb8b88680471193064d3e715c7c6074b1c8c412cb526466efe9"}, - {file = "ujson-5.10.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:7ec0ca8c415e81aa4123501fee7f761abf4b7f386aad348501a26940beb1860f"}, - {file = "ujson-5.10.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ab13a2a9e0b2865a6c6db9271f4b46af1c7476bfd51af1f64585e919b7c07fd4"}, - {file = "ujson-5.10.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:57aaf98b92d72fc70886b5a0e1a1ca52c2320377360341715dd3933a18e827b1"}, - {file = "ujson-5.10.0-cp311-cp311-win32.whl", hash = "sha256:2987713a490ceb27edff77fb184ed09acdc565db700ee852823c3dc3cffe455f"}, - {file = "ujson-5.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:f00ea7e00447918ee0eff2422c4add4c5752b1b60e88fcb3c067d4a21049a720"}, - {file = "ujson-5.10.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:98ba15d8cbc481ce55695beee9f063189dce91a4b08bc1d03e7f0152cd4bbdd5"}, - {file = "ujson-5.10.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a9d2edbf1556e4f56e50fab7d8ff993dbad7f54bac68eacdd27a8f55f433578e"}, - {file = "ujson-5.10.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6627029ae4f52d0e1a2451768c2c37c0c814ffc04f796eb36244cf16b8e57043"}, - {file = "ujson-5.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8ccb77b3e40b151e20519c6ae6d89bfe3f4c14e8e210d910287f778368bb3d1"}, - {file = "ujson-5.10.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f3caf9cd64abfeb11a3b661329085c5e167abbe15256b3b68cb5d914ba7396f3"}, - {file = "ujson-5.10.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6e32abdce572e3a8c3d02c886c704a38a1b015a1fb858004e03d20ca7cecbb21"}, - {file = "ujson-5.10.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a65b6af4d903103ee7b6f4f5b85f1bfd0c90ba4eeac6421aae436c9988aa64a2"}, - {file = "ujson-5.10.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:604a046d966457b6cdcacc5aa2ec5314f0e8c42bae52842c1e6fa02ea4bda42e"}, - {file = "ujson-5.10.0-cp312-cp312-win32.whl", hash = "sha256:6dea1c8b4fc921bf78a8ff00bbd2bfe166345f5536c510671bccececb187c80e"}, - {file = "ujson-5.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:38665e7d8290188b1e0d57d584eb8110951a9591363316dd41cf8686ab1d0abc"}, - {file = "ujson-5.10.0-cp313-cp313-macosx_10_9_x86_64.whl", hash = "sha256:618efd84dc1acbd6bff8eaa736bb6c074bfa8b8a98f55b61c38d4ca2c1f7f287"}, - {file = "ujson-5.10.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:38d5d36b4aedfe81dfe251f76c0467399d575d1395a1755de391e58985ab1c2e"}, - {file = "ujson-5.10.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67079b1f9fb29ed9a2914acf4ef6c02844b3153913eb735d4bf287ee1db6e557"}, - {file = "ujson-5.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d7d0e0ceeb8fe2468c70ec0c37b439dd554e2aa539a8a56365fd761edb418988"}, - {file = "ujson-5.10.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:59e02cd37bc7c44d587a0ba45347cc815fb7a5fe48de16bf05caa5f7d0d2e816"}, - {file = "ujson-5.10.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2a890b706b64e0065f02577bf6d8ca3b66c11a5e81fb75d757233a38c07a1f20"}, - {file = "ujson-5.10.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:621e34b4632c740ecb491efc7f1fcb4f74b48ddb55e65221995e74e2d00bbff0"}, - {file = "ujson-5.10.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b9500e61fce0cfc86168b248104e954fead61f9be213087153d272e817ec7b4f"}, - {file = "ujson-5.10.0-cp313-cp313-win32.whl", hash = "sha256:4c4fc16f11ac1612f05b6f5781b384716719547e142cfd67b65d035bd85af165"}, - {file = "ujson-5.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:4573fd1695932d4f619928fd09d5d03d917274381649ade4328091ceca175539"}, - {file = "ujson-5.10.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:a984a3131da7f07563057db1c3020b1350a3e27a8ec46ccbfbf21e5928a43050"}, - {file = "ujson-5.10.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:73814cd1b9db6fc3270e9d8fe3b19f9f89e78ee9d71e8bd6c9a626aeaeaf16bd"}, - {file = "ujson-5.10.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:61e1591ed9376e5eddda202ec229eddc56c612b61ac6ad07f96b91460bb6c2fb"}, - {file = "ujson-5.10.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2c75269f8205b2690db4572a4a36fe47cd1338e4368bc73a7a0e48789e2e35a"}, - {file = "ujson-5.10.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7223f41e5bf1f919cd8d073e35b229295aa8e0f7b5de07ed1c8fddac63a6bc5d"}, - {file = "ujson-5.10.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d4dc2fd6b3067c0782e7002ac3b38cf48608ee6366ff176bbd02cf969c9c20fe"}, - {file = "ujson-5.10.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:232cc85f8ee3c454c115455195a205074a56ff42608fd6b942aa4c378ac14dd7"}, - {file = "ujson-5.10.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:cc6139531f13148055d691e442e4bc6601f6dba1e6d521b1585d4788ab0bfad4"}, - {file = "ujson-5.10.0-cp38-cp38-win32.whl", hash = "sha256:e7ce306a42b6b93ca47ac4a3b96683ca554f6d35dd8adc5acfcd55096c8dfcb8"}, - {file = "ujson-5.10.0-cp38-cp38-win_amd64.whl", hash = "sha256:e82d4bb2138ab05e18f089a83b6564fee28048771eb63cdecf4b9b549de8a2cc"}, - {file = "ujson-5.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:dfef2814c6b3291c3c5f10065f745a1307d86019dbd7ea50e83504950136ed5b"}, - {file = "ujson-5.10.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4734ee0745d5928d0ba3a213647f1c4a74a2a28edc6d27b2d6d5bd9fa4319e27"}, - {file = "ujson-5.10.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d47ebb01bd865fdea43da56254a3930a413f0c5590372a1241514abae8aa7c76"}, - {file = "ujson-5.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dee5e97c2496874acbf1d3e37b521dd1f307349ed955e62d1d2f05382bc36dd5"}, - {file = "ujson-5.10.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7490655a2272a2d0b072ef16b0b58ee462f4973a8f6bbe64917ce5e0a256f9c0"}, - {file = "ujson-5.10.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:ba17799fcddaddf5c1f75a4ba3fd6441f6a4f1e9173f8a786b42450851bd74f1"}, - {file = "ujson-5.10.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2aff2985cef314f21d0fecc56027505804bc78802c0121343874741650a4d3d1"}, - {file = "ujson-5.10.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:ad88ac75c432674d05b61184178635d44901eb749786c8eb08c102330e6e8996"}, - {file = "ujson-5.10.0-cp39-cp39-win32.whl", hash = "sha256:2544912a71da4ff8c4f7ab5606f947d7299971bdd25a45e008e467ca638d13c9"}, - {file = "ujson-5.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:3ff201d62b1b177a46f113bb43ad300b424b7847f9c5d38b1b4ad8f75d4a282a"}, - {file = "ujson-5.10.0-pp310-pypy310_pp73-macosx_10_9_x86_64.whl", hash = "sha256:5b6fee72fa77dc172a28f21693f64d93166534c263adb3f96c413ccc85ef6e64"}, - {file = "ujson-5.10.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:61d0af13a9af01d9f26d2331ce49bb5ac1fb9c814964018ac8df605b5422dcb3"}, - {file = "ujson-5.10.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ecb24f0bdd899d368b715c9e6664166cf694d1e57be73f17759573a6986dd95a"}, - {file = "ujson-5.10.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fbd8fd427f57a03cff3ad6574b5e299131585d9727c8c366da4624a9069ed746"}, - {file = "ujson-5.10.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:beeaf1c48e32f07d8820c705ff8e645f8afa690cca1544adba4ebfa067efdc88"}, - {file = "ujson-5.10.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:baed37ea46d756aca2955e99525cc02d9181de67f25515c468856c38d52b5f3b"}, - {file = "ujson-5.10.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7663960f08cd5a2bb152f5ee3992e1af7690a64c0e26d31ba7b3ff5b2ee66337"}, - {file = "ujson-5.10.0-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:d8640fb4072d36b08e95a3a380ba65779d356b2fee8696afeb7794cf0902d0a1"}, - {file = "ujson-5.10.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78778a3aa7aafb11e7ddca4e29f46bc5139131037ad628cc10936764282d6753"}, - {file = "ujson-5.10.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b0111b27f2d5c820e7f2dbad7d48e3338c824e7ac4d2a12da3dc6061cc39c8e6"}, - {file = "ujson-5.10.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:c66962ca7565605b355a9ed478292da628b8f18c0f2793021ca4425abf8b01e5"}, - {file = "ujson-5.10.0-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:ba43cc34cce49cf2d4bc76401a754a81202d8aa926d0e2b79f0ee258cb15d3a4"}, - {file = "ujson-5.10.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:ac56eb983edce27e7f51d05bc8dd820586c6e6be1c5216a6809b0c668bb312b8"}, - {file = "ujson-5.10.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f44bd4b23a0e723bf8b10628288c2c7c335161d6840013d4d5de20e48551773b"}, - {file = "ujson-5.10.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7c10f4654e5326ec14a46bcdeb2b685d4ada6911050aa8baaf3501e57024b804"}, - {file = "ujson-5.10.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0de4971a89a762398006e844ae394bd46991f7c385d7a6a3b93ba229e6dac17e"}, - {file = "ujson-5.10.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e1402f0564a97d2a52310ae10a64d25bcef94f8dd643fcf5d310219d915484f7"}, - {file = "ujson-5.10.0.tar.gz", hash = "sha256:b3cd8f3c5d8c7738257f1018880444f7b7d9b66232c64649f562d7ba86ad4bc1"}, -] - [[package]] name = "ultralytics" version = "8.3.104" @@ -7391,86 +5753,6 @@ h2 = ["h2 (>=4,<5)"] socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] zstd = ["zstandard (>=0.18.0)"] -[[package]] -name = "uvicorn" -version = "0.22.0" -description = "The lightning-fast ASGI server." -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "uvicorn-0.22.0-py3-none-any.whl", hash = "sha256:e9434d3bbf05f310e762147f769c9f21235ee118ba2d2bf1155a7196448bd996"}, - {file = "uvicorn-0.22.0.tar.gz", hash = "sha256:79277ae03db57ce7d9aa0567830bbb51d7a612f54d6e1e3e92da3ef24c2c8ed8"}, -] - -[package.dependencies] -click = ">=7.0" -colorama = {version = ">=0.4", optional = true, markers = "sys_platform == \"win32\" and extra == \"standard\""} -h11 = ">=0.8" -httptools = {version = ">=0.5.0", optional = true, markers = "extra == \"standard\""} -python-dotenv = {version = ">=0.13", optional = true, markers = "extra == \"standard\""} -pyyaml = {version = ">=5.1", optional = true, markers = "extra == \"standard\""} -uvloop = {version = ">=0.14.0,<0.15.0 || >0.15.0,<0.15.1 || >0.15.1", optional = true, markers = "sys_platform != \"win32\" and sys_platform != \"cygwin\" and platform_python_implementation != \"PyPy\" and extra == \"standard\""} -watchfiles = {version = ">=0.13", optional = true, markers = "extra == \"standard\""} -websockets = {version = ">=10.4", optional = true, markers = "extra == \"standard\""} - -[package.extras] -standard = ["colorama (>=0.4) ; sys_platform == \"win32\"", "httptools (>=0.5.0)", "python-dotenv (>=0.13)", "pyyaml (>=5.1)", "uvloop (>=0.14.0,!=0.15.0,!=0.15.1) ; sys_platform != \"win32\" and sys_platform != \"cygwin\" and platform_python_implementation != \"PyPy\"", "watchfiles (>=0.13)", "websockets (>=10.4)"] - -[[package]] -name = "uvloop" -version = "0.21.0" -description = "Fast implementation of asyncio event loop on top of libuv" -optional = true -python-versions = ">=3.8.0" -groups = ["main"] -markers = "sys_platform != \"win32\" and sys_platform != \"cygwin\" and platform_python_implementation != \"PyPy\" and extra == \"llm\"" -files = [ - {file = "uvloop-0.21.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:ec7e6b09a6fdded42403182ab6b832b71f4edaf7f37a9a0e371a01db5f0cb45f"}, - {file = "uvloop-0.21.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:196274f2adb9689a289ad7d65700d37df0c0930fd8e4e743fa4834e850d7719d"}, - {file = "uvloop-0.21.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f38b2e090258d051d68a5b14d1da7203a3c3677321cf32a95a6f4db4dd8b6f26"}, - {file = "uvloop-0.21.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87c43e0f13022b998eb9b973b5e97200c8b90823454d4bc06ab33829e09fb9bb"}, - {file = "uvloop-0.21.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:10d66943def5fcb6e7b37310eb6b5639fd2ccbc38df1177262b0640c3ca68c1f"}, - {file = "uvloop-0.21.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:67dd654b8ca23aed0a8e99010b4c34aca62f4b7fce88f39d452ed7622c94845c"}, - {file = "uvloop-0.21.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:c0f3fa6200b3108919f8bdabb9a7f87f20e7097ea3c543754cabc7d717d95cf8"}, - {file = "uvloop-0.21.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0878c2640cf341b269b7e128b1a5fed890adc4455513ca710d77d5e93aa6d6a0"}, - {file = "uvloop-0.21.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9fb766bb57b7388745d8bcc53a359b116b8a04c83a2288069809d2b3466c37e"}, - {file = "uvloop-0.21.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8a375441696e2eda1c43c44ccb66e04d61ceeffcd76e4929e527b7fa401b90fb"}, - {file = "uvloop-0.21.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:baa0e6291d91649c6ba4ed4b2f982f9fa165b5bbd50a9e203c416a2797bab3c6"}, - {file = "uvloop-0.21.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:4509360fcc4c3bd2c70d87573ad472de40c13387f5fda8cb58350a1d7475e58d"}, - {file = "uvloop-0.21.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:359ec2c888397b9e592a889c4d72ba3d6befba8b2bb01743f72fffbde663b59c"}, - {file = "uvloop-0.21.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f7089d2dc73179ce5ac255bdf37c236a9f914b264825fdaacaded6990a7fb4c2"}, - {file = "uvloop-0.21.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:baa4dcdbd9ae0a372f2167a207cd98c9f9a1ea1188a8a526431eef2f8116cc8d"}, - {file = "uvloop-0.21.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86975dca1c773a2c9864f4c52c5a55631038e387b47eaf56210f873887b6c8dc"}, - {file = "uvloop-0.21.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:461d9ae6660fbbafedd07559c6a2e57cd553b34b0065b6550685f6653a98c1cb"}, - {file = "uvloop-0.21.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:183aef7c8730e54c9a3ee3227464daed66e37ba13040bb3f350bc2ddc040f22f"}, - {file = "uvloop-0.21.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:bfd55dfcc2a512316e65f16e503e9e450cab148ef11df4e4e679b5e8253a5281"}, - {file = "uvloop-0.21.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:787ae31ad8a2856fc4e7c095341cccc7209bd657d0e71ad0dc2ea83c4a6fa8af"}, - {file = "uvloop-0.21.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5ee4d4ef48036ff6e5cfffb09dd192c7a5027153948d85b8da7ff705065bacc6"}, - {file = "uvloop-0.21.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3df876acd7ec037a3d005b3ab85a7e4110422e4d9c1571d4fc89b0fc41b6816"}, - {file = "uvloop-0.21.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd53ecc9a0f3d87ab847503c2e1552b690362e005ab54e8a48ba97da3924c0dc"}, - {file = "uvloop-0.21.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a5c39f217ab3c663dc699c04cbd50c13813e31d917642d459fdcec07555cc553"}, - {file = "uvloop-0.21.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:17df489689befc72c39a08359efac29bbee8eee5209650d4b9f34df73d22e414"}, - {file = "uvloop-0.21.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:bc09f0ff191e61c2d592a752423c767b4ebb2986daa9ed62908e2b1b9a9ae206"}, - {file = "uvloop-0.21.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f0ce1b49560b1d2d8a2977e3ba4afb2414fb46b86a1b64056bc4ab929efdafbe"}, - {file = "uvloop-0.21.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e678ad6fe52af2c58d2ae3c73dc85524ba8abe637f134bf3564ed07f555c5e79"}, - {file = "uvloop-0.21.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:460def4412e473896ef179a1671b40c039c7012184b627898eea5072ef6f017a"}, - {file = "uvloop-0.21.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:10da8046cc4a8f12c91a1c39d1dd1585c41162a15caaef165c2174db9ef18bdc"}, - {file = "uvloop-0.21.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:c097078b8031190c934ed0ebfee8cc5f9ba9642e6eb88322b9958b649750f72b"}, - {file = "uvloop-0.21.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:46923b0b5ee7fc0020bef24afe7836cb068f5050ca04caf6b487c513dc1a20b2"}, - {file = "uvloop-0.21.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:53e420a3afe22cdcf2a0f4846e377d16e718bc70103d7088a4f7623567ba5fb0"}, - {file = "uvloop-0.21.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88cb67cdbc0e483da00af0b2c3cdad4b7c61ceb1ee0f33fe00e09c81e3a6cb75"}, - {file = "uvloop-0.21.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:221f4f2a1f46032b403bf3be628011caf75428ee3cc204a22addf96f586b19fd"}, - {file = "uvloop-0.21.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:2d1f581393673ce119355d56da84fe1dd9d2bb8b3d13ce792524e1607139feff"}, - {file = "uvloop-0.21.0.tar.gz", hash = "sha256:3bf12b0fda68447806a7ad847bfa591613177275d35b6724b1ee573faa3704e3"}, -] - -[package.extras] -dev = ["Cython (>=3.0,<4.0)", "setuptools (>=60)"] -docs = ["Sphinx (>=4.1.2,<4.2.0)", "sphinx-rtd-theme (>=0.5.2,<0.6.0)", "sphinxcontrib-asyncio (>=0.3.0,<0.4.0)"] -test = ["aiohttp (>=3.10.5)", "flake8 (>=5.0,<6.0)", "mypy (>=0.800)", "psutil", "pyOpenSSL (>=23.0.0,<23.1.0)", "pycodestyle (>=2.9.0,<2.10.0)"] - [[package]] name = "virtualenv" version = "20.30.0" @@ -7492,91 +5774,6 @@ platformdirs = ">=3.9.1,<5" docs = ["furo (>=2023.7.26)", "proselint (>=0.13)", "sphinx (>=7.1.2,!=7.3)", "sphinx-argparse (>=0.4)", "sphinxcontrib-towncrier (>=0.2.1a0)", "towncrier (>=23.6)"] test = ["covdefaults (>=2.3)", "coverage (>=7.2.7)", "coverage-enable-subprocess (>=1)", "flaky (>=3.7)", "packaging (>=23.1)", "pytest (>=7.4)", "pytest-env (>=0.8.2)", "pytest-freezer (>=0.4.8) ; platform_python_implementation == \"PyPy\" or platform_python_implementation == \"GraalVM\" or platform_python_implementation == \"CPython\" and sys_platform == \"win32\" and python_version >= \"3.13\"", "pytest-mock (>=3.11.1)", "pytest-randomly (>=3.12)", "pytest-timeout (>=2.1)", "setuptools (>=68)", "time-machine (>=2.10) ; platform_python_implementation == \"CPython\""] -[[package]] -name = "watchfiles" -version = "1.0.5" -description = "Simple, modern and high performance file watching and code reload in python." -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "watchfiles-1.0.5-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:5c40fe7dd9e5f81e0847b1ea64e1f5dd79dd61afbedb57759df06767ac719b40"}, - {file = "watchfiles-1.0.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8c0db396e6003d99bb2d7232c957b5f0b5634bbd1b24e381a5afcc880f7373fb"}, - {file = "watchfiles-1.0.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b551d4fb482fc57d852b4541f911ba28957d051c8776e79c3b4a51eb5e2a1b11"}, - {file = "watchfiles-1.0.5-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:830aa432ba5c491d52a15b51526c29e4a4b92bf4f92253787f9726fe01519487"}, - {file = "watchfiles-1.0.5-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a16512051a822a416b0d477d5f8c0e67b67c1a20d9acecb0aafa3aa4d6e7d256"}, - {file = "watchfiles-1.0.5-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:bfe0cbc787770e52a96c6fda6726ace75be7f840cb327e1b08d7d54eadc3bc85"}, - {file = "watchfiles-1.0.5-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d363152c5e16b29d66cbde8fa614f9e313e6f94a8204eaab268db52231fe5358"}, - {file = "watchfiles-1.0.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7ee32c9a9bee4d0b7bd7cbeb53cb185cf0b622ac761efaa2eba84006c3b3a614"}, - {file = "watchfiles-1.0.5-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:29c7fd632ccaf5517c16a5188e36f6612d6472ccf55382db6c7fe3fcccb7f59f"}, - {file = "watchfiles-1.0.5-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:8e637810586e6fe380c8bc1b3910accd7f1d3a9a7262c8a78d4c8fb3ba6a2b3d"}, - {file = "watchfiles-1.0.5-cp310-cp310-win32.whl", hash = "sha256:cd47d063fbeabd4c6cae1d4bcaa38f0902f8dc5ed168072874ea11d0c7afc1ff"}, - {file = "watchfiles-1.0.5-cp310-cp310-win_amd64.whl", hash = "sha256:86c0df05b47a79d80351cd179893f2f9c1b1cae49d96e8b3290c7f4bd0ca0a92"}, - {file = "watchfiles-1.0.5-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:237f9be419e977a0f8f6b2e7b0475ababe78ff1ab06822df95d914a945eac827"}, - {file = "watchfiles-1.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e0da39ff917af8b27a4bdc5a97ac577552a38aac0d260a859c1517ea3dc1a7c4"}, - {file = "watchfiles-1.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2cfcb3952350e95603f232a7a15f6c5f86c5375e46f0bd4ae70d43e3e063c13d"}, - {file = "watchfiles-1.0.5-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:68b2dddba7a4e6151384e252a5632efcaa9bc5d1c4b567f3cb621306b2ca9f63"}, - {file = "watchfiles-1.0.5-cp311-cp311-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:95cf944fcfc394c5f9de794ce581914900f82ff1f855326f25ebcf24d5397418"}, - {file = "watchfiles-1.0.5-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ecf6cd9f83d7c023b1aba15d13f705ca7b7d38675c121f3cc4a6e25bd0857ee9"}, - {file = "watchfiles-1.0.5-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:852de68acd6212cd6d33edf21e6f9e56e5d98c6add46f48244bd479d97c967c6"}, - {file = "watchfiles-1.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5730f3aa35e646103b53389d5bc77edfbf578ab6dab2e005142b5b80a35ef25"}, - {file = "watchfiles-1.0.5-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:18b3bd29954bc4abeeb4e9d9cf0b30227f0f206c86657674f544cb032296acd5"}, - {file = "watchfiles-1.0.5-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:ba5552a1b07c8edbf197055bc9d518b8f0d98a1c6a73a293bc0726dce068ed01"}, - {file = "watchfiles-1.0.5-cp311-cp311-win32.whl", hash = "sha256:2f1fefb2e90e89959447bc0420fddd1e76f625784340d64a2f7d5983ef9ad246"}, - {file = "watchfiles-1.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:b6e76ceb1dd18c8e29c73f47d41866972e891fc4cc7ba014f487def72c1cf096"}, - {file = "watchfiles-1.0.5-cp311-cp311-win_arm64.whl", hash = "sha256:266710eb6fddc1f5e51843c70e3bebfb0f5e77cf4f27129278c70554104d19ed"}, - {file = "watchfiles-1.0.5-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:b5eb568c2aa6018e26da9e6c86f3ec3fd958cee7f0311b35c2630fa4217d17f2"}, - {file = "watchfiles-1.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0a04059f4923ce4e856b4b4e5e783a70f49d9663d22a4c3b3298165996d1377f"}, - {file = "watchfiles-1.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3e380c89983ce6e6fe2dd1e1921b9952fb4e6da882931abd1824c092ed495dec"}, - {file = "watchfiles-1.0.5-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:fe43139b2c0fdc4a14d4f8d5b5d967f7a2777fd3d38ecf5b1ec669b0d7e43c21"}, - {file = "watchfiles-1.0.5-cp312-cp312-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee0822ce1b8a14fe5a066f93edd20aada932acfe348bede8aa2149f1a4489512"}, - {file = "watchfiles-1.0.5-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a0dbcb1c2d8f2ab6e0a81c6699b236932bd264d4cef1ac475858d16c403de74d"}, - {file = "watchfiles-1.0.5-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a2014a2b18ad3ca53b1f6c23f8cd94a18ce930c1837bd891262c182640eb40a6"}, - {file = "watchfiles-1.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f6ae86d5cb647bf58f9f655fcf577f713915a5d69057a0371bc257e2553234"}, - {file = "watchfiles-1.0.5-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:1a7bac2bde1d661fb31f4d4e8e539e178774b76db3c2c17c4bb3e960a5de07a2"}, - {file = "watchfiles-1.0.5-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ab626da2fc1ac277bbf752446470b367f84b50295264d2d313e28dc4405d663"}, - {file = "watchfiles-1.0.5-cp312-cp312-win32.whl", hash = "sha256:9f4571a783914feda92018ef3901dab8caf5b029325b5fe4558c074582815249"}, - {file = "watchfiles-1.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:360a398c3a19672cf93527f7e8d8b60d8275119c5d900f2e184d32483117a705"}, - {file = "watchfiles-1.0.5-cp312-cp312-win_arm64.whl", hash = "sha256:1a2902ede862969077b97523987c38db28abbe09fb19866e711485d9fbf0d417"}, - {file = "watchfiles-1.0.5-cp313-cp313-macosx_10_12_x86_64.whl", hash = "sha256:0b289572c33a0deae62daa57e44a25b99b783e5f7aed81b314232b3d3c81a11d"}, - {file = "watchfiles-1.0.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a056c2f692d65bf1e99c41045e3bdcaea3cb9e6b5a53dcaf60a5f3bd95fc9763"}, - {file = "watchfiles-1.0.5-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b9dca99744991fc9850d18015c4f0438865414e50069670f5f7eee08340d8b40"}, - {file = "watchfiles-1.0.5-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:894342d61d355446d02cd3988a7326af344143eb33a2fd5d38482a92072d9563"}, - {file = "watchfiles-1.0.5-cp313-cp313-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ab44e1580924d1ffd7b3938e02716d5ad190441965138b4aa1d1f31ea0877f04"}, - {file = "watchfiles-1.0.5-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d6f9367b132078b2ceb8d066ff6c93a970a18c3029cea37bfd7b2d3dd2e5db8f"}, - {file = "watchfiles-1.0.5-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2e55a9b162e06e3f862fb61e399fe9f05d908d019d87bf5b496a04ef18a970a"}, - {file = "watchfiles-1.0.5-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0125f91f70e0732a9f8ee01e49515c35d38ba48db507a50c5bdcad9503af5827"}, - {file = "watchfiles-1.0.5-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:13bb21f8ba3248386337c9fa51c528868e6c34a707f729ab041c846d52a0c69a"}, - {file = "watchfiles-1.0.5-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:839ebd0df4a18c5b3c1b890145b5a3f5f64063c2a0d02b13c76d78fe5de34936"}, - {file = "watchfiles-1.0.5-cp313-cp313-win32.whl", hash = "sha256:4a8ec1e4e16e2d5bafc9ba82f7aaecfeec990ca7cd27e84fb6f191804ed2fcfc"}, - {file = "watchfiles-1.0.5-cp313-cp313-win_amd64.whl", hash = "sha256:f436601594f15bf406518af922a89dcaab416568edb6f65c4e5bbbad1ea45c11"}, - {file = "watchfiles-1.0.5-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:2cfb371be97d4db374cba381b9f911dd35bb5f4c58faa7b8b7106c8853e5d225"}, - {file = "watchfiles-1.0.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a3904d88955fda461ea2531fcf6ef73584ca921415d5cfa44457a225f4a42bc1"}, - {file = "watchfiles-1.0.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2b7a21715fb12274a71d335cff6c71fe7f676b293d322722fe708a9ec81d91f5"}, - {file = "watchfiles-1.0.5-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:dfd6ae1c385ab481766b3c61c44aca2b3cd775f6f7c0fa93d979ddec853d29d5"}, - {file = "watchfiles-1.0.5-cp39-cp39-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b659576b950865fdad31fa491d31d37cf78b27113a7671d39f919828587b429b"}, - {file = "watchfiles-1.0.5-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:1909e0a9cd95251b15bff4261de5dd7550885bd172e3536824bf1cf6b121e200"}, - {file = "watchfiles-1.0.5-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:832ccc221927c860e7286c55c9b6ebcc0265d5e072f49c7f6456c7798d2b39aa"}, - {file = "watchfiles-1.0.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85fbb6102b3296926d0c62cfc9347f6237fb9400aecd0ba6bbda94cae15f2b3b"}, - {file = "watchfiles-1.0.5-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:15ac96dd567ad6c71c71f7b2c658cb22b7734901546cd50a475128ab557593ca"}, - {file = "watchfiles-1.0.5-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:4b6227351e11c57ae997d222e13f5b6f1f0700d84b8c52304e8675d33a808382"}, - {file = "watchfiles-1.0.5-cp39-cp39-win32.whl", hash = "sha256:974866e0db748ebf1eccab17862bc0f0303807ed9cda465d1324625b81293a18"}, - {file = "watchfiles-1.0.5-cp39-cp39-win_amd64.whl", hash = "sha256:9848b21ae152fe79c10dd0197304ada8f7b586d3ebc3f27f43c506e5a52a863c"}, - {file = "watchfiles-1.0.5-pp310-pypy310_pp73-macosx_10_12_x86_64.whl", hash = "sha256:f59b870db1f1ae5a9ac28245707d955c8721dd6565e7f411024fa374b5362d1d"}, - {file = "watchfiles-1.0.5-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:9475b0093767e1475095f2aeb1d219fb9664081d403d1dff81342df8cd707034"}, - {file = "watchfiles-1.0.5-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fc533aa50664ebd6c628b2f30591956519462f5d27f951ed03d6c82b2dfd9965"}, - {file = "watchfiles-1.0.5-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fed1cd825158dcaae36acce7b2db33dcbfd12b30c34317a88b8ed80f0541cc57"}, - {file = "watchfiles-1.0.5-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:554389562c29c2c182e3908b149095051f81d28c2fec79ad6c8997d7d63e0009"}, - {file = "watchfiles-1.0.5-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:a74add8d7727e6404d5dc4dcd7fac65d4d82f95928bbee0cf5414c900e86773e"}, - {file = "watchfiles-1.0.5-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cb1489f25b051a89fae574505cc26360c8e95e227a9500182a7fe0afcc500ce0"}, - {file = "watchfiles-1.0.5-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0901429650652d3f0da90bad42bdafc1f9143ff3605633c455c999a2d786cac"}, - {file = "watchfiles-1.0.5.tar.gz", hash = "sha256:b7529b5dcc114679d43827d8c35a07c493ad6f083633d573d81c660abc5979e9"}, -] - -[package.dependencies] -anyio = ">=3.0.0" - [[package]] name = "wcwidth" version = "0.2.13" @@ -7630,86 +5827,6 @@ docs = ["Sphinx (>=6.0)", "myst-parser (>=2.0.0)", "sphinx-rtd-theme (>=1.1.0)"] optional = ["python-socks", "wsaccel"] test = ["websockets"] -[[package]] -name = "websockets" -version = "15.0.1" -description = "An implementation of the WebSocket Protocol (RFC 6455 & 7692)" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "websockets-15.0.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:d63efaa0cd96cf0c5fe4d581521d9fa87744540d4bc999ae6e08595a1014b45b"}, - {file = "websockets-15.0.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ac60e3b188ec7574cb761b08d50fcedf9d77f1530352db4eef1707fe9dee7205"}, - {file = "websockets-15.0.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5756779642579d902eed757b21b0164cd6fe338506a8083eb58af5c372e39d9a"}, - {file = "websockets-15.0.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0fdfe3e2a29e4db3659dbd5bbf04560cea53dd9610273917799f1cde46aa725e"}, - {file = "websockets-15.0.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4c2529b320eb9e35af0fa3016c187dffb84a3ecc572bcee7c3ce302bfeba52bf"}, - {file = "websockets-15.0.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac1e5c9054fe23226fb11e05a6e630837f074174c4c2f0fe442996112a6de4fb"}, - {file = "websockets-15.0.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:5df592cd503496351d6dc14f7cdad49f268d8e618f80dce0cd5a36b93c3fc08d"}, - {file = "websockets-15.0.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0a34631031a8f05657e8e90903e656959234f3a04552259458aac0b0f9ae6fd9"}, - {file = "websockets-15.0.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3d00075aa65772e7ce9e990cab3ff1de702aa09be3940d1dc88d5abf1ab8a09c"}, - {file = "websockets-15.0.1-cp310-cp310-win32.whl", hash = "sha256:1234d4ef35db82f5446dca8e35a7da7964d02c127b095e172e54397fb6a6c256"}, - {file = "websockets-15.0.1-cp310-cp310-win_amd64.whl", hash = "sha256:39c1fec2c11dc8d89bba6b2bf1556af381611a173ac2b511cf7231622058af41"}, - {file = "websockets-15.0.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:823c248b690b2fd9303ba00c4f66cd5e2d8c3ba4aa968b2779be9532a4dad431"}, - {file = "websockets-15.0.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678999709e68425ae2593acf2e3ebcbcf2e69885a5ee78f9eb80e6e371f1bf57"}, - {file = "websockets-15.0.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d50fd1ee42388dcfb2b3676132c78116490976f1300da28eb629272d5d93e905"}, - {file = "websockets-15.0.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d99e5546bf73dbad5bf3547174cd6cb8ba7273062a23808ffea025ecb1cf8562"}, - {file = "websockets-15.0.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:66dd88c918e3287efc22409d426c8f729688d89a0c587c88971a0faa2c2f3792"}, - {file = "websockets-15.0.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8dd8327c795b3e3f219760fa603dcae1dcc148172290a8ab15158cf85a953413"}, - {file = "websockets-15.0.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8fdc51055e6ff4adeb88d58a11042ec9a5eae317a0a53d12c062c8a8865909e8"}, - {file = "websockets-15.0.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:693f0192126df6c2327cce3baa7c06f2a117575e32ab2308f7f8216c29d9e2e3"}, - {file = "websockets-15.0.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:54479983bd5fb469c38f2f5c7e3a24f9a4e70594cd68cd1fa6b9340dadaff7cf"}, - {file = "websockets-15.0.1-cp311-cp311-win32.whl", hash = "sha256:16b6c1b3e57799b9d38427dda63edcbe4926352c47cf88588c0be4ace18dac85"}, - {file = "websockets-15.0.1-cp311-cp311-win_amd64.whl", hash = "sha256:27ccee0071a0e75d22cb35849b1db43f2ecd3e161041ac1ee9d2352ddf72f065"}, - {file = "websockets-15.0.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:3e90baa811a5d73f3ca0bcbf32064d663ed81318ab225ee4f427ad4e26e5aff3"}, - {file = "websockets-15.0.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:592f1a9fe869c778694f0aa806ba0374e97648ab57936f092fd9d87f8bc03665"}, - {file = "websockets-15.0.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0701bc3cfcb9164d04a14b149fd74be7347a530ad3bbf15ab2c678a2cd3dd9a2"}, - {file = "websockets-15.0.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e8b56bdcdb4505c8078cb6c7157d9811a85790f2f2b3632c7d1462ab5783d215"}, - {file = "websockets-15.0.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0af68c55afbd5f07986df82831c7bff04846928ea8d1fd7f30052638788bc9b5"}, - {file = "websockets-15.0.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:64dee438fed052b52e4f98f76c5790513235efaa1ef7f3f2192c392cd7c91b65"}, - {file = "websockets-15.0.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:d5f6b181bb38171a8ad1d6aa58a67a6aa9d4b38d0f8c5f496b9e42561dfc62fe"}, - {file = "websockets-15.0.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:5d54b09eba2bada6011aea5375542a157637b91029687eb4fdb2dab11059c1b4"}, - {file = "websockets-15.0.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3be571a8b5afed347da347bfcf27ba12b069d9d7f42cb8c7028b5e98bbb12597"}, - {file = "websockets-15.0.1-cp312-cp312-win32.whl", hash = "sha256:c338ffa0520bdb12fbc527265235639fb76e7bc7faafbb93f6ba80d9c06578a9"}, - {file = "websockets-15.0.1-cp312-cp312-win_amd64.whl", hash = "sha256:fcd5cf9e305d7b8338754470cf69cf81f420459dbae8a3b40cee57417f4614a7"}, - {file = "websockets-15.0.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:ee443ef070bb3b6ed74514f5efaa37a252af57c90eb33b956d35c8e9c10a1931"}, - {file = "websockets-15.0.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5a939de6b7b4e18ca683218320fc67ea886038265fd1ed30173f5ce3f8e85675"}, - {file = "websockets-15.0.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:746ee8dba912cd6fc889a8147168991d50ed70447bf18bcda7039f7d2e3d9151"}, - {file = "websockets-15.0.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:595b6c3969023ecf9041b2936ac3827e4623bfa3ccf007575f04c5a6aa318c22"}, - {file = "websockets-15.0.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3c714d2fc58b5ca3e285461a4cc0c9a66bd0e24c5da9911e30158286c9b5be7f"}, - {file = "websockets-15.0.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0f3c1e2ab208db911594ae5b4f79addeb3501604a165019dd221c0bdcabe4db8"}, - {file = "websockets-15.0.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:229cf1d3ca6c1804400b0a9790dc66528e08a6a1feec0d5040e8b9eb14422375"}, - {file = "websockets-15.0.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:756c56e867a90fb00177d530dca4b097dd753cde348448a1012ed6c5131f8b7d"}, - {file = "websockets-15.0.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:558d023b3df0bffe50a04e710bc87742de35060580a293c2a984299ed83bc4e4"}, - {file = "websockets-15.0.1-cp313-cp313-win32.whl", hash = "sha256:ba9e56e8ceeeedb2e080147ba85ffcd5cd0711b89576b83784d8605a7df455fa"}, - {file = "websockets-15.0.1-cp313-cp313-win_amd64.whl", hash = "sha256:e09473f095a819042ecb2ab9465aee615bd9c2028e4ef7d933600a8401c79561"}, - {file = "websockets-15.0.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:5f4c04ead5aed67c8a1a20491d54cdfba5884507a48dd798ecaf13c74c4489f5"}, - {file = "websockets-15.0.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:abdc0c6c8c648b4805c5eacd131910d2a7f6455dfd3becab248ef108e89ab16a"}, - {file = "websockets-15.0.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:a625e06551975f4b7ea7102bc43895b90742746797e2e14b70ed61c43a90f09b"}, - {file = "websockets-15.0.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d591f8de75824cbb7acad4e05d2d710484f15f29d4a915092675ad3456f11770"}, - {file = "websockets-15.0.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:47819cea040f31d670cc8d324bb6435c6f133b8c7a19ec3d61634e62f8d8f9eb"}, - {file = "websockets-15.0.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac017dd64572e5c3bd01939121e4d16cf30e5d7e110a119399cf3133b63ad054"}, - {file = "websockets-15.0.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:4a9fac8e469d04ce6c25bb2610dc535235bd4aa14996b4e6dbebf5e007eba5ee"}, - {file = "websockets-15.0.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:363c6f671b761efcb30608d24925a382497c12c506b51661883c3e22337265ed"}, - {file = "websockets-15.0.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:2034693ad3097d5355bfdacfffcbd3ef5694f9718ab7f29c29689a9eae841880"}, - {file = "websockets-15.0.1-cp39-cp39-win32.whl", hash = "sha256:3b1ac0d3e594bf121308112697cf4b32be538fb1444468fb0a6ae4feebc83411"}, - {file = "websockets-15.0.1-cp39-cp39-win_amd64.whl", hash = "sha256:b7643a03db5c95c799b89b31c036d5f27eeb4d259c798e878d6937d71832b1e4"}, - {file = "websockets-15.0.1-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0c9e74d766f2818bb95f84c25be4dea09841ac0f734d1966f415e4edfc4ef1c3"}, - {file = "websockets-15.0.1-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:1009ee0c7739c08a0cd59de430d6de452a55e42d6b522de7aa15e6f67db0b8e1"}, - {file = "websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76d1f20b1c7a2fa82367e04982e708723ba0e7b8d43aa643d3dcd404d74f1475"}, - {file = "websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f29d80eb9a9263b8d109135351caf568cc3f80b9928bccde535c235de55c22d9"}, - {file = "websockets-15.0.1-pp310-pypy310_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b359ed09954d7c18bbc1680f380c7301f92c60bf924171629c5db97febb12f04"}, - {file = "websockets-15.0.1-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:cad21560da69f4ce7658ca2cb83138fb4cf695a2ba3e475e0559e05991aa8122"}, - {file = "websockets-15.0.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7f493881579c90fc262d9cdbaa05a6b54b3811c2f300766748db79f098db9940"}, - {file = "websockets-15.0.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:47b099e1f4fbc95b701b6e85768e1fcdaf1630f3cbe4765fa216596f12310e2e"}, - {file = "websockets-15.0.1-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67f2b6de947f8c757db2db9c71527933ad0019737ec374a8a6be9a956786aaf9"}, - {file = "websockets-15.0.1-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d08eb4c2b7d6c41da6ca0600c077e93f5adcfd979cd777d747e9ee624556da4b"}, - {file = "websockets-15.0.1-pp39-pypy39_pp73-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4b826973a4a2ae47ba357e4e82fa44a463b8f168e1ca775ac64521442b19e87f"}, - {file = "websockets-15.0.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:21c1fa28a6a7e3cbdc171c694398b6df4744613ce9b36b1a498e816787e28123"}, - {file = "websockets-15.0.1-py3-none-any.whl", hash = "sha256:f7a866fbc1e97b5c617ee4116daaa09b722101d4a3c170c787450ba409f9736f"}, - {file = "websockets-15.0.1.tar.gz", hash = "sha256:82544de02076bafba038ce055ee6412d68da13ab47f0c60cab827346de828dee"}, -] - [[package]] name = "widgetsnbextension" version = "4.0.13" @@ -7811,270 +5928,12 @@ files = [ {file = "wrapt-1.17.2.tar.gz", hash = "sha256:41388e9d4d1522446fe79d3213196bd9e3b301a336965b9e27ca2788ebd122f3"}, ] -[[package]] -name = "xxhash" -version = "3.5.0" -description = "Python binding for xxHash" -optional = true -python-versions = ">=3.7" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "xxhash-3.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ece616532c499ee9afbb83078b1b952beffef121d989841f7f4b3dc5ac0fd212"}, - {file = "xxhash-3.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:3171f693dbc2cef6477054a665dc255d996646b4023fe56cb4db80e26f4cc520"}, - {file = "xxhash-3.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7c5d3e570ef46adaf93fc81b44aca6002b5a4d8ca11bd0580c07eac537f36680"}, - {file = "xxhash-3.5.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7cb29a034301e2982df8b1fe6328a84f4b676106a13e9135a0d7e0c3e9f806da"}, - {file = "xxhash-3.5.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d0d307d27099bb0cbeea7260eb39ed4fdb99c5542e21e94bb6fd29e49c57a23"}, - {file = "xxhash-3.5.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c0342aafd421795d740e514bc9858ebddfc705a75a8c5046ac56d85fe97bf196"}, - {file = "xxhash-3.5.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3dbbd9892c5ebffeca1ed620cf0ade13eb55a0d8c84e0751a6653adc6ac40d0c"}, - {file = "xxhash-3.5.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:4cc2d67fdb4d057730c75a64c5923abfa17775ae234a71b0200346bfb0a7f482"}, - {file = "xxhash-3.5.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:ec28adb204b759306a3d64358a5e5c07d7b1dd0ccbce04aa76cb9377b7b70296"}, - {file = "xxhash-3.5.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:1328f6d8cca2b86acb14104e381225a3d7b42c92c4b86ceae814e5c400dbb415"}, - {file = "xxhash-3.5.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:8d47ebd9f5d9607fd039c1fbf4994e3b071ea23eff42f4ecef246ab2b7334198"}, - {file = "xxhash-3.5.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b96d559e0fcddd3343c510a0fe2b127fbff16bf346dd76280b82292567523442"}, - {file = "xxhash-3.5.0-cp310-cp310-win32.whl", hash = "sha256:61c722ed8d49ac9bc26c7071eeaa1f6ff24053d553146d5df031802deffd03da"}, - {file = "xxhash-3.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:9bed5144c6923cc902cd14bb8963f2d5e034def4486ab0bbe1f58f03f042f9a9"}, - {file = "xxhash-3.5.0-cp310-cp310-win_arm64.whl", hash = "sha256:893074d651cf25c1cc14e3bea4fceefd67f2921b1bb8e40fcfeba56820de80c6"}, - {file = "xxhash-3.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:02c2e816896dc6f85922ced60097bcf6f008dedfc5073dcba32f9c8dd786f3c1"}, - {file = "xxhash-3.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:6027dcd885e21581e46d3c7f682cfb2b870942feeed58a21c29583512c3f09f8"}, - {file = "xxhash-3.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1308fa542bbdbf2fa85e9e66b1077eea3a88bef38ee8a06270b4298a7a62a166"}, - {file = "xxhash-3.5.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:c28b2fdcee797e1c1961cd3bcd3d545cab22ad202c846235197935e1df2f8ef7"}, - {file = "xxhash-3.5.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:924361811732ddad75ff23e90efd9ccfda4f664132feecb90895bade6a1b4623"}, - {file = "xxhash-3.5.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:89997aa1c4b6a5b1e5b588979d1da048a3c6f15e55c11d117a56b75c84531f5a"}, - {file = "xxhash-3.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:685c4f4e8c59837de103344eb1c8a3851f670309eb5c361f746805c5471b8c88"}, - {file = "xxhash-3.5.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dbd2ecfbfee70bc1a4acb7461fa6af7748ec2ab08ac0fa298f281c51518f982c"}, - {file = "xxhash-3.5.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:25b5a51dc3dfb20a10833c8eee25903fd2e14059e9afcd329c9da20609a307b2"}, - {file = "xxhash-3.5.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:a8fb786fb754ef6ff8c120cb96629fb518f8eb5a61a16aac3a979a9dbd40a084"}, - {file = "xxhash-3.5.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:a905ad00ad1e1c34fe4e9d7c1d949ab09c6fa90c919860c1534ff479f40fd12d"}, - {file = "xxhash-3.5.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:963be41bcd49f53af6d795f65c0da9b4cc518c0dd9c47145c98f61cb464f4839"}, - {file = "xxhash-3.5.0-cp311-cp311-win32.whl", hash = "sha256:109b436096d0a2dd039c355fa3414160ec4d843dfecc64a14077332a00aeb7da"}, - {file = "xxhash-3.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:b702f806693201ad6c0a05ddbbe4c8f359626d0b3305f766077d51388a6bac58"}, - {file = "xxhash-3.5.0-cp311-cp311-win_arm64.whl", hash = "sha256:c4dcb4120d0cc3cc448624147dba64e9021b278c63e34a38789b688fd0da9bf3"}, - {file = "xxhash-3.5.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:14470ace8bd3b5d51318782cd94e6f94431974f16cb3b8dc15d52f3b69df8e00"}, - {file = "xxhash-3.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:59aa1203de1cb96dbeab595ded0ad0c0056bb2245ae11fac11c0ceea861382b9"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08424f6648526076e28fae6ea2806c0a7d504b9ef05ae61d196d571e5c879c84"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:61a1ff00674879725b194695e17f23d3248998b843eb5e933007ca743310f793"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f2f2c61bee5844d41c3eb015ac652a0229e901074951ae48581d58bfb2ba01be"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9d32a592cac88d18cc09a89172e1c32d7f2a6e516c3dfde1b9adb90ab5df54a6"}, - {file = "xxhash-3.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:70dabf941dede727cca579e8c205e61121afc9b28516752fd65724be1355cc90"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e5d0ddaca65ecca9c10dcf01730165fd858533d0be84c75c327487c37a906a27"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e5b5e16c5a480fe5f59f56c30abdeba09ffd75da8d13f6b9b6fd224d0b4d0a2"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:149b7914451eb154b3dfaa721315117ea1dac2cc55a01bfbd4df7c68c5dd683d"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:eade977f5c96c677035ff39c56ac74d851b1cca7d607ab3d8f23c6b859379cab"}, - {file = "xxhash-3.5.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fa9f547bd98f5553d03160967866a71056a60960be00356a15ecc44efb40ba8e"}, - {file = "xxhash-3.5.0-cp312-cp312-win32.whl", hash = "sha256:f7b58d1fd3551b8c80a971199543379be1cee3d0d409e1f6d8b01c1a2eebf1f8"}, - {file = "xxhash-3.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:fa0cafd3a2af231b4e113fba24a65d7922af91aeb23774a8b78228e6cd785e3e"}, - {file = "xxhash-3.5.0-cp312-cp312-win_arm64.whl", hash = "sha256:586886c7e89cb9828bcd8a5686b12e161368e0064d040e225e72607b43858ba2"}, - {file = "xxhash-3.5.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:37889a0d13b0b7d739cfc128b1c902f04e32de17b33d74b637ad42f1c55101f6"}, - {file = "xxhash-3.5.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:97a662338797c660178e682f3bc180277b9569a59abfb5925e8620fba00b9fc5"}, - {file = "xxhash-3.5.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f85e0108d51092bdda90672476c7d909c04ada6923c14ff9d913c4f7dc8a3bc"}, - {file = "xxhash-3.5.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:cd2fd827b0ba763ac919440042302315c564fdb797294d86e8cdd4578e3bc7f3"}, - {file = "xxhash-3.5.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:82085c2abec437abebf457c1d12fccb30cc8b3774a0814872511f0f0562c768c"}, - {file = "xxhash-3.5.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:07fda5de378626e502b42b311b049848c2ef38784d0d67b6f30bb5008642f8eb"}, - {file = "xxhash-3.5.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c279f0d2b34ef15f922b77966640ade58b4ccdfef1c4d94b20f2a364617a493f"}, - {file = "xxhash-3.5.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:89e66ceed67b213dec5a773e2f7a9e8c58f64daeb38c7859d8815d2c89f39ad7"}, - {file = "xxhash-3.5.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:bcd51708a633410737111e998ceb3b45d3dbc98c0931f743d9bb0a209033a326"}, - {file = "xxhash-3.5.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:3ff2c0a34eae7df88c868be53a8dd56fbdf592109e21d4bfa092a27b0bf4a7bf"}, - {file = "xxhash-3.5.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:4e28503dccc7d32e0b9817aa0cbfc1f45f563b2c995b7a66c4c8a0d232e840c7"}, - {file = "xxhash-3.5.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a6c50017518329ed65a9e4829154626f008916d36295b6a3ba336e2458824c8c"}, - {file = "xxhash-3.5.0-cp313-cp313-win32.whl", hash = "sha256:53a068fe70301ec30d868ece566ac90d873e3bb059cf83c32e76012c889b8637"}, - {file = "xxhash-3.5.0-cp313-cp313-win_amd64.whl", hash = "sha256:80babcc30e7a1a484eab952d76a4f4673ff601f54d5142c26826502740e70b43"}, - {file = "xxhash-3.5.0-cp313-cp313-win_arm64.whl", hash = "sha256:4811336f1ce11cac89dcbd18f3a25c527c16311709a89313c3acaf771def2d4b"}, - {file = "xxhash-3.5.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:6e5f70f6dca1d3b09bccb7daf4e087075ff776e3da9ac870f86ca316736bb4aa"}, - {file = "xxhash-3.5.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2e76e83efc7b443052dd1e585a76201e40b3411fe3da7af4fe434ec51b2f163b"}, - {file = "xxhash-3.5.0-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:33eac61d0796ca0591f94548dcfe37bb193671e0c9bcf065789b5792f2eda644"}, - {file = "xxhash-3.5.0-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0ec70a89be933ea49222fafc3999987d7899fc676f688dd12252509434636622"}, - {file = "xxhash-3.5.0-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd86b8e7f703ec6ff4f351cfdb9f428955859537125904aa8c963604f2e9d3e7"}, - {file = "xxhash-3.5.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0adfbd36003d9f86c8c97110039f7539b379f28656a04097e7434d3eaf9aa131"}, - {file = "xxhash-3.5.0-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:63107013578c8a730419adc05608756c3fa640bdc6abe806c3123a49fb829f43"}, - {file = "xxhash-3.5.0-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:683b94dbd1ca67557850b86423318a2e323511648f9f3f7b1840408a02b9a48c"}, - {file = "xxhash-3.5.0-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:5d2a01dcce81789cf4b12d478b5464632204f4c834dc2d064902ee27d2d1f0ee"}, - {file = "xxhash-3.5.0-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:a9d360a792cbcce2fe7b66b8d51274ec297c53cbc423401480e53b26161a290d"}, - {file = "xxhash-3.5.0-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:f0b48edbebea1b7421a9c687c304f7b44d0677c46498a046079d445454504737"}, - {file = "xxhash-3.5.0-cp37-cp37m-win32.whl", hash = "sha256:7ccb800c9418e438b44b060a32adeb8393764da7441eb52aa2aa195448935306"}, - {file = "xxhash-3.5.0-cp37-cp37m-win_amd64.whl", hash = "sha256:c3bc7bf8cb8806f8d1c9bf149c18708cb1c406520097d6b0a73977460ea03602"}, - {file = "xxhash-3.5.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:74752ecaa544657d88b1d1c94ae68031e364a4d47005a90288f3bab3da3c970f"}, - {file = "xxhash-3.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:dee1316133c9b463aa81aca676bc506d3f80d8f65aeb0bba2b78d0b30c51d7bd"}, - {file = "xxhash-3.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:602d339548d35a8579c6b013339fb34aee2df9b4e105f985443d2860e4d7ffaa"}, - {file = "xxhash-3.5.0-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:695735deeddfb35da1677dbc16a083445360e37ff46d8ac5c6fcd64917ff9ade"}, - {file = "xxhash-3.5.0-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1030a39ba01b0c519b1a82f80e8802630d16ab95dc3f2b2386a0b5c8ed5cbb10"}, - {file = "xxhash-3.5.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a5bc08f33c4966f4eb6590d6ff3ceae76151ad744576b5fc6c4ba8edd459fdec"}, - {file = "xxhash-3.5.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:160e0c19ee500482ddfb5d5570a0415f565d8ae2b3fd69c5dcfce8a58107b1c3"}, - {file = "xxhash-3.5.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:f1abffa122452481a61c3551ab3c89d72238e279e517705b8b03847b1d93d738"}, - {file = "xxhash-3.5.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:d5e9db7ef3ecbfc0b4733579cea45713a76852b002cf605420b12ef3ef1ec148"}, - {file = "xxhash-3.5.0-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:23241ff6423378a731d84864bf923a41649dc67b144debd1077f02e6249a0d54"}, - {file = "xxhash-3.5.0-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:82b833d5563fefd6fceafb1aed2f3f3ebe19f84760fdd289f8b926731c2e6e91"}, - {file = "xxhash-3.5.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0a80ad0ffd78bef9509eee27b4a29e56f5414b87fb01a888353e3d5bda7038bd"}, - {file = "xxhash-3.5.0-cp38-cp38-win32.whl", hash = "sha256:50ac2184ffb1b999e11e27c7e3e70cc1139047e7ebc1aa95ed12f4269abe98d4"}, - {file = "xxhash-3.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:392f52ebbb932db566973693de48f15ce787cabd15cf6334e855ed22ea0be5b3"}, - {file = "xxhash-3.5.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bfc8cdd7f33d57f0468b0614ae634cc38ab9202c6957a60e31d285a71ebe0301"}, - {file = "xxhash-3.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e0c48b6300cd0b0106bf49169c3e0536408dfbeb1ccb53180068a18b03c662ab"}, - {file = "xxhash-3.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe1a92cfbaa0a1253e339ccec42dbe6db262615e52df591b68726ab10338003f"}, - {file = "xxhash-3.5.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:33513d6cc3ed3b559134fb307aae9bdd94d7e7c02907b37896a6c45ff9ce51bd"}, - {file = "xxhash-3.5.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eefc37f6138f522e771ac6db71a6d4838ec7933939676f3753eafd7d3f4c40bc"}, - {file = "xxhash-3.5.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a606c8070ada8aa2a88e181773fa1ef17ba65ce5dd168b9d08038e2a61b33754"}, - {file = "xxhash-3.5.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:42eca420c8fa072cc1dd62597635d140e78e384a79bb4944f825fbef8bfeeef6"}, - {file = "xxhash-3.5.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:604253b2143e13218ff1ef0b59ce67f18b8bd1c4205d2ffda22b09b426386898"}, - {file = "xxhash-3.5.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:6e93a5ad22f434d7876665444a97e713a8f60b5b1a3521e8df11b98309bff833"}, - {file = "xxhash-3.5.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:7a46e1d6d2817ba8024de44c4fd79913a90e5f7265434cef97026215b7d30df6"}, - {file = "xxhash-3.5.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:30eb2efe6503c379b7ab99c81ba4a779748e3830241f032ab46bd182bf5873af"}, - {file = "xxhash-3.5.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:c8aa771ff2c13dd9cda8166d685d7333d389fae30a4d2bb39d63ab5775de8606"}, - {file = "xxhash-3.5.0-cp39-cp39-win32.whl", hash = "sha256:5ed9ebc46f24cf91034544b26b131241b699edbfc99ec5e7f8f3d02d6eb7fba4"}, - {file = "xxhash-3.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:220f3f896c6b8d0316f63f16c077d52c412619e475f9372333474ee15133a558"}, - {file = "xxhash-3.5.0-cp39-cp39-win_arm64.whl", hash = "sha256:a7b1d8315d9b5e9f89eb2933b73afae6ec9597a258d52190944437158b49d38e"}, - {file = "xxhash-3.5.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:2014c5b3ff15e64feecb6b713af12093f75b7926049e26a580e94dcad3c73d8c"}, - {file = "xxhash-3.5.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fab81ef75003eda96239a23eda4e4543cedc22e34c373edcaf744e721a163986"}, - {file = "xxhash-3.5.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e2febf914ace002132aa09169cc572e0d8959d0f305f93d5828c4836f9bc5a6"}, - {file = "xxhash-3.5.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5d3a10609c51da2a1c0ea0293fc3968ca0a18bd73838455b5bca3069d7f8e32b"}, - {file = "xxhash-3.5.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:5a74f23335b9689b66eb6dbe2a931a88fcd7a4c2cc4b1cb0edba8ce381c7a1da"}, - {file = "xxhash-3.5.0-pp37-pypy37_pp73-macosx_10_9_x86_64.whl", hash = "sha256:2b4154c00eb22e4d543f472cfca430e7962a0f1d0f3778334f2e08a7ba59363c"}, - {file = "xxhash-3.5.0-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d30bbc1644f726b825b3278764240f449d75f1a8bdda892e641d4a688b1494ae"}, - {file = "xxhash-3.5.0-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6fa0b72f2423e2aa53077e54a61c28e181d23effeaafd73fcb9c494e60930c8e"}, - {file = "xxhash-3.5.0-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:13de2b76c1835399b2e419a296d5b38dc4855385d9e96916299170085ef72f57"}, - {file = "xxhash-3.5.0-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:0691bfcc4f9c656bcb96cc5db94b4d75980b9d5589f2e59de790091028580837"}, - {file = "xxhash-3.5.0-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:297595fe6138d4da2c8ce9e72a04d73e58725bb60f3a19048bc96ab2ff31c692"}, - {file = "xxhash-3.5.0-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cc1276d369452040cbb943300dc8abeedab14245ea44056a2943183822513a18"}, - {file = "xxhash-3.5.0-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2061188a1ba352fc699c82bff722f4baacb4b4b8b2f0c745d2001e56d0dfb514"}, - {file = "xxhash-3.5.0-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:38c384c434021e4f62b8d9ba0bc9467e14d394893077e2c66d826243025e1f81"}, - {file = "xxhash-3.5.0-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:e6a4dd644d72ab316b580a1c120b375890e4c52ec392d4aef3c63361ec4d77d1"}, - {file = "xxhash-3.5.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:531af8845aaadcadf951b7e0c1345c6b9c68a990eeb74ff9acd8501a0ad6a1c9"}, - {file = "xxhash-3.5.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7ce379bcaa9fcc00f19affa7773084dd09f5b59947b3fb47a1ceb0179f91aaa1"}, - {file = "xxhash-3.5.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd1b2281d01723f076df3c8188f43f2472248a6b63118b036e641243656b1b0f"}, - {file = "xxhash-3.5.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9c770750cc80e8694492244bca7251385188bc5597b6a39d98a9f30e8da984e0"}, - {file = "xxhash-3.5.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:b150b8467852e1bd844387459aa6fbe11d7f38b56e901f9f3b3e6aba0d660240"}, - {file = "xxhash-3.5.0.tar.gz", hash = "sha256:84f2caddf951c9cbf8dc2e22a89d4ccf5d86391ac6418fe81e3c67d0cf60b45f"}, -] - -[[package]] -name = "yarl" -version = "1.19.0" -description = "Yet another URL library" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "yarl-1.19.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0bae32f8ebd35c04d6528cedb4a26b8bf25339d3616b04613b97347f919b76d3"}, - {file = "yarl-1.19.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8015a076daf77823e7ebdcba474156587391dab4e70c732822960368c01251e6"}, - {file = "yarl-1.19.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:9973ac95327f5d699eb620286c39365990b240031672b5c436a4cd00539596c5"}, - {file = "yarl-1.19.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd4b5fbd7b9dde785cfeb486b8cca211a0b138d4f3a7da27db89a25b3c482e5c"}, - {file = "yarl-1.19.0-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:75460740005de5a912b19f657848aef419387426a40f581b1dc9fac0eb9addb5"}, - {file = "yarl-1.19.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:57abd66ca913f2cfbb51eb3dbbbac3648f1f6983f614a4446e0802e241441d2a"}, - {file = "yarl-1.19.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:46ade37911b7c99ce28a959147cb28bffbd14cea9e7dd91021e06a8d2359a5aa"}, - {file = "yarl-1.19.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8346ec72ada749a6b5d82bff7be72578eab056ad7ec38c04f668a685abde6af0"}, - {file = "yarl-1.19.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:7e4cb14a6ee5b6649ccf1c6d648b4da9220e8277d4d4380593c03cc08d8fe937"}, - {file = "yarl-1.19.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:66fc1c2926a73a2fb46e4b92e3a6c03904d9bc3a0b65e01cb7d2b84146a8bd3b"}, - {file = "yarl-1.19.0-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:5a70201dd1e0a4304849b6445a9891d7210604c27e67da59091d5412bc19e51c"}, - {file = "yarl-1.19.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e4807aab1bdeab6ae6f296be46337a260ae4b1f3a8c2fcd373e236b4b2b46efd"}, - {file = "yarl-1.19.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:ae584afe81a1de4c1bb06672481050f0d001cad13163e3c019477409f638f9b7"}, - {file = "yarl-1.19.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:30eaf4459df6e91f21b2999d1ee18f891bcd51e3cbe1de301b4858c84385895b"}, - {file = "yarl-1.19.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:0e617d45d03c8dec0dfce6f51f3e1b8a31aa81aaf4a4d1442fdb232bcf0c6d8c"}, - {file = "yarl-1.19.0-cp310-cp310-win32.whl", hash = "sha256:32ba32d0fa23893fd8ea8d05bdb05de6eb19d7f2106787024fd969f4ba5466cb"}, - {file = "yarl-1.19.0-cp310-cp310-win_amd64.whl", hash = "sha256:545575ecfcd465891b51546c2bcafdde0acd2c62c2097d8d71902050b20e4922"}, - {file = "yarl-1.19.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:163ff326680de5f6d4966954cf9e3fe1bf980f5fee2255e46e89b8cf0f3418b5"}, - {file = "yarl-1.19.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a626c4d9cca298d1be8625cff4b17004a9066330ac82d132bbda64a4c17c18d3"}, - {file = "yarl-1.19.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:961c3e401ea7f13d02b8bb7cb0c709152a632a6e14cdc8119e9c6ee5596cd45d"}, - {file = "yarl-1.19.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a39d7b807ab58e633ed760f80195cbd145b58ba265436af35f9080f1810dfe64"}, - {file = "yarl-1.19.0-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:c4228978fb59c6b10f60124ba8e311c26151e176df364e996f3f8ff8b93971b5"}, - {file = "yarl-1.19.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9ba536b17ecf3c74a94239ec1137a3ad3caea8c0e4deb8c8d2ffe847d870a8c5"}, - {file = "yarl-1.19.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a251e00e445d2e9df7b827c9843c0b87f58a3254aaa3f162fb610747491fe00f"}, - {file = "yarl-1.19.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f9b92431d8b4d4ca5ccbfdbac95b05a3a6cd70cd73aa62f32f9627acfde7549c"}, - {file = "yarl-1.19.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec2f56edaf476f70b5831bbd59700b53d9dd011b1f77cd4846b5ab5c5eafdb3f"}, - {file = "yarl-1.19.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:acf9b92c4245ac8b59bc7ec66a38d3dcb8d1f97fac934672529562bb824ecadb"}, - {file = "yarl-1.19.0-cp311-cp311-musllinux_1_2_armv7l.whl", hash = "sha256:57711f1465c06fee8825b95c0b83e82991e6d9425f9a042c3c19070a70ac92bf"}, - {file = "yarl-1.19.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:528e86f5b1de0ad8dd758ddef4e0ed24f5d946d4a1cef80ffb2d4fca4e10f122"}, - {file = "yarl-1.19.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:3b77173663e075d9e5a57e09d711e9da2f3266be729ecca0b8ae78190990d260"}, - {file = "yarl-1.19.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:d8717924cf0a825b62b1a96fc7d28aab7f55a81bf5338b8ef41d7a76ab9223e9"}, - {file = "yarl-1.19.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:0df9f0221a78d858793f40cbea3915c29f969c11366646a92ca47e080a14f881"}, - {file = "yarl-1.19.0-cp311-cp311-win32.whl", hash = "sha256:8b3ade62678ee2c7c10dcd6be19045135e9badad53108f7d2ed14896ee396045"}, - {file = "yarl-1.19.0-cp311-cp311-win_amd64.whl", hash = "sha256:0626ee31edb23ac36bdffe607231de2cca055ad3a5e2dc5da587ef8bc6a321bc"}, - {file = "yarl-1.19.0-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:7b687c334da3ff8eab848c9620c47a253d005e78335e9ce0d6868ed7e8fd170b"}, - {file = "yarl-1.19.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b0fe766febcf523a2930b819c87bb92407ae1368662c1bc267234e79b20ff894"}, - {file = "yarl-1.19.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:742ceffd3c7beeb2b20d47cdb92c513eef83c9ef88c46829f88d5b06be6734ee"}, - {file = "yarl-1.19.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2af682a1e97437382ee0791eacbf540318bd487a942e068e7e0a6c571fadbbd3"}, - {file = "yarl-1.19.0-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:63702f1a098d0eaaea755e9c9d63172be1acb9e2d4aeb28b187092bcc9ca2d17"}, - {file = "yarl-1.19.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3560dcba3c71ae7382975dc1e912ee76e50b4cd7c34b454ed620d55464f11876"}, - {file = "yarl-1.19.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:68972df6a0cc47c8abaf77525a76ee5c5f6ea9bbdb79b9565b3234ded3c5e675"}, - {file = "yarl-1.19.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5684e7ff93ea74e47542232bd132f608df4d449f8968fde6b05aaf9e08a140f9"}, - {file = "yarl-1.19.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8182ad422bfacdebd4759ce3adc6055c0c79d4740aea1104e05652a81cd868c6"}, - {file = "yarl-1.19.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:aee5b90a5a9b71ac57400a7bdd0feaa27c51e8f961decc8d412e720a004a1791"}, - {file = "yarl-1.19.0-cp312-cp312-musllinux_1_2_armv7l.whl", hash = "sha256:8c0b2371858d5a814b08542d5d548adb03ff2d7ab32f23160e54e92250961a72"}, - {file = "yarl-1.19.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:cd430c2b7df4ae92498da09e9b12cad5bdbb140d22d138f9e507de1aa3edfea3"}, - {file = "yarl-1.19.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:a93208282c0ccdf73065fd76c6c129bd428dba5ff65d338ae7d2ab27169861a0"}, - {file = "yarl-1.19.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:b8179280cdeb4c36eb18d6534a328f9d40da60d2b96ac4a295c5f93e2799e9d9"}, - {file = "yarl-1.19.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:eda3c2b42dc0c389b7cfda2c4df81c12eeb552019e0de28bde8f913fc3d1fcf3"}, - {file = "yarl-1.19.0-cp312-cp312-win32.whl", hash = "sha256:57f3fed859af367b9ca316ecc05ce79ce327d6466342734305aa5cc380e4d8be"}, - {file = "yarl-1.19.0-cp312-cp312-win_amd64.whl", hash = "sha256:5507c1f7dd3d41251b67eecba331c8b2157cfd324849879bebf74676ce76aff7"}, - {file = "yarl-1.19.0-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:59281b9ed27bc410e0793833bcbe7fc149739d56ffa071d1e0fe70536a4f7b61"}, - {file = "yarl-1.19.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:d27a6482ad5e05e8bafd47bf42866f8a1c0c3345abcb48d4511b3c29ecc197dc"}, - {file = "yarl-1.19.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7a8e19fd5a6fdf19a91f2409665c7a089ffe7b9b5394ab33c0eec04cbecdd01f"}, - {file = "yarl-1.19.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cda34ab19099c3a1685ad48fe45172536610c312b993310b5f1ca3eb83453b36"}, - {file = "yarl-1.19.0-cp313-cp313-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:7908a25d33f94852b479910f9cae6cdb9e2a509894e8d5f416c8342c0253c397"}, - {file = "yarl-1.19.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:e66c14d162bac94973e767b24de5d7e6c5153f7305a64ff4fcba701210bcd638"}, - {file = "yarl-1.19.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c03607bf932aa4cfae371e2dc9ca8b76faf031f106dac6a6ff1458418140c165"}, - {file = "yarl-1.19.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9931343d1c1f4e77421687b6b94bbebd8a15a64ab8279adf6fbb047eff47e536"}, - {file = "yarl-1.19.0-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:262087a8a0d73e1d169d45c2baf968126f93c97cf403e1af23a7d5455d52721f"}, - {file = "yarl-1.19.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:70f384921c24e703d249a6ccdabeb57dd6312b568b504c69e428a8dd3e8e68ca"}, - {file = "yarl-1.19.0-cp313-cp313-musllinux_1_2_armv7l.whl", hash = "sha256:756b9ea5292a2c180d1fe782a377bc4159b3cfefaca7e41b5b0a00328ef62fa9"}, - {file = "yarl-1.19.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:cbeb9c145d534c240a63b6ecc8a8dd451faeb67b3dc61d729ec197bb93e29497"}, - {file = "yarl-1.19.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:087ae8f8319848c18e0d114d0f56131a9c017f29200ab1413b0137ad7c83e2ae"}, - {file = "yarl-1.19.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:362f5480ba527b6c26ff58cff1f229afe8b7fdd54ee5ffac2ab827c1a75fc71c"}, - {file = "yarl-1.19.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f408d4b4315e814e5c3668094e33d885f13c7809cbe831cbdc5b1bb8c7a448f4"}, - {file = "yarl-1.19.0-cp313-cp313-win32.whl", hash = "sha256:24e4c367ad69988a2283dd45ea88172561ca24b2326b9781e164eb46eea68345"}, - {file = "yarl-1.19.0-cp313-cp313-win_amd64.whl", hash = "sha256:0110f91c57ab43d1538dfa92d61c45e33b84df9257bd08fcfcda90cce931cbc9"}, - {file = "yarl-1.19.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:85ac908cd5a97bbd3048cca9f1bf37b932ea26c3885099444f34b0bf5d5e9fa6"}, - {file = "yarl-1.19.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:6ba0931b559f1345df48a78521c31cfe356585670e8be22af84a33a39f7b9221"}, - {file = "yarl-1.19.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5bc503e1c1fee1b86bcb58db67c032957a52cae39fe8ddd95441f414ffbab83e"}, - {file = "yarl-1.19.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d995122dcaf180fd4830a9aa425abddab7c0246107c21ecca2fa085611fa7ce9"}, - {file = "yarl-1.19.0-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.manylinux_2_31_armv7l.whl", hash = "sha256:217f69e60a14da4eed454a030ea8283f8fbd01a7d6d81e57efb865856822489b"}, - {file = "yarl-1.19.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:aad67c8f13a4b79990082f72ef09c078a77de2b39899aabf3960a48069704973"}, - {file = "yarl-1.19.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:dff065a1a8ed051d7e641369ba1ad030d5a707afac54cf4ede7069b959898835"}, - {file = "yarl-1.19.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ada882e26b16ee651ab6544ce956f2f4beaed38261238f67c2a96db748e17741"}, - {file = "yarl-1.19.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:67a56b1acc7093451ea2de0687aa3bd4e58d6b4ef6cbeeaad137b45203deaade"}, - {file = "yarl-1.19.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:e97d2f0a06b39e231e59ebab0e6eec45c7683b339e8262299ac952707bdf7688"}, - {file = "yarl-1.19.0-cp39-cp39-musllinux_1_2_armv7l.whl", hash = "sha256:a5288adb7c59d0f54e4ad58d86fb06d4b26e08a59ed06d00a1aac978c0e32884"}, - {file = "yarl-1.19.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:1efbf4d03e6eddf5da27752e0b67a8e70599053436e9344d0969532baa99df53"}, - {file = "yarl-1.19.0-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:f228f42f29cc87db67020f7d71624102b2c837686e55317b16e1d3ef2747a993"}, - {file = "yarl-1.19.0-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c515f7dd60ca724e4c62b34aeaa603188964abed2eb66bb8e220f7f104d5a187"}, - {file = "yarl-1.19.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:4815ec6d3d68a96557fa71bd36661b45ac773fb50e5cfa31a7e843edb098f060"}, - {file = "yarl-1.19.0-cp39-cp39-win32.whl", hash = "sha256:9fac2dd1c5ecb921359d9546bc23a6dcc18c6acd50c6d96f118188d68010f497"}, - {file = "yarl-1.19.0-cp39-cp39-win_amd64.whl", hash = "sha256:5864f539ce86b935053bfa18205fa08ce38e9a40ea4d51b19ce923345f0ed5db"}, - {file = "yarl-1.19.0-py3-none-any.whl", hash = "sha256:a727101eb27f66727576630d02985d8a065d09cd0b5fcbe38a5793f71b2a97ef"}, - {file = "yarl-1.19.0.tar.gz", hash = "sha256:01e02bb80ae0dbed44273c304095295106e1d9470460e773268a27d11e594892"}, -] - -[package.dependencies] -idna = ">=2.0" -multidict = ">=4.0" -propcache = ">=0.2.1" - -[[package]] -name = "zipp" -version = "3.21.0" -description = "Backport of pathlib-compatible object wrapper for zip files" -optional = true -python-versions = ">=3.9" -groups = ["main"] -markers = "extra == \"llm\"" -files = [ - {file = "zipp-3.21.0-py3-none-any.whl", hash = "sha256:ac1bbe05fd2991f160ebce24ffbac5f6d11d83dc90891255885223d42b3cd931"}, - {file = "zipp-3.21.0.tar.gz", hash = "sha256:2c9958f6430a2040341a52eb608ed6dd93ef4392e02ffe219417c1b28b5dd1f4"}, -] - -[package.extras] -check = ["pytest-checkdocs (>=2.4)", "pytest-ruff (>=0.2.1) ; sys_platform != \"cygwin\""] -cover = ["pytest-cov"] -doc = ["furo", "jaraco.packaging (>=9.3)", "jaraco.tidelift (>=1.4)", "rst.linker (>=1.9)", "sphinx (>=3.5)", "sphinx-lint"] -enabler = ["pytest-enabler (>=2.2)"] -test = ["big-O", "importlib-resources ; python_version < \"3.9\"", "jaraco.functools", "jaraco.itertools", "jaraco.test", "more-itertools", "pytest (>=6,!=8.1.*)", "pytest-ignore-flaky"] -type = ["pytest-mypy"] - [extras] -llm = ["dspy"] +llm = [] ml = ["torch", "torchvision", "transformers"] ocr = ["easyocr", "python-doctr", "surya-ocr"] [metadata] lock-version = "2.1" python-versions = "^3.10" -content-hash = "b987708140f9a2bf75135b9b275e443e9f89ac495109c73998a116c3cffd7bf8" +content-hash = "0beb4123bf5669db09026fe42e9427b2ebe6a571c768176a9b3fa78c32ccd29e" diff --git a/pyproject.toml b/pyproject.toml index 5cb8c19..92acb8b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [tool.poetry] name = "scaledp" -version = "0.2.3rc45" +version = "0.2.3rc46" description = "ScaleDP is a library for processing documents using Apache Spark and LLMs" authors = ["Mykola Melnyk "] repository = "https://github.com/StabRise/scaledp" diff --git a/scaledp/__init__.py b/scaledp/__init__.py index f8e4209..4cbd9aa 100644 --- a/scaledp/__init__.py +++ b/scaledp/__init__.py @@ -14,6 +14,7 @@ from scaledp.image.ImageDrawBoxes import ImageDrawBoxes from scaledp.models.detectors.DocTRTextDetector import DocTRTextDetector from scaledp.models.detectors.YoloDetector import YoloDetector +from scaledp.models.detectors.YoloOnnxDetector import YoloOnnxDetector from scaledp.models.extractors.DSPyExtractor import DSPyExtractor from scaledp.models.extractors.LLMExtractor import LLMExtractor from scaledp.models.extractors.LLMVisualExtractor import LLMVisualExtractor @@ -210,6 +211,7 @@ def ScaleDPSession( "EasyOcr", "DocTROcr", "YoloDetector", + "YoloOnnxDetector", "ImageCropBoxes", "DSPyExtractor", "TesseractRecognizer", diff --git a/scaledp/image/DataToImage.py b/scaledp/image/DataToImage.py index f3bf0be..ede7374 100644 --- a/scaledp/image/DataToImage.py +++ b/scaledp/image/DataToImage.py @@ -93,5 +93,5 @@ def _transform(self, dataset): ), ) if not self.getKeepInputData(): - result = result.drop(input_col) + result = result.drop(self.getInputCol()) return result diff --git a/scaledp/models/detectors/BaseDetector.py b/scaledp/models/detectors/BaseDetector.py index e8999fa..8fbfa95 100644 --- a/scaledp/models/detectors/BaseDetector.py +++ b/scaledp/models/detectors/BaseDetector.py @@ -64,6 +64,13 @@ class BaseDetector( typeConverter=TypeConverters.toFloat, ) + onlyRotated = Param( + Params._dummy(), + "onlyRotated", + "Return only rotated boxes.", + typeConverter=TypeConverters.toBoolean, + ) + def get_params(self): return json.dumps({k.name: v for k, v in self.extractParamMap().items()}) @@ -99,8 +106,10 @@ def transform_udf(self, image, params=None): exception=image.exception, ) try: + logging.info("Convert image") image_pil = image.to_pil() scale_factor = self.getScaleFactor() + logging.info("Resize image") if scale_factor != 1.0: resized_image = image_pil.resize( ( @@ -110,7 +119,7 @@ def transform_udf(self, image, params=None): ) else: resized_image = image_pil - + logging.info("Call detector on image") result = self.call_detector([(resized_image, image.path)], params) except Exception as e: exception = traceback.format_exc() @@ -190,7 +199,7 @@ def _transform(self, dataset): ) if not self.getKeepInputData(): - result = result.drop(input_col) + result = result.drop(self.getInputCol()) return result def setScaleFactor(self, value): diff --git a/scaledp/models/detectors/CraftTextDetector.py b/scaledp/models/detectors/CraftTextDetector.py new file mode 100644 index 0000000..362c800 --- /dev/null +++ b/scaledp/models/detectors/CraftTextDetector.py @@ -0,0 +1,281 @@ +from types import MappingProxyType +from typing import Any + +import numpy +from pyspark import keyword_only + +from scaledp.enums import Device +from scaledp.models.detectors.BaseDetector import BaseDetector +from scaledp.params import HasBatchSize, HasDevice, Param, Params, TypeConverters +from scaledp.schemas.Box import Box +from scaledp.schemas.DetectorOutput import DetectorOutput + + +class CraftTextDetector(BaseDetector, HasDevice, HasBatchSize): + _craft_net = None + _refine_net = None + + defaultParams = MappingProxyType( + { + "inputCol": "image", + "outputCol": "boxes", + "keepInputData": False, + "scaleFactor": 1.0, + "scoreThreshold": 0.7, + "textThreshold": 0.4, + "linkThreshold": 0.4, + "sizeThreshold": -1, + "width": 1280, + "withRefiner": False, + "device": Device.CPU, + "batchSize": 2, + "partitionMap": False, + "numPartitions": 0, + "pageCol": "page", + "pathCol": "path", + "propagateError": False, + "onlyRotated": False, + }, + ) + + textThreshold = Param( + Params._dummy(), + "textThreshold", + "Threshold for text region score", + typeConverter=TypeConverters.toFloat, + ) + + linkThreshold = Param( + Params._dummy(), + "linkThreshold", + "Threshold for link affinity score", + typeConverter=TypeConverters.toFloat, + ) + + sizeThreshold = Param( + Params._dummy(), + "sizeThreshold", + "Threshold for height of detected regions", + typeConverter=TypeConverters.toInt, + ) + + width = Param( + Params._dummy(), + "width", + "Width for image resizing", + typeConverter=TypeConverters.toInt, + ) + + withRefiner = Param( + Params._dummy(), + "withRefiner", + "Enable refiner network postprocessing", + typeConverter=TypeConverters.toBoolean, + ) + + @keyword_only + def __init__(self, **kwargs: Any) -> None: + super(CraftTextDetector, self).__init__() + self._setDefault(**self.defaultParams) + self._set(**kwargs) + self.get_model({k.name: v for k, v in self.extractParamMap().items()}) + + @classmethod + def get_model(cls, params): + if cls._craft_net and cls._refine_net: + return cls._craft_net, cls._refine_net + + from craft_text_detector import load_craftnet_model, load_refinenet_model + + device = "cuda" if int(params["device"]) == Device.CUDA.value else "cpu" + use_cuda = device == "cuda" + + craft_net = load_craftnet_model( + cuda=use_cuda, + ) + + refine_net = None + if params.get("withRefiner"): + refine_net = load_refinenet_model( + cuda=use_cuda, + ) + + cls._craft_net = craft_net + cls._refine_net = refine_net + return craft_net, refine_net + + @classmethod + def call_detector(cls, images, params): + import cv2 + from craft_text_detector import craft_utils, image_utils, torch_utils + + craft_net, refine_net = cls.get_model(params) + use_cuda = int(params["device"]) == Device.CUDA.value + results = [] + + for image, image_path in images: + try: + # Convert PIL to OpenCV format + + img_cv = image_utils.read_image(numpy.array(image)[:, :, ::-1]) + + # Resize + img_resized, target_ratio, size_heatmap = ( + image_utils.resize_aspect_ratio( + img_cv, + params["width"], + interpolation=cv2.INTER_LINEAR, + ) + ) + ratio_h = ratio_w = 1 / target_ratio + + # Preprocess + x = image_utils.normalizeMeanVariance(img_resized) + x = torch_utils.from_numpy(x).permute(2, 0, 1) + x = torch_utils.Variable(x.unsqueeze(0)) + if use_cuda: + x = x.cuda() + + # Forward pass + with torch_utils.no_grad(): + y, feature = craft_net(x) + + score_text = y[0, :, :, 0].cpu().data.numpy() + score_link = y[0, :, :, 1].cpu().data.numpy() + + # Refine if enabled + if refine_net is not None: + with torch_utils.no_grad(): + y_refiner = refine_net(y, feature) + score_link = y_refiner[0, :, :, 0].cpu().data.numpy() + + # Post-process + boxes, _ = craft_utils.getDetBoxes( + score_text, + score_link, + params["scoreThreshold"], + params["linkThreshold"], + params["textThreshold"], + poly=False, + ) + + # Adjust coordinates + boxes = craft_utils.adjustResultCoordinates(boxes, ratio_w, ratio_h) + + # Convert to Box objects + box_objects = [Box.from_polygon(box) for box in boxes] + + results.append( + DetectorOutput( + path=image_path, + type="craft", + bboxes=box_objects, + exception="", + ), + ) + + except Exception as e: + raise e + results.append( + DetectorOutput( + path=image_path, + type="craft", + bboxes=[], + exception=f"CraftTextDetector error: {e!s}", + ), + ) + + return results + + @classmethod + def call_detector1(cls, images, params): + import cv2 + from crafter import craft_utils, image_utils + + craft_net, refine_net = cls.get_model(params) + results = [] + + for image, image_path in images: + try: + # Convert PIL to OpenCV format + + img_cv = image_utils.read_image(numpy.array(image)[:, :, ::-1]) + + # Resize + img_resized, target_ratio, size_heatmap = ( + image_utils.resize_aspect_ratio( + img_cv, + params["width"], + interpolation=cv2.INTER_LINEAR, + ) + ) + ratio_h = ratio_w = 1 / target_ratio + + # Preprocess + x = image_utils.normalizeMeanVariance(img_resized) + x = numpy.transpose(x, (2, 0, 1)) # [h, w, c] to [c, h, w] + x = numpy.expand_dims(x, 0) # [c, h, w] to [b, c, h, w] + + # Forward pass + y, feature = craft_net(x) + + score_text = y[0, 0, :, :] + score_link = y[0, 1, :, :] + + # Refine if enabled + if refine_net is not None: + y_refiner = refine_net(y, feature) + score_link = y_refiner[0, 0, :, :] + + # Post-process + boxes, _ = craft_utils.getDetBoxes( + score_text, + score_link, + params["scoreThreshold"], + params["linkThreshold"], + params["textThreshold"], + poly=False, + ) + + # Adjust coordinates + boxes = craft_utils.adjustResultCoordinates(boxes, ratio_w, ratio_h) + + # Convert to Box objects + box_objects = [Box.from_polygon(box) for box in boxes] + + results.append( + DetectorOutput( + path=image_path, + type="craft", + bboxes=box_objects, + exception="", + ), + ) + + except Exception as e: + raise e + results.append( + DetectorOutput( + path=image_path, + type="craft", + bboxes=[], + exception=f"CraftTextDetector error: {e!s}", + ), + ) + + return results + + def setTextThreshold(self, value): + return self._set(textThreshold=value) + + def setLinkThreshold(self, value): + return self._set(linkThreshold=value) + + def setSizeThreshold(self, value): + return self._set(sizeThreshold=value) + + def setWidth(self, value): + return self._set(width=value) + + def setWithRefiner(self, value): + return self._set(withRefiner=value) diff --git a/scaledp/models/detectors/DBNetOnnxDetector.py b/scaledp/models/detectors/DBNetOnnxDetector.py new file mode 100644 index 0000000..cbeb905 --- /dev/null +++ b/scaledp/models/detectors/DBNetOnnxDetector.py @@ -0,0 +1,97 @@ +import gc +import logging +from pathlib import Path +from types import MappingProxyType +from typing import Any + +import numpy as np +from huggingface_hub import hf_hub_download +from pyspark import keyword_only + +from scaledp.enums import Device +from scaledp.models.detectors.BaseDetector import BaseDetector +from scaledp.models.detectors.paddle_onnx.predict_det import DBNetTextDetector +from scaledp.params import HasBatchSize, HasDevice +from scaledp.schemas.Box import Box +from scaledp.schemas.DetectorOutput import DetectorOutput + + +class DBNetOnnxDetector(BaseDetector, HasDevice, HasBatchSize): + _model = None + + defaultParams = MappingProxyType( + { + "inputCol": "image", + "outputCol": "boxes", + "keepInputData": False, + "scaleFactor": 1.0, + "scoreThreshold": 0.2, + "device": Device.CPU, + "batchSize": 2, + "partitionMap": False, + "numPartitions": 0, + "pageCol": "page", + "pathCol": "path", + "propagateError": False, + "onlyRotated": False, + }, + ) + + @keyword_only + def __init__(self, **kwargs: Any) -> None: + super(DBNetOnnxDetector, self).__init__() + self._setDefault(**self.defaultParams) + self._set(**kwargs) + self.get_model({k.name: v for k, v in self.extractParamMap().items()}) + + @classmethod + def get_model(cls, params): + + logging.info("Loading model...") + if cls._model: + return cls._model + + model = params["model"] + if not Path(model).is_file(): + model = hf_hub_download(repo_id=model, filename="model.onnx") + + logging.info("Model downloaded") + + detector = DBNetTextDetector(model, use_gpu=params["model"] == Device.CUDA) + + cls._model = detector + return cls._model + + @classmethod + def call_detector(cls, images, params): + logging.info("Running DBNetOnnxDetector") + import cv2 + + detector = cls.get_model(params) + + logging.info("Process images") + results_final = [] + for image, image_path in images: + boxes = [] + + # Convert PIL to NumPy (RGB) + image_np = np.array(image) + + # Convert RGB to BGR for OpenCV + image_rgb = cv2.cvtColor(image_np, cv2.COLOR_RGB2BGR) + + result = detector(image_rgb) + + for points in result: + boxes.append(Box.from_polygon(points, padding=0)) + + if params["onlyRotated"]: + boxes = [box for box in boxes if box.is_rotated()] + + results_final.append( + DetectorOutput(path=image_path, type="DBNetOnnx", bboxes=boxes), + ) + + gc.collect() + + return results_final diff --git a/scaledp/models/detectors/FastTextDetector.py b/scaledp/models/detectors/FastTextDetector.py new file mode 100644 index 0000000..876706f --- /dev/null +++ b/scaledp/models/detectors/FastTextDetector.py @@ -0,0 +1,124 @@ +import logging +from types import MappingProxyType +from typing import Any + +import numpy as np +import torch +from doctr.models import detection_predictor +from pyspark import keyword_only + +from scaledp.enums import Device +from scaledp.models.detectors.BaseDetector import BaseDetector +from scaledp.params import HasBatchSize, HasDevice +from scaledp.schemas.Box import Box +from scaledp.schemas.DetectorOutput import DetectorOutput + + +class FastTextDetector(BaseDetector, HasDevice, HasBatchSize): + _model = None + defaultParams = MappingProxyType( + { + "inputCol": "image", + "outputCol": "boxes", + "keepInputData": False, + "scaleFactor": 1.0, + "scoreThreshold": 0.7, + "batchSize": 2, + "device": Device.CPU, + "partitionMap": False, + "numPartitions": 0, + "pageCol": "page", + "pathCol": "path", + "propagateError": False, + "onlyRotated": False, + }, + ) + + @keyword_only + def __init__(self, **kwargs: Any) -> None: + super(FastTextDetector, self).__init__() + self._setDefault(**self.defaultParams) + self._set(**kwargs) + self.get_model({k.name: v for k, v in self.extractParamMap().items()}) + + @classmethod + def get_model(cls, params): + if cls._model: + return cls._model + device = "cuda" if int(params["device"]) == Device.CUDA.value else "cpu" + + # Initialize the fast text detection model from doctr + cls._model = detection_predictor( + arch="fast_tiny", # Use DBNet with ResNet50 backbone + pretrained=True, # Use pretrained weights + assume_straight_pages=True, + ).to(device) + + return cls._model + + @classmethod + def call_detector(cls, images, params): + model = cls.get_model(params) + device = "cuda" if int(params["device"]) == Device.CUDA.value else "cpu" + results = [] + + for img, image_path in images: + try: + # Convert PIL image to numpy array if needed + image = img + if not isinstance(image, np.ndarray): + image = np.array(image) + + # Normalize image + if image.max() > 1: + image = image / 255.0 + + # Get predictions + out = model([[image]]) + + # Extract boxes from predictions + # doctr returns relative coordinates (0-1) + predictions = out[0] + + # Convert doctr boxes to Box objects + # Scale relative coordinates to absolute coordinates + height, width = image.shape[:2] + box_objects = [] + for pred in predictions: + # Get coordinates + x_min, y_min = pred[0] # Top-left + x_max, y_max = pred[2] # Bottom-right + + # Convert to absolute coordinates + abs_coords = [ + int(x_min * width), # x_min + int(y_min * height), # y_min + int(x_max * width), # x_max + int(y_max * height), # y_max + ] + + box_objects.append(Box.from_bbox(abs_coords)) + results.append( + DetectorOutput( + path=image_path, + type="fast", + bboxes=box_objects, + exception="", + ), + ) + + except Exception as e: + logging.exception(e) + results.append( + DetectorOutput( + path=image_path, + type="fast", + bboxes=[], + exception=f"FastTextDetector error: {e!s}", + ), + ) + + if device == "cuda": + torch.cuda.empty_cache() + + return results diff --git a/scaledp/models/detectors/craft/__init__.py b/scaledp/models/detectors/craft/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scaledp/models/detectors/craft/models.py b/scaledp/models/detectors/craft/models.py new file mode 100644 index 0000000..dfe6606 --- /dev/null +++ b/scaledp/models/detectors/craft/models.py @@ -0,0 +1,28 @@ +import onnxruntime +from crafter.resources import res + + +class Craftnet: + def __init__(self, onnx_path=None): + onnx_path = "/home/mykola/PycharmProjects/scaledp/tests/model.quant.onnx" + + session_options = onnxruntime.SessionOptions() + if onnx_path is None: + onnx_path = res("craftnet.onnx") + self._onnx_session = onnxruntime.InferenceSession( + onnx_path, + sess_options=session_options, + ) + + def __call__(self, image): + return self._onnx_session.run(None, {"image": image}) + + +class Refinenet: + def __init__(self, onnx_path=None): + if onnx_path is None: + onnx_path = res("refinenet.onnx") + self._onnx_session = onnxruntime.InferenceSession(onnx_path) + + def __call__(self, y, feature): + return self._onnx_session.run(None, {"y": y, "feature": feature})[0] diff --git a/scaledp/models/detectors/paddle_onnx/__init__.py b/scaledp/models/detectors/paddle_onnx/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scaledp/models/detectors/paddle_onnx/db_postprocess.py b/scaledp/models/detectors/paddle_onnx/db_postprocess.py new file mode 100644 index 0000000..bf4fb52 --- /dev/null +++ b/scaledp/models/detectors/paddle_onnx/db_postprocess.py @@ -0,0 +1,275 @@ +""" +This code is refered from: +https://github.com/WenmuZhou/DBNet.pytorch/blob/master/post_processing/seg_detector_representer.py +""" + +import cv2 +import numpy as np +import pyclipper +from shapely.geometry import Polygon + + +class DBPostProcess(object): + """ + The post process for Differentiable Binarization (DB). + """ + + def __init__( + self, + thresh=0.3, + box_thresh=0.7, + max_candidates=1000, + unclip_ratio=2.0, + use_dilation=False, + score_mode="fast", + box_type="quad", + **kwargs + ): + self.thresh = thresh + self.box_thresh = box_thresh + self.max_candidates = max_candidates + self.unclip_ratio = unclip_ratio + self.min_size = 3 + self.score_mode = score_mode + self.box_type = box_type + assert score_mode in [ + "slow", + "fast", + ], "Score mode must be in [slow, fast] but got: {}".format(score_mode) + + self.dilation_kernel = None if not use_dilation else np.array([[1, 1], [1, 1]]) + + def polygons_from_bitmap(self, pred, _bitmap, dest_width, dest_height): + """ + _bitmap: single map with shape (1, H, W), + whose values are binarized as {0, 1} + """ + + bitmap = _bitmap + height, width = bitmap.shape + + boxes = [] + scores = [] + + contours, _ = cv2.findContours( + (bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE + ) + + for contour in contours[: self.max_candidates]: + epsilon = 0.002 * cv2.arcLength(contour, True) + approx = cv2.approxPolyDP(contour, epsilon, True) + points = approx.reshape((-1, 2)) + if points.shape[0] < 4: + continue + + score = self.box_score_fast(pred, points.reshape(-1, 2)) + if self.box_thresh > score: + continue + + if points.shape[0] > 2: + box = self.unclip(points, self.unclip_ratio) + if len(box) > 1: + continue + else: + continue + box = box.reshape(-1, 2) + + _, sside = self.get_mini_boxes(box.reshape((-1, 1, 2))) + if sside < self.min_size + 2: + continue + + box = np.array(box) + box[:, 0] = np.clip(np.round(box[:, 0] / width * dest_width), 0, dest_width) + box[:, 1] = np.clip( + np.round(box[:, 1] / height * dest_height), 0, dest_height + ) + boxes.append(box.tolist()) + scores.append(score) + return boxes, scores + + def boxes_from_bitmap( + self, pred, _bitmap, dest_width, dest_height, ratio_h, ratio_w + ): + """ + _bitmap: single map with shape (1, H, W), + whose values are binarized as {0, 1} + """ + + bitmap = _bitmap + height, width = bitmap.shape + + outs = cv2.findContours( + (bitmap * 255).astype(np.uint8), cv2.RETR_LIST, cv2.CHAIN_APPROX_SIMPLE + ) + if len(outs) == 3: + img, contours, _ = outs[0], outs[1], outs[2] + elif len(outs) == 2: + contours, _ = outs[0], outs[1] + + num_contours = min(len(contours), self.max_candidates) + + boxes = [] + scores = [] + for index in range(num_contours): + contour = contours[index] + points, sside = self.get_mini_boxes(contour) + if sside < self.min_size: + continue + points = np.array(points) + if self.score_mode == "fast": + score = self.box_score_fast(pred, points.reshape(-1, 2)) + else: + score = self.box_score_slow(pred, contour) + if self.box_thresh > score: + continue + + box = self.unclip(points, self.unclip_ratio).reshape(-1, 1, 2) + box, sside = self.get_mini_boxes(box) + if sside < self.min_size + 2: + continue + box = np.array(box) + + # box[:, 0] = np.clip( + # np.round(box[:, 0] / width * dest_width), 0, dest_width) + # box[:, 1] = np.clip( + # np.round(box[:, 1] / height * dest_height), 0, dest_height) + + box[:, 0] = np.clip(np.round(box[:, 0] / ratio_w), 0, dest_width) + box[:, 1] = np.clip(np.round(box[:, 1] / ratio_h), 0, dest_height) + boxes.append(box.astype("int32")) + scores.append(score) + return np.array(boxes, dtype="int32"), scores + + def unclip(self, box, unclip_ratio): + poly = Polygon(box) + distance = poly.area * unclip_ratio / poly.length + offset = pyclipper.PyclipperOffset() + offset.AddPath(box, pyclipper.JT_ROUND, pyclipper.ET_CLOSEDPOLYGON) + expanded = np.array(offset.Execute(distance)) + return expanded + + def get_mini_boxes(self, contour): + bounding_box = cv2.minAreaRect(contour) + points = sorted(list(cv2.boxPoints(bounding_box)), key=lambda x: x[0]) + + index_1, index_2, index_3, index_4 = 0, 1, 2, 3 + if points[1][1] > points[0][1]: + index_1 = 0 + index_4 = 1 + else: + index_1 = 1 + index_4 = 0 + if points[3][1] > points[2][1]: + index_2 = 2 + index_3 = 3 + else: + index_2 = 3 + index_3 = 2 + + box = [ + points[index_1], + points[index_2], + points[index_3], + points[index_4], + ] + return box, min(bounding_box[1]) + + def box_score_fast(self, bitmap, _box): + """ + box_score_fast: use bbox mean score as the mean score + """ + h, w = bitmap.shape[:2] + box = _box.copy() + xmin = np.clip(np.floor(box[:, 0].min()).astype("int32"), 0, w - 1) + xmax = np.clip(np.ceil(box[:, 0].max()).astype("int32"), 0, w - 1) + ymin = np.clip(np.floor(box[:, 1].min()).astype("int32"), 0, h - 1) + ymax = np.clip(np.ceil(box[:, 1].max()).astype("int32"), 0, h - 1) + + mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8) + box[:, 0] = box[:, 0] - xmin + box[:, 1] = box[:, 1] - ymin + cv2.fillPoly(mask, box.reshape(1, -1, 2).astype("int32"), 1) + return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0] + + def box_score_slow(self, bitmap, contour): + """ + box_score_slow: use polyon mean score as the mean score + """ + h, w = bitmap.shape[:2] + contour = contour.copy() + contour = np.reshape(contour, (-1, 2)) + + xmin = np.clip(np.min(contour[:, 0]), 0, w - 1) + xmax = np.clip(np.max(contour[:, 0]), 0, w - 1) + ymin = np.clip(np.min(contour[:, 1]), 0, h - 1) + ymax = np.clip(np.max(contour[:, 1]), 0, h - 1) + + mask = np.zeros((ymax - ymin + 1, xmax - xmin + 1), dtype=np.uint8) + + contour[:, 0] = contour[:, 0] - xmin + contour[:, 1] = contour[:, 1] - ymin + + cv2.fillPoly(mask, contour.reshape(1, -1, 2).astype("int32"), 1) + return cv2.mean(bitmap[ymin : ymax + 1, xmin : xmax + 1], mask)[0] + + def __call__(self, outs_dict, shape_list): + pred = outs_dict["maps"] + pred = pred[:, 0, :, :] + segmentation = pred > self.thresh + + boxes_batch = [] + for batch_index in range(pred.shape[0]): + src_h, src_w, ratio_h, ratio_w = shape_list[batch_index] + if self.dilation_kernel is not None: + mask = cv2.dilate( + np.array(segmentation[batch_index]).astype(np.uint8), + self.dilation_kernel, + ) + else: + mask = segmentation[batch_index] + if self.box_type == "poly": + boxes, scores = self.polygons_from_bitmap( + pred[batch_index], mask, src_w, src_h + ) + elif self.box_type == "quad": + boxes, scores = self.boxes_from_bitmap( + pred[batch_index], mask, src_w, src_h, ratio_h, ratio_w + ) + else: + raise ValueError("box_type can only be one of ['quad', 'poly']") + + boxes_batch.append({"points": boxes}) + return boxes_batch + + +class DistillationDBPostProcess(object): + def __init__( + self, + model_name=["student"], + key=None, + thresh=0.3, + box_thresh=0.6, + max_candidates=1000, + unclip_ratio=1.5, + use_dilation=False, + score_mode="fast", + box_type="quad", + **kwargs + ): + self.model_name = model_name + self.key = key + self.post_process = DBPostProcess( + thresh=thresh, + box_thresh=box_thresh, + max_candidates=max_candidates, + unclip_ratio=unclip_ratio, + use_dilation=use_dilation, + score_mode=score_mode, + box_type=box_type, + ) + + def __call__(self, predicts, shape_list): + results = {} + for k in self.model_name: + results[k] = self.post_process(predicts[k], shape_list=shape_list) + return results diff --git a/scaledp/models/detectors/paddle_onnx/imaug.py b/scaledp/models/detectors/paddle_onnx/imaug.py new file mode 100644 index 0000000..ec21b31 --- /dev/null +++ b/scaledp/models/detectors/paddle_onnx/imaug.py @@ -0,0 +1,36 @@ +""" +https://github.com/PaddlePaddle/PaddleOCR/blob/main/ppocr/data/imaug/__init__.py +""" + +from .operators import * + + +def transform(data, ops=None): + """Transform""" + if ops is None: + ops = [] + for op in ops: + data = op(data) + if data is None: + return None + return data + + +def create_operators(op_param_list, global_config=None): + """ + create operators based on the config + + Args: + params(list): a dict list, used to create some operators + """ + assert isinstance(op_param_list, list), "operator config should be a list" + ops = [] + for operator in op_param_list: + assert isinstance(operator, dict) and len(operator) == 1, "yaml format error" + op_name = list(operator)[0] + param = {} if operator[op_name] is None else operator[op_name] + if global_config is not None: + param.update(global_config) + op = eval(op_name)(**param) + ops.append(op) + return ops diff --git a/scaledp/models/detectors/paddle_onnx/operators.py b/scaledp/models/detectors/paddle_onnx/operators.py new file mode 100644 index 0000000..15f79b9 --- /dev/null +++ b/scaledp/models/detectors/paddle_onnx/operators.py @@ -0,0 +1,199 @@ +import sys + +import cv2 +import numpy as np + + +class NormalizeImage(object): + """normalize image such as substract mean, divide std""" + + def __init__(self, scale=None, mean=None, std=None, order="chw", **kwargs): + if isinstance(scale, str): + scale = eval(scale) + self.scale = np.float32(scale if scale is not None else 1.0 / 255.0) + mean = mean if mean is not None else [0.485, 0.456, 0.406] + std = std if std is not None else [0.229, 0.224, 0.225] + + shape = (3, 1, 1) if order == "chw" else (1, 1, 3) + self.mean = np.array(mean).reshape(shape).astype("float32") + self.std = np.array(std).reshape(shape).astype("float32") + + def __call__(self, data): + img = data["image"] + from PIL import Image + + if isinstance(img, Image.Image): + img = np.array(img) + assert isinstance(img, np.ndarray), "invalid input 'img' in NormalizeImage" + data["image"] = (img.astype("float32") * self.scale - self.mean) / self.std + return data + + +class DetResizeForTest(object): + def __init__(self, **kwargs): + super(DetResizeForTest, self).__init__() + self.resize_type = 0 + self.keep_ratio = False + if "image_shape" in kwargs: + self.image_shape = kwargs["image_shape"] + self.resize_type = 1 + if "keep_ratio" in kwargs: + self.keep_ratio = kwargs["keep_ratio"] + elif "limit_side_len" in kwargs: + self.limit_side_len = kwargs["limit_side_len"] + self.limit_type = kwargs.get("limit_type", "min") + elif "resize_long" in kwargs: + self.resize_type = 2 + self.resize_long = kwargs.get("resize_long", 960) + else: + self.limit_side_len = 736 + self.limit_type = "min" + + def __call__(self, data): + img = data["image"] + src_h, src_w, _ = img.shape + if sum([src_h, src_w]) < 64: + img = self.image_padding(img) + + if self.resize_type == 0: + # img, shape = self.resize_image_type0(img) + img, [ratio_h, ratio_w] = self.resize_image_type0(img) + elif self.resize_type == 2: + img, [ratio_h, ratio_w] = self.resize_image_type2(img) + else: + # img, shape = self.resize_image_type1(img) + img, [ratio_h, ratio_w] = self.resize_image_type1(img) + data["image"] = img + data["shape"] = np.array([src_h, src_w, ratio_h, ratio_w]) + return data + + def image_padding(self, im, value=0): + h, w, c = im.shape + im_pad = np.zeros((max(32, h), max(32, w), c), np.uint8) + value + im_pad[:h, :w, :] = im + return im_pad + + def resize_image_type1(self, img): + target_h, target_w = self.image_shape + ori_h, ori_w = img.shape[:2] + if self.keep_ratio: + scale = min(target_h / ori_h, target_w / ori_w) + resize_h = int(ori_h * scale) + resize_w = int(ori_w * scale) + img = cv2.resize(img, (resize_w, resize_h)) + + if resize_h < target_h: + pad_bottom = target_h - resize_h + img = cv2.copyMakeBorder( + img, 0, pad_bottom, 0, 0, cv2.BORDER_CONSTANT, value=(255, 255, 255) + ) + if resize_w < target_w: + pad_right = target_w - resize_w + img = cv2.copyMakeBorder( + img, 0, 0, 0, pad_right, cv2.BORDER_CONSTANT, value=(255, 255, 255) + ) + ratio_h = ratio_w = scale + else: + img = cv2.resize(img, (target_w, target_h)) + ratio_h = target_h / ori_h + ratio_w = target_w / ori_w + return img, [ratio_h, ratio_w] + + def resize_image_type0(self, img): + """ + resize image to a size multiple of 32 which is required by the network + args: + img(array): array with shape [h, w, c] + return(tuple): + img, (ratio_h, ratio_w) + """ + limit_side_len = self.limit_side_len + h, w, c = img.shape + + # limit the max side + if self.limit_type == "max": + if max(h, w) > limit_side_len: + if h > w: + ratio = float(limit_side_len) / h + else: + ratio = float(limit_side_len) / w + else: + ratio = 1.0 + elif self.limit_type == "min": + if min(h, w) < limit_side_len: + if h < w: + ratio = float(limit_side_len) / h + else: + ratio = float(limit_side_len) / w + else: + ratio = 1.0 + elif self.limit_type == "resize_long": + ratio = float(limit_side_len) / max(h, w) + else: + raise Exception("not support limit type, image ") + resize_h = int(h * ratio) + resize_w = int(w * ratio) + + resize_h = max(int(round(resize_h / 32) * 32), 32) + resize_w = max(int(round(resize_w / 32) * 32), 32) + + try: + if int(resize_w) <= 0 or int(resize_h) <= 0: + return None, (None, None) + img = cv2.resize(img, (int(resize_w), int(resize_h))) + except: + print(img.shape, resize_w, resize_h) + sys.exit(0) + ratio_h = resize_h / float(h) + ratio_w = resize_w / float(w) + return img, [ratio_h, ratio_w] + + def resize_image_type2(self, img): + h, w, _ = img.shape + + resize_w = w + resize_h = h + + if resize_h > resize_w: + ratio = float(self.resize_long) / resize_h + else: + ratio = float(self.resize_long) / resize_w + + resize_h = int(resize_h * ratio) + resize_w = int(resize_w * ratio) + + max_stride = 128 + resize_h = (resize_h + max_stride - 1) // max_stride * max_stride + resize_w = (resize_w + max_stride - 1) // max_stride * max_stride + img = cv2.resize(img, (int(resize_w), int(resize_h))) + ratio_h = resize_h / float(h) + ratio_w = resize_w / float(w) + + return img, [ratio_h, ratio_w] + + +class ToCHWImage(object): + """convert hwc image to chw image""" + + def __init__(self, **kwargs): + pass + + def __call__(self, data): + img = data["image"] + from PIL import Image + + if isinstance(img, Image.Image): + img = np.array(img) + data["image"] = img.transpose((2, 0, 1)) + return data + + +class KeepKeys(object): + def __init__(self, keep_keys, **kwargs): + self.keep_keys = keep_keys + + def __call__(self, data): + data_list = [] + for key in self.keep_keys: + data_list.append(data[key]) + return data_list diff --git a/scaledp/models/detectors/paddle_onnx/predict_base.py b/scaledp/models/detectors/paddle_onnx/predict_base.py new file mode 100644 index 0000000..a23a9a7 --- /dev/null +++ b/scaledp/models/detectors/paddle_onnx/predict_base.py @@ -0,0 +1,58 @@ +import onnxruntime + + +class PredictBase(object): + def __init__(self): + pass + + def get_onnx_session(self, model_dir, use_gpu): + # 使用gpu + if use_gpu: + providers = [ + "CUDAExecutionProvider" + ] # [('CUDAExecutionProvider',{"cudnn_conv_algo_search": "DEFAULT"})]#,'CPUExecutionProvider'] + else: + providers = ["CPUExecutionProvider"] + + session_options = onnxruntime.SessionOptions() + session_options.intra_op_num_threads = 1 # Set number of CPU cores + onnx_session = onnxruntime.InferenceSession( + model_dir, session_options, providers=providers + ) + + # print("providers:", onnxruntime.get_device()) + return onnx_session + + def get_output_name(self, onnx_session): + """ + output_name = onnx_session.get_outputs()[0].name + :param onnx_session: + :return: + """ + output_name = [] + for node in onnx_session.get_outputs(): + output_name.append(node.name) + return output_name + + def get_input_name(self, onnx_session): + """ + input_name = onnx_session.get_inputs()[0].name + :param onnx_session: + :return: + """ + input_name = [] + for node in onnx_session.get_inputs(): + input_name.append(node.name) + return input_name + + def get_input_feed(self, input_name, image_numpy): + """ + input_feed={self.input_name: image_numpy} + :param input_name: + :param image_numpy: + :return: + """ + input_feed = {} + for name in input_name: + input_feed[name] = image_numpy + return input_feed diff --git a/scaledp/models/detectors/paddle_onnx/predict_det.py b/scaledp/models/detectors/paddle_onnx/predict_det.py new file mode 100644 index 0000000..39af222 --- /dev/null +++ b/scaledp/models/detectors/paddle_onnx/predict_det.py @@ -0,0 +1,122 @@ +"""https://github.com/opencv-ai/paddle-ocr/blob/main/detector.py""" + +import numpy as np + +from .db_postprocess import DBPostProcess +from .imaug import create_operators, transform +from .predict_base import PredictBase + + +class DBNetTextDetector(PredictBase): + def __init__(self, det_model_dir, use_gpu): + self.det_algorithm = "DB" + pre_process_list = [ + { + "DetResizeForTest": { + "image_shape": [960, 960], + # "limit_side_len": 960, + # "resize_long": 960, + "limit_type": "max", + "keep_ratio": True, + }, + }, + { + "NormalizeImage": { + "std": [0.229, 0.224, 0.225], + "mean": [0.485, 0.456, 0.406], + "scale": "1./255.", + "order": "hwc", + }, + }, + {"ToCHWImage": None}, + {"KeepKeys": {"keep_keys": ["image", "shape"]}}, + ] + postprocess_params = {} + postprocess_params["name"] = "DBPostProcess" + postprocess_params["thresh"] = 0.3 # args.det_db_thresh + postprocess_params["box_thresh"] = 0.4 # args.det_db_box_thresh + postprocess_params["max_candidates"] = 1000 + postprocess_params["unclip_ratio"] = 1.7 # args.det_db_unclip_ratio + postprocess_params["use_dilation"] = False # args.use_dilation + postprocess_params["score_mode"] = "fast" # args.det_db_score_mode + postprocess_params["box_type"] = "quad" # args.det_box_type + self.det_box_type = postprocess_params["box_type"] + + self.preprocess_op = create_operators(pre_process_list) + self.postprocess_op = DBPostProcess(**postprocess_params) + + self.det_onnx_session = self.get_onnx_session(det_model_dir, use_gpu) + self.det_input_name = self.get_input_name(self.det_onnx_session) + self.det_output_name = self.get_output_name(self.det_onnx_session) + + def order_points_clockwise(self, pts): + rect = np.zeros((4, 2), dtype="float32") + s = pts.sum(axis=1) + rect[0] = pts[np.argmin(s)] + rect[2] = pts[np.argmax(s)] + tmp = np.delete(pts, (np.argmin(s), np.argmax(s)), axis=0) + diff = np.diff(np.array(tmp), axis=1) + rect[1] = tmp[np.argmin(diff)] + rect[3] = tmp[np.argmax(diff)] + return rect + + def clip_det_res(self, points, img_height, img_width): + for pno in range(points.shape[0]): + points[pno, 0] = int(min(max(points[pno, 0], 0), img_width - 1)) + points[pno, 1] = int(min(max(points[pno, 1], 0), img_height - 1)) + return points + + def filter_tag_det_res(self, dt_boxes, image_shape): + img_height, img_width = image_shape[0:2] + dt_boxes_new = [] + for box in dt_boxes: + if type(box) is list: + box = np.array(box) + box = self.order_points_clockwise(box) + box = self.clip_det_res(box, img_height, img_width) + rect_width = int(np.linalg.norm(box[0] - box[1])) + rect_height = int(np.linalg.norm(box[0] - box[3])) + if rect_width <= 3 or rect_height <= 3: + continue + dt_boxes_new.append(box) + dt_boxes = np.array(dt_boxes_new) + return dt_boxes + + def filter_tag_det_res_only_clip(self, dt_boxes, image_shape): + img_height, img_width = image_shape[0:2] + dt_boxes_new = [] + for box in dt_boxes: + if type(box) is list: + box = np.array(box) + box = self.clip_det_res(box, img_height, img_width) + dt_boxes_new.append(box) + dt_boxes = np.array(dt_boxes_new) + return dt_boxes + + def __call__(self, img): + ori_im = img.copy() + data = {"image": img} + + data = transform(data, self.preprocess_op) + img, shape_list = data + if img is None: + return None, 0 + img = np.expand_dims(img, axis=0) + shape_list = np.expand_dims(shape_list, axis=0) + img = img.copy() + + input_feed = self.get_input_feed(self.det_input_name, img) + outputs = self.det_onnx_session.run(self.det_output_name, input_feed=input_feed) + + preds = {} + preds["maps"] = outputs[0] + + post_result = self.postprocess_op(preds, shape_list) + dt_boxes = post_result[0]["points"] + + if self.det_box_type == "poly": + dt_boxes = self.filter_tag_det_res_only_clip(dt_boxes, ori_im.shape) + else: + dt_boxes = self.filter_tag_det_res(dt_boxes, ori_im.shape) + + return dt_boxes diff --git a/scaledp/models/detectors/yolo/__init__.py b/scaledp/models/detectors/yolo/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scaledp/models/detectors/yolo/utils.py b/scaledp/models/detectors/yolo/utils.py new file mode 100644 index 0000000..bf0c59d --- /dev/null +++ b/scaledp/models/detectors/yolo/utils.py @@ -0,0 +1,70 @@ +import numpy as np + + +def nms(boxes, scores, iou_threshold): + # Sort by score + sorted_indices = np.argsort(scores)[::-1] + + keep_boxes = [] + while sorted_indices.size > 0: + # Pick the last box + box_id = sorted_indices[0] + keep_boxes.append(box_id) + + # Compute IoU of the picked box with the rest + ious = compute_iou(boxes[box_id, :], boxes[sorted_indices[1:], :]) + + # Remove boxes with IoU over the threshold + keep_indices = np.where(ious < iou_threshold)[0] + + # print(keep_indices.shape, sorted_indices.shape) + sorted_indices = sorted_indices[keep_indices + 1] + + return keep_boxes + + +def multiclass_nms(boxes, scores, class_ids, iou_threshold): + + unique_class_ids = np.unique(class_ids) + + keep_boxes = [] + for class_id in unique_class_ids: + class_indices = np.where(class_ids == class_id)[0] + class_boxes = boxes[class_indices, :] + class_scores = scores[class_indices] + + class_keep_boxes = nms(class_boxes, class_scores, iou_threshold) + keep_boxes.extend(class_indices[class_keep_boxes]) + + return keep_boxes + + +def compute_iou(box, boxes): + """Compute xmin, ymin, xmax, ymax for both boxes.""" + xmin = np.maximum(box[0], boxes[:, 0]) + ymin = np.maximum(box[1], boxes[:, 1]) + xmax = np.minimum(box[2], boxes[:, 2]) + ymax = np.minimum(box[3], boxes[:, 3]) + + # Compute intersection area + intersection_area = np.maximum(0, xmax - xmin) * np.maximum(0, ymax - ymin) + + # Compute union area + box_area = (box[2] - box[0]) * (box[3] - box[1]) + boxes_area = (boxes[:, 2] - boxes[:, 0]) * (boxes[:, 3] - boxes[:, 1]) + union_area = box_area + boxes_area - intersection_area + + # Compute IoU + iou = intersection_area / union_area + + return iou + + +def xywh2xyxy(x): + """Convert bounding box (x, y, w, h) to bounding box (x1, y1, x2, y2).""" + y = np.copy(x) + y[..., 0] = x[..., 0] - x[..., 2] / 2 + y[..., 1] = x[..., 1] - x[..., 3] / 2 + y[..., 2] = x[..., 0] + x[..., 2] / 2 + y[..., 3] = x[..., 1] + x[..., 3] / 2 + return y diff --git a/scaledp/models/recognizers/BaseOcr.py b/scaledp/models/recognizers/BaseOcr.py index d57e30e..46e7bb7 100644 --- a/scaledp/models/recognizers/BaseOcr.py +++ b/scaledp/models/recognizers/BaseOcr.py @@ -262,7 +262,7 @@ def _transform(self, dataset): ), ) if not self.getKeepInputData(): - result = result.drop(input_col) + result = result.drop(self.getInputCol()) return result def setLineTolerance(self, value): diff --git a/scaledp/pdf/PdfDataToDocument.py b/scaledp/pdf/PdfDataToDocument.py index e82cb76..a295bd6 100644 --- a/scaledp/pdf/PdfDataToDocument.py +++ b/scaledp/pdf/PdfDataToDocument.py @@ -64,28 +64,64 @@ def transform_udf(self, input: Row, path: str) -> list[Document]: page = doc[0] # Get the page's transformation matrix and dimensions - ctm = page.transformation_matrix dpi = self.getResolution() # PDF default DPI + # Get page rotation + rotation = page.rotation + # Normalize rotation to 0, 90, 180, or 270 degrees + rotation = rotation % 360 + words = page.get_text("words") boxes = [] text_content = [] + # Get page dimensions + page_width = page.mediabox_size[0] + page_height = page.mediabox_size[1] + for word in words: x0, y0, x1, y1, word_text, _, _, _ = word # Convert PDF coordinates to pixel coordinates using the transformation matrix - # and maintain position relative to DPI - pixel_x0 = x0 * ctm[0] * (dpi / 72) - pixel_y0 = abs(y0 * ctm[3] * (dpi / 72)) - pixel_x1 = x1 * ctm[0] * (dpi / 72) - pixel_y1 = abs(y1 * ctm[3] * (dpi / 72)) + # Scale coordinates according to DPI + scale = dpi / 72 + + # Apply basic coordinate transformation + if rotation == 0: + pixel_x0 = x0 * scale + pixel_y0 = y0 * scale + pixel_x1 = x1 * scale + pixel_y1 = y1 * scale + elif rotation == 90: + # Rotate 90 degrees clockwise + pixel_x0 = page_height * scale - y0 * scale + pixel_y0 = x0 * scale + pixel_x1 = page_height * scale - y1 * scale + pixel_y1 = x1 * scale + elif rotation == 180: + # Rotate 180 degrees + pixel_x0 = page_width * scale - x0 * scale + pixel_y0 = y0 * scale + pixel_x1 = page_width * scale - x1 * scale + pixel_y1 = y1 * scale + elif rotation == 270: + # Rotate 270 degrees clockwise + pixel_x0 = y0 * scale + pixel_y0 = page_width * scale - x0 * scale + pixel_x1 = y1 * scale + pixel_y1 = page_width * scale - x1 * scale + + # Ensure coordinates are properly ordered (x0 < x1 and y0 < y1) + x_min = min(pixel_x0, pixel_x1) + x_max = max(pixel_x0, pixel_x1) + y_min = min(pixel_y0, pixel_y1) + y_max = max(pixel_y0, pixel_y1) boxes.append( Box( - x=int(pixel_x0), - y=int(pixel_y0), - width=int(pixel_x1 - pixel_x0), - height=int(pixel_y1 - pixel_y0), + x=int(x_min), + y=int(y_min), + width=int(x_max - x_min), + height=int(y_max - y_min), text=word_text, score=1.0, ), @@ -129,5 +165,5 @@ def _transform(self, dataset: DataFrame) -> DataFrame: ), ) if not self.getKeepInputData(): - result = result.drop(input_col) + result = result.drop(self.getInputCol()) return result diff --git a/scaledp/pdf/PdfDataToImage.py b/scaledp/pdf/PdfDataToImage.py index 7be1b57..12841ef 100644 --- a/scaledp/pdf/PdfDataToImage.py +++ b/scaledp/pdf/PdfDataToImage.py @@ -8,7 +8,7 @@ from pyspark.ml import Transformer from pyspark.ml.util import DefaultParamsReadable, DefaultParamsWritable from pyspark.pandas import DataFrame -from pyspark.sql.functions import posexplode_outer, udf +from pyspark.sql.functions import udf from pyspark.sql.types import ArrayType, Row from scaledp.enums import ImageType @@ -26,6 +26,7 @@ Params, TypeConverters, ) +from scaledp.pipeline.PandasPipeline import posexplode from scaledp.schemas.Image import Image @@ -111,21 +112,18 @@ def _transform(self, dataset: DataFrame) -> DataFrame: input_col = self._validate(self.getInputCol(), dataset) path_col = dataset[self.getPathCol()] - sel_col = [ - *dataset.columns, - *[ - posexplode_outer( - udf(self.transform_udf, ArrayType(Image.get_schema()))( - input_col, - path_col, - ), - ).alias(self.getPageCol(), out_col), - ], - ] + df_1 = dataset.withColumn( + "temp_data", + udf(self.transform_udf, ArrayType(Image.get_schema()))( + input_col, + path_col, + ), + ) + + result = posexplode(df_1, "temp_data", self.getPageCol(), out_col) - result = dataset.select(*sel_col) if not self.getKeepInputData(): - result = result.drop(input_col) + result = result.drop(self.getInputCol()) return result def getPageLimit(self) -> int: diff --git a/scaledp/pdf/SingleImageToPdf.py b/scaledp/pdf/SingleImageToPdf.py index 14b75b4..01b13fa 100644 --- a/scaledp/pdf/SingleImageToPdf.py +++ b/scaledp/pdf/SingleImageToPdf.py @@ -58,8 +58,17 @@ def transform_udf(self, image): import img2pdf - a4inpt = (img2pdf.mm_to_pt(210), img2pdf.mm_to_pt(297)) - layout_fun = img2pdf.get_layout_fun(a4inpt) + a4_width_pt = img2pdf.mm_to_pt(210) + a4_height_pt = img2pdf.mm_to_pt(297) + + # Determine if the image should be in portrait or landscape + is_portrait = height > width + page_size = ( + (a4_width_pt, a4_height_pt) + if is_portrait + else (a4_height_pt, a4_width_pt) + ) + layout_fun = img2pdf.get_layout_fun(page_size) pdf_bytes = img2pdf.convert(io.BytesIO(image.data), layout_fun=layout_fun) except Exception: exception = traceback.format_exc() diff --git a/scaledp/pipeline/PandasPipeline.py b/scaledp/pipeline/PandasPipeline.py index c51ee58..939d9f8 100644 --- a/scaledp/pipeline/PandasPipeline.py +++ b/scaledp/pipeline/PandasPipeline.py @@ -6,6 +6,7 @@ from typing import Any, ClassVar, List import pandas as pd +import pyspark.sql.functions as f from pyspark.ml import Transformer @@ -49,6 +50,11 @@ def lit(value) -> Any: return itertools.repeat(value) +def explode(col: Any) -> Any: + """Exploding.""" + return col + + def _invoke_function(name: str, *args: Any) -> Any: if name == "lit": return lit(*args) @@ -72,6 +78,39 @@ def unpathSparkFunctions(pyspark: Any) -> None: pyspark.sql.functions._invoke_function = temp_functions["invoke_function"] +def posexplode(df, in_col, pos_col="page", val_col="value"): + """Explode a column of lists into multiple rows, with position index.""" + + def to_list(x): + val = x[in_col] + if not isinstance(val, list): + try: + val = list(val) # will work for generator, tuple, etc. + except TypeError: + val = [val] + return DatasetPd({pos_col: range(len(val)), val_col: val}) + + ret = None + if isinstance(df, pd.DataFrame): + out = df[[in_col]].apply(to_list, axis=1) + out = pd.concat(out.tolist(), keys=df.index).reset_index() + ret = DatasetPd( + df.drop(in_col).merge(out, left_index=True, right_on="level_0"), + ) + else: + sel_col = [ + *df.columns, + *[ + f.posexplode( + f.col(in_col), + ).alias(pos_col, val_col), + ], + ] + + ret = df.select(*sel_col) + return ret + + class DatasetPd(pd.DataFrame): def withColumn(self, name, col) -> "DatasetPd": @@ -82,7 +121,7 @@ def withColumn(self, name, col) -> "DatasetPd": return self def drop(self, col) -> "DatasetPd": - return self + return DatasetPd(super().drop(columns=[col])) def repartition(self, numPartitions) -> "DatasetPd": return self @@ -90,6 +129,9 @@ def repartition(self, numPartitions) -> "DatasetPd": def coalesce(self, numPartitions) -> "DatasetPd": return self + def select(self, *args: Any): + return self[list(args)] + class PandasPipeline: """PandasPipeline for call Spark ML Pipelines with Pandas DataFrame.""" @@ -119,7 +161,7 @@ def fromBinary(self, data, filename="memory") -> Any: def fromPandas(self, data: pd.DataFrame) -> Any: start_time_total = time.time() - execution_times = {"stages": []} + execution_times = {"stages": {}} data = DatasetPd(data) for stage in self.stages: @@ -128,17 +170,19 @@ def fromPandas(self, data: pd.DataFrame) -> Any: data = stage._transform(data) stage_duration = time.time() - start_time_stage - execution_times["stages"].append({stage_name: stage_duration}) + execution_times["stages"][stage_name] = round(stage_duration, 4) logging.info( f"Stage {stage_name} completed in {stage_duration:.2f} seconds", ) - total_duration = time.time() - start_time_total + total_duration = round(time.time() - start_time_total, 4) execution_times["total"] = total_duration logging.info(f"Total execution time: {total_duration:.2f} seconds") # Add execution time information as a new column - return data.withColumn("execution_time", [json.dumps(execution_times)]) + data["execution_time"] = json.dumps(execution_times) + + return data def fromDict(self, data: dict) -> Any: data = DatasetPd(data) diff --git a/scaledp/schemas/Image.py b/scaledp/schemas/Image.py index fcc0f50..768442f 100644 --- a/scaledp/schemas/Image.py +++ b/scaledp/schemas/Image.py @@ -23,10 +23,23 @@ class Image(object): width: int = 0 def to_pil(self) -> pImage.Image: + """Convert image to PIL Image format.""" if self.imageType in (ImageType.FILE.value, ImageType.WEBP.value): return pImage.open(io.BytesIO(self.data)) raise ValueError("Invalid image type.") + def to_cv2(self): + """Convert image to OpenCV format.""" + import cv2 + import numpy as np + + if self.imageType in (ImageType.FILE.value, ImageType.WEBP.value): + # Convert bytes to numpy array + nparr = np.frombuffer(self.data, np.uint8) + # Decode the numpy array as an image + return cv2.imdecode(nparr, cv2.IMREAD_COLOR) + raise ValueError("Invalid image type.") + def to_io_stream(self) -> io.BytesIO: return io.BytesIO(self.data) diff --git a/tests/conftest.py b/tests/conftest.py index 1820ed0..df35f95 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -1,13 +1,23 @@ from pathlib import Path +import pyspark import pytest from PIL import Image as pImage from scaledp.enums import ImageType from scaledp.image.DataToImage import DataToImage +from scaledp.pipeline.PandasPipeline import pathSparkFunctions, unpathSparkFunctions from scaledp.schemas.Image import Image +@pytest.fixture +def patch_spark(): + """Fixture to handle patching and unpatching of spark functions.""" + pathSparkFunctions(pyspark) + yield + unpathSparkFunctions(pyspark) + + @pytest.fixture def image_file(resource_path_root): return (resource_path_root / "images/Invoice.png").absolute().as_posix() @@ -69,6 +79,20 @@ def pdf_df(spark_session, resource_path_root): ) +@pytest.fixture +def pdf_df_extra(spark_session, resource_path_root): + return spark_session.read.format("binaryFile").load( + (resource_path_root / "pdfs/Example3.pdf").absolute().as_posix(), + ) + + +@pytest.fixture +def pdf_horizontal_df(spark_session, resource_path_root): + return spark_session.read.format("binaryFile").load( + (resource_path_root / "pdfs/horizontal.pdf").absolute().as_posix(), + ) + + @pytest.fixture def image_pdf_df(spark_session, resource_path_root): return spark_session.read.format("binaryFile").load( @@ -108,6 +132,24 @@ def image_receipt_df(spark_session, resource_path_root): return bin_to_image.transform(df) +@pytest.fixture +def image_rotated_df(spark_session, resource_path_root): + df = spark_session.read.format("binaryFile").load( + (resource_path_root / "images" / "img_rotated.png").absolute().as_posix(), + ) + bin_to_image = DataToImage().setImageType(ImageType.WEBP.value) + return bin_to_image.transform(df) + + +@pytest.fixture +def image_qr_code_df(spark_session, resource_path_root): + df = spark_session.read.format("binaryFile").load( + (resource_path_root / "images" / "QrCode.png").absolute().as_posix(), + ) + bin_to_image = DataToImage().setImageType(ImageType.WEBP.value) + return bin_to_image.transform(df) + + @pytest.fixture def receipt_json(receipt_json_path: Path) -> Path: return receipt_json_path.open("r").read() diff --git a/tests/models/detectors/test_craft_text_detector.py b/tests/models/detectors/test_craft_text_detector.py new file mode 100644 index 0000000..8b7c9c8 --- /dev/null +++ b/tests/models/detectors/test_craft_text_detector.py @@ -0,0 +1,111 @@ +import tempfile + +from pyspark.ml import PipelineModel + +from scaledp import ( + ImageDrawBoxes, + PdfDataToImage, + TesseractRecognizer, +) +from scaledp.enums import Device, TessLib +from scaledp.models.detectors.CraftTextDetector import CraftTextDetector + + +def test_craft_detector(image_rotated_df): + detector = CraftTextDetector( + device=Device.CPU, + keepInputData=True, + partitionMap=True, + numPartitions=1, + width=1600, + ) + + ocr = TesseractRecognizer( + inputCols=["image", "boxes"], + keepFormatting=False, + keepInputData=True, + tessLib=TessLib.PYTESSERACT, + lang=["eng", "spa"], + scoreThreshold=0.2, + scaleFactor=2.0, + partitionMap=True, + numPartitions=1, + ) + + draw = ImageDrawBoxes( + keepInputData=True, + inputCols=["image", "text"], + filled=False, + color="green", + lineWidth=5, + displayDataList=["score", "text", "angle"], + ) + # Transform the image dataframe through the OCR stage + pipeline = PipelineModel(stages=[detector, ocr, draw]) + result = pipeline.transform(image_rotated_df) + + data = result.collect() + + # Verify the pipeline result + assert len(data) == 1, "Expected exactly one result" + + # # Check that exceptions is empty + assert data[0].text.exception == "" + + # Save the output image to a temporary file for verification + with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp: + temp.write(data[0].image_with_boxes.data) + temp.close() + + # Print the path to the temporary file + print("file://" + temp.name) + + +def test_craft_detector_pdf(pdf_df_extra): + pdf_data_to_image = PdfDataToImage(inputCol="content", outputCol="image") + detector = CraftTextDetector( + device=Device.CPU, + keepInputData=True, + partitionMap=True, + numPartitions=1, + width=1600, + ) + + ocr = TesseractRecognizer( + inputCols=["image", "boxes"], + keepFormatting=False, + keepInputData=True, + tessLib=TessLib.PYTESSERACT, + lang=["eng", "spa"], + scoreThreshold=0.2, + partitionMap=True, + numPartitions=1, + ) + + draw = ImageDrawBoxes( + keepInputData=True, + inputCols=["image", "text"], + filled=False, + color="green", + lineWidth=5, + displayDataList=["score", "text"], + ) + # Transform the image dataframe through the OCR stage + pipeline = PipelineModel(stages=[pdf_data_to_image, detector, ocr, draw]) + result = pipeline.transform(pdf_df_extra) + + data = result.collect() + + # Verify the pipeline result + assert len(data) == 1, "Expected exactly one result" + + # # Check that exceptions is empty + assert data[0].text.exception == "" + + # Save the output image to a temporary file for verification + with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp: + temp.write(data[0].image_with_boxes.data) + temp.close() + + # Print the path to the temporary file + print("file://" + temp.name) diff --git a/tests/models/ner/test_ner.py b/tests/models/ner/test_ner.py index 314907b..061241d 100644 --- a/tests/models/ner/test_ner.py +++ b/tests/models/ner/test_ner.py @@ -13,7 +13,55 @@ def test_ner(image_df): ocr = TesseractOcr(keepInputData=True) # Initialize the NER stage with the specified model and device - ner = Ner(model="obi/deid_bert_i2b2", numPartitions=0, device=Device.CPU.value) + ner = Ner( + model="obi/deid_bert_i2b2", + numPartitions=0, + inputCols=["text", "text"], + device=Device.CPU.value, + ) + + # Transform the image dataframe through the OCR and NER stages + result_df = ner.transform(ocr.transform(image_df)) + + # Cache the result for performance + result = result_df.select("ner", "text").cache() + + # Collect the results + data = result.collect() + + # Check that exceptions is empty + assert data[0].text.exception == "" + + # Assert that there is exactly one result + assert len(data) == 1 + + # Assert that the 'ner' field is present in the result + assert hasattr(data[0], "ner") + + # Display the NER results for debugging + result.show_ner("ner", 40) + + # Visualize the NER results + result.visualize_ner() + + # Extract and count the NER tags + ner_tags = result.select(f.explode("ner.entities").alias("ner")).select("ner.*") + + # Assert that there are more than 70 NER tags + assert ner_tags.count() > 70 + + +def test_ner_pandas(image_df): + # Initialize the OCR stage + ocr = TesseractOcr(keepInputData=True) + + # Initialize the NER stage with the specified model and device + ner = Ner( + model="obi/deid_bert_i2b2", + numPartitions=1, + inputCols=["text", "text"], + device=Device.CPU.value, + ) # Transform the image dataframe through the OCR and NER stages result_df = ner.transform(ocr.transform(image_df)) diff --git a/tests/pdf/test_pdf_data_to_document.py b/tests/pdf/test_pdf_data_to_document.py index 43b77c1..006b85f 100644 --- a/tests/pdf/test_pdf_data_to_document.py +++ b/tests/pdf/test_pdf_data_to_document.py @@ -59,12 +59,6 @@ def test_pdf_data_to_document(pdf_df): # Test 3: Verify that OCR completed without exceptions assert result[0].text.exception == "", "OCR process encountered an exception" - # Test 4: Verify the expected content in the OCR result - expected_text = "UniDoc Medial Center" - assert ( - expected_text in result[0].text.text - ), f"Expected text '{expected_text}' not found in OCR result" - assert hasattr(result[0], "image_with_boxes") # Save the output image to a temporary file for verification @@ -165,7 +159,12 @@ def test_pdf_local_pipeline(pdf_file): pdf_data_to_document = PdfDataToDocument(inputCol="content", outputCol="text") # Initialize the OCR transformer - ocr = TesseractOcr(inputCol="image", outputCol="text", bypassCol="text") + ocr = TesseractOcr( + inputCol="image", + outputCol="text", + bypassCol="text", + keepInputData=True, + ) # Create the pipeline pipeline = PandasPipeline( @@ -187,6 +186,8 @@ def test_pdf_local_pipeline(pdf_file): ocr_result = result["text"][0].text assert len(ocr_result) > 0 + print(result["execution_time"]) + assert "execution_time" in result.columns unpathSparkFunctions(pyspark) diff --git a/tests/pdf/test_pdf_data_to_image.py b/tests/pdf/test_pdf_data_to_image.py index 1c9312e..e384da9 100644 --- a/tests/pdf/test_pdf_data_to_image.py +++ b/tests/pdf/test_pdf_data_to_image.py @@ -4,6 +4,7 @@ from scaledp.models.recognizers.TesseractOcr import TesseractOcr from scaledp.pdf.PdfDataToImage import PdfDataToImage +from scaledp.pipeline.PandasPipeline import PandasPipeline def test_pdf_data_to_text(pdf_df: DataFrame) -> None: @@ -31,6 +32,48 @@ def test_pdf_data_to_text(pdf_df: DataFrame) -> None: ), "Expected 'UniDoc Medical Center' in the detected text" +def test_pdf_local_pipeline(patch_spark, pdf_file: str) -> None: + """Test PDF processing using PandasPipeline with local file input.""" + + # Initialize pipeline stages + pdf_data_to_image = PdfDataToImage( + inputCol="content", + outputCol="image", + pageLimit=2, + ) + ocr = TesseractOcr( + inputCol="image", + outputCol="text", + keepInputData=True, + ) + + # Create and configure the pipeline + pipeline = PandasPipeline( + stages=[ + pdf_data_to_image, + ocr, + ], + ) + + # Process the PDF file + result = pipeline.fromFile(pdf_file) + + # Verify pipeline execution and results + assert result is not None, "Pipeline result should not be None" + assert "text" in result.columns, "Result should contain 'text' column" + assert "execution_time" in result.columns, "Result should contain execution timing" + + assert len(result) == 2 + + # Verify OCR results + ocr_result = result["text"][0].text + assert len(ocr_result) > 0, "OCR result should not be empty" + assert "Main Street Anywhere" in ocr_result, "Expected text content not found" + + # Optional: Print execution timing + print(f"Pipeline execution time: {result['execution_time'][0]}") + + def test_pdf_data_to_image_class(pdf_file: str) -> None: """Test the PdfDataToImage class with the UDF transform method.""" # Read the PDF file diff --git a/tests/pipeline/test_pipeline.py b/tests/pipeline/test_pipeline.py index a5f43b6..95bc9f4 100644 --- a/tests/pipeline/test_pipeline.py +++ b/tests/pipeline/test_pipeline.py @@ -1,37 +1,33 @@ from pathlib import Path +from pipeline.PandasPipeline import DatasetPd, PandasPipeline, posexplode + from scaledp import DataToImage -def test_local_pipeline(image_file: str) -> None: +def test_local_pipeline(patch_spark, image_file: str) -> None: """Test the local pipeline with the DataToImage stage.""" - import pyspark - - from scaledp.pipeline.PandasPipeline import PandasPipeline, UserDefinedFunction - - original_udf = pyspark.sql.udf.UserDefinedFunction - - try: - # Replace UserDefinedFunction with the custom one - pyspark.sql.udf.UserDefinedFunction = UserDefinedFunction + # Initialize the DataToImage stage + data_to_image = DataToImage() - # Initialize the DataToImage stage - data_to_image = DataToImage() + # Initialize the LocalPipeline with the DataToImage stage + pipeline = PandasPipeline(stages=[data_to_image]) - # Initialize the LocalPipeline with the DataToImage stage - pipeline = PandasPipeline(stages=[data_to_image]) + # Read the image file + with Path.open(image_file, "rb") as f: + image_data = f.read() - # Read the image file - with Path.open(image_file, "rb") as f: - image_data = f.read() + # Transform the image data through the pipeline + result = pipeline.fromBinary(image_data) - # Transform the image data through the pipeline - result = pipeline.fromBinary(image_data) + # Verify the pipeline result + assert result is not None, "Expected a non-None result from the pipeline" + assert len(result) > 0, "Expected at least one result from the pipeline" - # Verify the pipeline result - assert result is not None, "Expected a non-None result from the pipeline" - assert len(result) > 0, "Expected at least one result from the pipeline" - finally: - # Restore the original UserDefinedFunction - pyspark.sql.udf.UserDefinedFunction = original_udf +def test_explode(patch_spark, pdf_file: str) -> None: + """Test the explode function with the DataToImage stage.""" + data = DatasetPd( + {"content": [("1", "2", "3")], "path": ["memory"], "resolution": [0]}, + ) + print(posexplode(data, "content")) diff --git a/tests/pytest.ini b/tests/pytest.ini new file mode 100644 index 0000000..3dd7ced --- /dev/null +++ b/tests/pytest.ini @@ -0,0 +1,4 @@ +[pytest] +spark_options = + spark.app.name: scaledp-pytest-spark-tests + spark.executor.instances: 1 diff --git a/tests/testresources/images/QrCode.png b/tests/testresources/images/QrCode.png new file mode 100644 index 0000000000000000000000000000000000000000..6af489e59e47fc20e73c26d17bffc1b3562024bc GIT binary patch literal 54391 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 AuK)l5 literal 0 HcmV?d00001 From 4ef541ddec207a1f13f78efeb6c4f3caec17a9e0 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:45:34 +0200 Subject: [PATCH 09/13] Fixed tests --- tests/pipeline/test_pipeline.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tests/pipeline/test_pipeline.py b/tests/pipeline/test_pipeline.py index 95bc9f4..4d6535f 100644 --- a/tests/pipeline/test_pipeline.py +++ b/tests/pipeline/test_pipeline.py @@ -1,8 +1,7 @@ from pathlib import Path -from pipeline.PandasPipeline import DatasetPd, PandasPipeline, posexplode - from scaledp import DataToImage +from scaledp.pipeline.PandasPipeline import DatasetPd, PandasPipeline, posexplode def test_local_pipeline(patch_spark, image_file: str) -> None: From 82d514286537f616fbeefd44c9d6109bdfee6cbf Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:54:27 +0200 Subject: [PATCH 10/13] Fixed tests --- .github/workflows/tests.yml | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 5a14d73..9c1400b 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -112,7 +112,9 @@ jobs: #---------------------------------------------- - name: Install dependencies if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true' - run: poetry install --no-interaction -E ml + run: | + poetry install --no-interaction -E ml + poetry install --no-interaction # ensure the root package is installed #---------------------------------------------- # run test suite From 069e19ebcb172ebb590c4c8c425e5400ebd89505 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 16:56:39 +0200 Subject: [PATCH 11/13] Fixed tests --- .github/workflows/tests.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 9c1400b..4a9a681 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -114,7 +114,6 @@ jobs: if: steps.cached-poetry-dependencies.outputs.cache-hit != 'true' run: | poetry install --no-interaction -E ml - poetry install --no-interaction # ensure the root package is installed #---------------------------------------------- # run test suite @@ -123,7 +122,8 @@ jobs: env: OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }} OPENAI_BASE_URL: 'https://generativelanguage.googleapis.com/v1beta/' - run: + run: | + poetry install --no-interaction # ensure the root package is installed poetry run pytest --cov-report=xml --cov=scaledp tests/ #---------------------------------------------- From 17168bce4101f9213006913e70867f6f412d0262 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 17:07:18 +0200 Subject: [PATCH 12/13] Fixed tests --- tests/models/detectors/test_craft_text_detector.py | 10 ++++++---- .../models/detectors/test_dbnet_onnx_text_detector.py | 4 ++-- 2 files changed, 8 insertions(+), 6 deletions(-) diff --git a/tests/models/detectors/test_craft_text_detector.py b/tests/models/detectors/test_craft_text_detector.py index 8b7c9c8..46972b4 100644 --- a/tests/models/detectors/test_craft_text_detector.py +++ b/tests/models/detectors/test_craft_text_detector.py @@ -1,5 +1,6 @@ import tempfile +import pytest from pyspark.ml import PipelineModel from scaledp import ( @@ -11,7 +12,7 @@ from scaledp.models.detectors.CraftTextDetector import CraftTextDetector -def test_craft_detector(image_rotated_df): +def test_craft_detector(image_df): detector = CraftTextDetector( device=Device.CPU, keepInputData=True, @@ -42,7 +43,7 @@ def test_craft_detector(image_rotated_df): ) # Transform the image dataframe through the OCR stage pipeline = PipelineModel(stages=[detector, ocr, draw]) - result = pipeline.transform(image_rotated_df) + result = pipeline.transform(image_df) data = result.collect() @@ -61,7 +62,8 @@ def test_craft_detector(image_rotated_df): print("file://" + temp.name) -def test_craft_detector_pdf(pdf_df_extra): +@pytest.skip() +def test_craft_detector_pdf(image_pdf_df): pdf_data_to_image = PdfDataToImage(inputCol="content", outputCol="image") detector = CraftTextDetector( device=Device.CPU, @@ -92,7 +94,7 @@ def test_craft_detector_pdf(pdf_df_extra): ) # Transform the image dataframe through the OCR stage pipeline = PipelineModel(stages=[pdf_data_to_image, detector, ocr, draw]) - result = pipeline.transform(pdf_df_extra) + result = pipeline.transform(image_pdf_df) data = result.collect() diff --git a/tests/models/detectors/test_dbnet_onnx_text_detector.py b/tests/models/detectors/test_dbnet_onnx_text_detector.py index e33e6e1..9ea91e5 100644 --- a/tests/models/detectors/test_dbnet_onnx_text_detector.py +++ b/tests/models/detectors/test_dbnet_onnx_text_detector.py @@ -10,7 +10,7 @@ from scaledp.models.detectors.DBNetOnnxDetector import DBNetOnnxDetector -def test_dbnet_detector(image_rotated_df): +def test_dbnet_detector(image_df): detector = DBNetOnnxDetector( model="StabRise/text_detection_dbnet_ml_v0.1", @@ -40,7 +40,7 @@ def test_dbnet_detector(image_rotated_df): ) # Transform the image dataframe through the OCR stage pipeline = PipelineModel(stages=[detector, ocr, draw]) - result = pipeline.transform(image_rotated_df) + result = pipeline.transform(image_df) data = result.collect() From 36a62d78424984cba29ce8da28a7a8eed6135e33 Mon Sep 17 00:00:00 2001 From: mykola Date: Fri, 15 Aug 2025 17:11:05 +0200 Subject: [PATCH 13/13] Fixed tests --- tests/models/detectors/test_craft_text_detector.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/tests/models/detectors/test_craft_text_detector.py b/tests/models/detectors/test_craft_text_detector.py index 46972b4..7344ec0 100644 --- a/tests/models/detectors/test_craft_text_detector.py +++ b/tests/models/detectors/test_craft_text_detector.py @@ -1,6 +1,5 @@ import tempfile -import pytest from pyspark.ml import PipelineModel from scaledp import ( @@ -62,7 +61,6 @@ def test_craft_detector(image_df): print("file://" + temp.name) -@pytest.skip() def test_craft_detector_pdf(image_pdf_df): pdf_data_to_image = PdfDataToImage(inputCol="content", outputCol="image") detector = CraftTextDetector(