datago 2026.1.2__cp312-cp312-manylinux_2_31_x86_64.whl

README.md

@@ -0,0 +1,319 @@
+# datago
+
+[![Rust](https://github.com/Photoroom/datago/actions/workflows/rust.yml/badge.svg)](https://github.com/Photoroom/datago/actions/workflows/rust.yml)
+[![Rust-py](https://github.com/Photoroom/datago/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/Photoroom/datago/actions/workflows/ci-cd.yml)
+
+A Rust-written data loader which can be used as a python module. Handles several data sources, from local files to webdataset or a VectorDB focused http stack [soon-to-be open sourced](https://github.com/Photoroom/dataroom). Focused on image data at the moment, could also easily be more generic.
+
+Datago handles, outside of the Python GIL
+
+- per sample IO
+- deserialization (jpg and png decompression)
+- some optional vision processing (aligning different image payloads)
+- optional serialization
+
+Samples are exposed in the Python scope as python native objects, using PIL and Numpy base types. Speed will be network dependent, but GB/s is typical. Depending on the front ends, datago can be rank and world-size aware, in which case the samples are dispatched depending on the samples hash.
+
+![Datago organization](assets/447175851-2277afcb-8abf-4d17-b2db-dae27c6056d0.png)
+
+<details> <summary><strong>Use it</strong></summary>
+
+You can simply install datago with `[uv] pip install datago`
+
+## Use the package from Python
+Please note that in all the of the following cases, you can directly get an IterableDataset (torch compatible) with the following code snippet
+
+```python
+from dataset import DatagoIterDataset
+client_config = {} # See below for examples
+datago_dataset = DatagoIterDataset(client_config, return_python_types=True)
+```
+
+`return_python_types` enforces that images will be of the PIL.Image sort for instance, being an external binary module should be transparent.
+
+<details> <summary><strong>Dataroom</strong></summary>
+
+```python
+from datago import DatagoClient, initialize_logging
+import os
+import json
+
+# Respects RUST_LOG=INFO env var for setting log level
+# If omitted the logger will be initialized when the client starts.
+initialize_logging()
+
+config = {
+    "source_config": {
+        "sources": os.environ.get("DATAROOM_TEST_SOURCE", ""),
+        "page_size": 500,
+        "rank": 0,
+        "world_size": 1,
+    },
+    "limit": 200,
+    "samples_buffer_size": 32,
+}
+
+client = DatagoClient(json.dumps(config))
+
+for _ in range(10):
+    sample = client.get_sample()
+```
+
+Please note that the image buffers will be passed around as raw pointers, see below (we provide python utils to convert to PIL types).
+
+</details><details> <summary><strong>Local files</strong></summary>
+
+To test datago while serving local files (jpg, png, ..), code would look like the following.
+**Note that datago serving files with a lot of concurrent threads means that, even if random_sampling is not set,
+there will be some randomness in the sample ordering.**
+
+```python
+from datago import DatagoClient, initialize_logging
+import os
+import json
+
+# Can also set the log level directly instead of using RUST_LOG env var
+initialize_logging(log_level="warn")
+
+config = {
+    "source_type": "file",
+    "source_config": {
+        "root_path": "myPath",
+        "random_sampling": False, # True if used directly for training
+        "rank": 0, # Optional, distributed workloads are possible
+        "world_size": 1,
+    },
+    "limit": 200,
+    "samples_buffer_size": 32,
+}
+
+client = DatagoClient(json.dumps(config))
+
+for _ in range(10):
+    sample = client.get_sample()
+```
+
+</details><details> <summary><strong>[experimental] Webdataset</strong></summary>
+
+Please note that this implementation is very new, and probably has significant limitations still. It has not yet been tested at scale.
+Please also note that you can find a better example in /python/benchmark_webdataset.py, which will show how to convert everything to more pythonic types (PIL images).
+
+```python
+from datago import DatagoClient, initialize_logging
+import os
+import json
+
+# Can also set the log level directly instead of using RUST_LOG env var
+initialize_logging(log_level="warn")
+
+# URL of the test bucket
+bucket = "https://storage.googleapis.com/webdataset/fake-imagenet"
+dataset = "/imagenet-train-{000000..001281}.tar"
+url = bucket + dataset
+
+client_config = {
+    "source_type": "webdataset",
+    "source_config": {
+        "url": url,
+        "random_sampling": False,
+        "concurrent_downloads": 8, # The number of TarballSamples which should be handled concurrently
+        "rank": 0,
+        "world_size": 1,
+    },
+    "prefetch_buffer_size": 128,
+    "samples_buffer_size": 64,
+    "limit": 1_000_000, # Dummy example, max number of samples you would like to serve
+}
+
+client = DatagoClient(json.dumps(client_config))
+
+for _ in range(10):
+    sample = client.get_sample()
+```
+
+</details>
+
+## Process images on the fly
+
+Datago can also process images on the fly, for instance to align different image payloads. This is done by adding an `image_config` to the configuration. The following example shows how to align different image payloads.
+
+Processing can be very CPU heavy, but it will be distributed over all CPU cores wihout requiring multiple python processes. I.e., you can keep a single python process using `get_sample()` on the client and still saturate all CPU cores.
+
+There are three main processing topics that you can choose from:
+
+- crop the images to within an aspect ratio bucket (which is very handy for all Transformer / patch based architectures)
+- resize the images (setting here will be related to the square aspect ratio bucket, other buckets will differ of course)
+- pre-encode the images to a specific format (jpg, png, ...)
+
+```python
+   config = {
+    "source_type": "file",
+    "source_config": {
+        "root_path": "myPath",
+        "random_sampling": False, # True if used directly for training
+    },
+    # Optional pre-processing of the images, placing them in an aspect ratio bucket to preserve as much as possible of the original content
+    "image_config": {
+        "crop_and_resize": True, # False to turn it off, or just omit this part of the config
+        "default_image_size": 1024,
+        "downsampling_ratio": 32,
+        "min_aspect_ratio": 0.5,
+        "max_aspect_ratio": 2.0,
+        "pre_encode_images": False,
+    },
+    "limit": 200,
+    "samples_buffer_size": 32,
+}
+```
+
+## Match the raw exported buffers with typical python types
+
+See helper functions provided in `raw_types.py`, should be self explanatory. Check python benchmarks for examples. As mentioned above, we also provide a wrapper so that you get a `dataset` directly.
+
+## Logging
+
+We are using the [log](https://docs.rs/log/latest/log/) crate with [env_logger](https://docs.rs/env_logger/latest/env_logger/).
+You can set the log level using the RUST_LOG environment variable. E.g. `RUST_LOG=INFO`.
+
+When using the library from Python, `env_logger` will be initialized automatically when creating a `DatagoClient`. There is also a `initialize_logging` function in the `datago` module, which if called before using a client, allows to customize the log level. This only works if RUST_LOG is not set.
+
+## Env variables
+
+There are a couple of env variables which will change the behavior of the library, for settings which felt too low level to be exposed in the config.
+
+- `DATAGO_MAX_TASKS`: refers to the number of threads which will be used to load the samples. Defaults to a multiple of the CPU cores.
+- `RUST_LOG`: see above, will change the level of logging for the whole library, could be useful for debugging or to report an issue here.
+- `DATAGO_MAX_RETRIES`: number of retries for a failed sample load, defaults to 3.
+
+</details><details> <summary><strong>Build it</strong></summary>
+
+## Preamble
+
+Just install the rust toolchain via rustup
+
+## [Apple Silicon MacOS only]
+
+If you are using an Apple Silicon Mac OS machine, create a `.cargo/config` file and paste the following:
+
+``` cfg
+[target.x86_64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
+```
+
+## Build a benchmark CLI
+
+`Cargo run --release --  -h` to get all the information, should be fairly straightforward
+
+## Run the rust test suite
+
+From the datago folder
+
+```bash
+cargo test
+```
+
+## Generate the python package binaries manually
+
+Build a wheel useable locally
+
+```bash
+maturin build -i python3.11 --release --target "x86_64-unknown-linux-gnu"
+```
+
+Build a wheel which can be uploaded to pypi or related
+
+- either use a manylinux docker image
+
+- or cross compile using zip
+
+```bash
+maturin build -i python3.11 --release --target "x86_64-unknown-linux-gnu" --manylinux 2014 --zig
+```
+
+then you can `pip install` from `target/wheels`
+
+## Update the pypi release (maintainers)
+
+Create a new tag and a new release in this repo, a new package will be pushed automatically.
+
+</details>
+
+<details> <summary><strong>Benchmarks</strong></summary>
+As usual, benchmarks are a tricky game, and you shouldn't read too much into the following plots but do your own tests. Some python benchmark examples are provided in the [python](./python/) folder.
+
+In general, Datago will be impactful if you want to load a lot of images very fast, but if you consume them as you go at a more leisury pace then it's not really needed. The more CPU work there is with the images and the higher quality they are, the more Datago will shine.
+
+## From disk: ImageNet
+
+The following benchmarks are using ImageNet 1k, which is very low resolution and thus kind of a worst case scenario. Data is served from cache (i.e. the OS cache) and the images are not pre-processed. In this case the receiving python process is typically the bottleneck, and caps at around 3000 images per second.
+
+### AMD Zen3 laptop - IN1k - disk - no processing
+![AMD Zen3 laptop & M2 SSD](assets/zen3_ssd.png)
+
+### AMD EPYC 9454 - IN1k - disk - no processing
+![AMD EPYC 9454](assets/epyc_vast.png)
+
+## Webdataset: FakeIN
+
+This benchmark is using low resolution images. It's accessed through the webdataset front end, datago is compared with the popular python webdataset library. Note that datago will start streaming the images faster here (almost instantly !), which emphasizes throughput differences depending on how long you test it for.
+
+Of note is also that this can be bottlenecked by your external bandwidth to the remote storage where WDS is hosted, in which case both solution would yield comparable numbers.
+
+### AMD Zen3 laptop - webdataset - no processing
+![AMD EPYC 9454](assets/zen3_wds_fakein.png)
+
+
+## Webdataset: PD12M
+
+This benchmark is using high resolution images. It's accessed through the webdataset front end, datago is compared with the popular python webdataset library. Note that datago will start streaming the images faster here (almost instantly !), which emphasizes throughput differences depending on how long you test it for.
+
+Of note is also that this can be bottlenecked by your external bandwidth to the remote storage where WDS is hosted, in which case both solution would yield comparable numbers.
+
+### AMD Zen3 laptop - webdataset - no processing
+![AMD Zen3 laptop](assets/zen3_wds_pd12m.png)
+
+
+### AMD EPYC 9454 - pd12m - webdataset - no processing
+![AMD EPYC 9454](assets/epyc_wds_pd12m.png)
+
+
+### AMD Zen3 laptop - webdataset - processing
+Adding image processing (crop and resize to Transformer compatible size buckets) to the equation changes the picture, as the work spread becomes more important. If you're training a diffusion model or an image encoder from a diverse set of images, this is likely to be the most realistic micro-benchmark.
+
+![AMD Zen3 laptop](assets/zen3_wds_pd12m_processing.png)
+
+</details>
+
+
+## License
+
+MIT License
+
+Copyright (c) 2025 Photoroom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

datago/__init__.py

@@ -0,0 +1,5 @@
+from .datago import *
+
+__doc__ = datago.__doc__
+if hasattr(datago, "__all__"):
+    __all__ = datago.__all__

datago-2026.1.2.dist-info/METADATA

@@ -0,0 +1,337 @@
+Metadata-Version: 2.4
+Name: datago
+Version: 2026.1.2
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+License-File: LICENSE
+Summary: A high performance dataloader for Python, written in Rust
+Author: Benjamin Lefaudeux, Roman Frigg
+Author-email: Photoroom <team@photoroom.com>
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/photoroom/datago
+Project-URL: Issues, https://github.com/photoroom/datago/issues
+
+# datago
+
+[![Rust](https://github.com/Photoroom/datago/actions/workflows/rust.yml/badge.svg)](https://github.com/Photoroom/datago/actions/workflows/rust.yml)
+[![Rust-py](https://github.com/Photoroom/datago/actions/workflows/ci-cd.yml/badge.svg)](https://github.com/Photoroom/datago/actions/workflows/ci-cd.yml)
+
+A Rust-written data loader which can be used as a python module. Handles several data sources, from local files to webdataset or a VectorDB focused http stack [soon-to-be open sourced](https://github.com/Photoroom/dataroom). Focused on image data at the moment, could also easily be more generic.
+
+Datago handles, outside of the Python GIL
+
+- per sample IO
+- deserialization (jpg and png decompression)
+- some optional vision processing (aligning different image payloads)
+- optional serialization
+
+Samples are exposed in the Python scope as python native objects, using PIL and Numpy base types. Speed will be network dependent, but GB/s is typical. Depending on the front ends, datago can be rank and world-size aware, in which case the samples are dispatched depending on the samples hash.
+
+![Datago organization](assets/447175851-2277afcb-8abf-4d17-b2db-dae27c6056d0.png)
+
+<details> <summary><strong>Use it</strong></summary>
+
+You can simply install datago with `[uv] pip install datago`
+
+## Use the package from Python
+Please note that in all the of the following cases, you can directly get an IterableDataset (torch compatible) with the following code snippet
+
+```python
+from dataset import DatagoIterDataset
+client_config = {} # See below for examples
+datago_dataset = DatagoIterDataset(client_config, return_python_types=True)
+```
+
+`return_python_types` enforces that images will be of the PIL.Image sort for instance, being an external binary module should be transparent.
+
+<details> <summary><strong>Dataroom</strong></summary>
+
+```python
+from datago import DatagoClient, initialize_logging
+import os
+import json
+
+# Respects RUST_LOG=INFO env var for setting log level
+# If omitted the logger will be initialized when the client starts.
+initialize_logging()
+
+config = {
+    "source_config": {
+        "sources": os.environ.get("DATAROOM_TEST_SOURCE", ""),
+        "page_size": 500,
+        "rank": 0,
+        "world_size": 1,
+    },
+    "limit": 200,
+    "samples_buffer_size": 32,
+}
+
+client = DatagoClient(json.dumps(config))
+
+for _ in range(10):
+    sample = client.get_sample()
+```
+
+Please note that the image buffers will be passed around as raw pointers, see below (we provide python utils to convert to PIL types).
+
+</details><details> <summary><strong>Local files</strong></summary>
+
+To test datago while serving local files (jpg, png, ..), code would look like the following.
+**Note that datago serving files with a lot of concurrent threads means that, even if random_sampling is not set,
+there will be some randomness in the sample ordering.**
+
+```python
+from datago import DatagoClient, initialize_logging
+import os
+import json
+
+# Can also set the log level directly instead of using RUST_LOG env var
+initialize_logging(log_level="warn")
+
+config = {
+    "source_type": "file",
+    "source_config": {
+        "root_path": "myPath",
+        "random_sampling": False, # True if used directly for training
+        "rank": 0, # Optional, distributed workloads are possible
+        "world_size": 1,
+    },
+    "limit": 200,
+    "samples_buffer_size": 32,
+}
+
+client = DatagoClient(json.dumps(config))
+
+for _ in range(10):
+    sample = client.get_sample()
+```
+
+</details><details> <summary><strong>[experimental] Webdataset</strong></summary>
+
+Please note that this implementation is very new, and probably has significant limitations still. It has not yet been tested at scale.
+Please also note that you can find a better example in /python/benchmark_webdataset.py, which will show how to convert everything to more pythonic types (PIL images).
+
+```python
+from datago import DatagoClient, initialize_logging
+import os
+import json
+
+# Can also set the log level directly instead of using RUST_LOG env var
+initialize_logging(log_level="warn")
+
+# URL of the test bucket
+bucket = "https://storage.googleapis.com/webdataset/fake-imagenet"
+dataset = "/imagenet-train-{000000..001281}.tar"
+url = bucket + dataset
+
+client_config = {
+    "source_type": "webdataset",
+    "source_config": {
+        "url": url,
+        "random_sampling": False,
+        "concurrent_downloads": 8, # The number of TarballSamples which should be handled concurrently
+        "rank": 0,
+        "world_size": 1,
+    },
+    "prefetch_buffer_size": 128,
+    "samples_buffer_size": 64,
+    "limit": 1_000_000, # Dummy example, max number of samples you would like to serve
+}
+
+client = DatagoClient(json.dumps(client_config))
+
+for _ in range(10):
+    sample = client.get_sample()
+```
+
+</details>
+
+## Process images on the fly
+
+Datago can also process images on the fly, for instance to align different image payloads. This is done by adding an `image_config` to the configuration. The following example shows how to align different image payloads.
+
+Processing can be very CPU heavy, but it will be distributed over all CPU cores wihout requiring multiple python processes. I.e., you can keep a single python process using `get_sample()` on the client and still saturate all CPU cores.
+
+There are three main processing topics that you can choose from:
+
+- crop the images to within an aspect ratio bucket (which is very handy for all Transformer / patch based architectures)
+- resize the images (setting here will be related to the square aspect ratio bucket, other buckets will differ of course)
+- pre-encode the images to a specific format (jpg, png, ...)
+
+```python
+   config = {
+    "source_type": "file",
+    "source_config": {
+        "root_path": "myPath",
+        "random_sampling": False, # True if used directly for training
+    },
+    # Optional pre-processing of the images, placing them in an aspect ratio bucket to preserve as much as possible of the original content
+    "image_config": {
+        "crop_and_resize": True, # False to turn it off, or just omit this part of the config
+        "default_image_size": 1024,
+        "downsampling_ratio": 32,
+        "min_aspect_ratio": 0.5,
+        "max_aspect_ratio": 2.0,
+        "pre_encode_images": False,
+    },
+    "limit": 200,
+    "samples_buffer_size": 32,
+}
+```
+
+## Match the raw exported buffers with typical python types
+
+See helper functions provided in `raw_types.py`, should be self explanatory. Check python benchmarks for examples. As mentioned above, we also provide a wrapper so that you get a `dataset` directly.
+
+## Logging
+
+We are using the [log](https://docs.rs/log/latest/log/) crate with [env_logger](https://docs.rs/env_logger/latest/env_logger/).
+You can set the log level using the RUST_LOG environment variable. E.g. `RUST_LOG=INFO`.
+
+When using the library from Python, `env_logger` will be initialized automatically when creating a `DatagoClient`. There is also a `initialize_logging` function in the `datago` module, which if called before using a client, allows to customize the log level. This only works if RUST_LOG is not set.
+
+## Env variables
+
+There are a couple of env variables which will change the behavior of the library, for settings which felt too low level to be exposed in the config.
+
+- `DATAGO_MAX_TASKS`: refers to the number of threads which will be used to load the samples. Defaults to a multiple of the CPU cores.
+- `RUST_LOG`: see above, will change the level of logging for the whole library, could be useful for debugging or to report an issue here.
+- `DATAGO_MAX_RETRIES`: number of retries for a failed sample load, defaults to 3.
+
+</details><details> <summary><strong>Build it</strong></summary>
+
+## Preamble
+
+Just install the rust toolchain via rustup
+
+## [Apple Silicon MacOS only]
+
+If you are using an Apple Silicon Mac OS machine, create a `.cargo/config` file and paste the following:
+
+``` cfg
+[target.x86_64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
+
+[target.aarch64-apple-darwin]
+rustflags = [
+  "-C", "link-arg=-undefined",
+  "-C", "link-arg=dynamic_lookup",
+]
+```
+
+## Build a benchmark CLI
+
+`Cargo run --release --  -h` to get all the information, should be fairly straightforward
+
+## Run the rust test suite
+
+From the datago folder
+
+```bash
+cargo test
+```
+
+## Generate the python package binaries manually
+
+Build a wheel useable locally
+
+```bash
+maturin build -i python3.11 --release --target "x86_64-unknown-linux-gnu"
+```
+
+Build a wheel which can be uploaded to pypi or related
+
+- either use a manylinux docker image
+
+- or cross compile using zip
+
+```bash
+maturin build -i python3.11 --release --target "x86_64-unknown-linux-gnu" --manylinux 2014 --zig
+```
+
+then you can `pip install` from `target/wheels`
+
+## Update the pypi release (maintainers)
+
+Create a new tag and a new release in this repo, a new package will be pushed automatically.
+
+</details>
+
+<details> <summary><strong>Benchmarks</strong></summary>
+As usual, benchmarks are a tricky game, and you shouldn't read too much into the following plots but do your own tests. Some python benchmark examples are provided in the [python](./python/) folder.
+
+In general, Datago will be impactful if you want to load a lot of images very fast, but if you consume them as you go at a more leisury pace then it's not really needed. The more CPU work there is with the images and the higher quality they are, the more Datago will shine.
+
+## From disk: ImageNet
+
+The following benchmarks are using ImageNet 1k, which is very low resolution and thus kind of a worst case scenario. Data is served from cache (i.e. the OS cache) and the images are not pre-processed. In this case the receiving python process is typically the bottleneck, and caps at around 3000 images per second.
+
+### AMD Zen3 laptop - IN1k - disk - no processing
+![AMD Zen3 laptop & M2 SSD](assets/zen3_ssd.png)
+
+### AMD EPYC 9454 - IN1k - disk - no processing
+![AMD EPYC 9454](assets/epyc_vast.png)
+
+## Webdataset: FakeIN
+
+This benchmark is using low resolution images. It's accessed through the webdataset front end, datago is compared with the popular python webdataset library. Note that datago will start streaming the images faster here (almost instantly !), which emphasizes throughput differences depending on how long you test it for.
+
+Of note is also that this can be bottlenecked by your external bandwidth to the remote storage where WDS is hosted, in which case both solution would yield comparable numbers.
+
+### AMD Zen3 laptop - webdataset - no processing
+![AMD EPYC 9454](assets/zen3_wds_fakein.png)
+
+
+## Webdataset: PD12M
+
+This benchmark is using high resolution images. It's accessed through the webdataset front end, datago is compared with the popular python webdataset library. Note that datago will start streaming the images faster here (almost instantly !), which emphasizes throughput differences depending on how long you test it for.
+
+Of note is also that this can be bottlenecked by your external bandwidth to the remote storage where WDS is hosted, in which case both solution would yield comparable numbers.
+
+### AMD Zen3 laptop - webdataset - no processing
+![AMD Zen3 laptop](assets/zen3_wds_pd12m.png)
+
+
+### AMD EPYC 9454 - pd12m - webdataset - no processing
+![AMD EPYC 9454](assets/epyc_wds_pd12m.png)
+
+
+### AMD Zen3 laptop - webdataset - processing
+Adding image processing (crop and resize to Transformer compatible size buckets) to the equation changes the picture, as the work spread becomes more important. If you're training a diffusion model or an image encoder from a diverse set of images, this is likely to be the most realistic micro-benchmark.
+
+![AMD Zen3 laptop](assets/zen3_wds_pd12m_processing.png)
+
+</details>
+
+
+## License
+
+MIT License
+
+Copyright (c) 2025 Photoroom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

datago-2026.1.2.dist-info/RECORD

@@ -0,0 +1,7 @@
+README.md,sha256=XwJ68dy_mOJNETAX0ZT4BRY0At9f2feXXlYrysdoBZo,12828
+datago/__init__.py,sha256=kNnGM4GPRHPbxtWqYjr-57Td4rOTtl3kLaKExPLuE7g,107
+datago/datago.cpython-312-x86_64-linux-gnu.so,sha256=sp3KumG2zHx78hQ09cJFBSuymMOPBe_R2-VBzfDksyw,13580424
+datago-2026.1.2.dist-info/METADATA,sha256=7sgPUJ-oKGjIajO_YERXdCGBaZFMDjoJ183-zbF6YvY,13552
+datago-2026.1.2.dist-info/WHEEL,sha256=ULB5_LOdT1XIeV6m04GmfiOw1ifWnpWoDWBprrVKHrs,109
+datago-2026.1.2.dist-info/licenses/LICENSE,sha256=5BkY8hpbSq1ldBOzHL1XHW4h-ognKi_lZa2zeWailV8,1066
+datago-2026.1.2.dist-info/RECORD,,

datago-2026.1.2.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: maturin (1.11.2)
+Root-Is-Purelib: false
+Tag: cp312-cp312-manylinux_2_31_x86_64

datago-2026.1.2.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Photoroom
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.