datamaestro 1.1.0__py3-none-any.whl → 1.2.1__py3-none-any.whl

datamaestro/annotations/agreement.py

@@ -1,9 +1,15 @@
-import logging
-from datamaestro.definitions import DatasetAnnotation, AbstractDataset, hook
+from typing import Optional
+from datamaestro.definitions import AbstractDataset, hook
 
 
 @hook("pre-use")
-def useragreement(definition: AbstractDataset, message, id=None):
+def useragreement(definition: AbstractDataset, message: str, id: Optional[str] = None):
+    """Asks for a user-agreement
+
+    :param definition: The dataset for which the agreement is asked
+    :param message: The agreement text
+    :param id: The ID of the agreement (default to the dataset ID)
+    """
     # Skip agreement when testing
     if definition.context.running_test:
         return

datamaestro/context.py

@@ -110,19 +110,20 @@ class Context:
         if repositoryid is None:
             return None
 
-        l = [
+        entry_points = [
             x
             for x in pkg_resources.iter_entry_points(
                 "datamaestro.repositories", repositoryid
             )
         ]
-        if not l:
+        if not entry_points:
             raise Exception("No datasets repository named %s", repositoryid)
-        if len(l) > 1:
+        if len(entry_points) > 1:
             raise Exception(
-                "Too many datasets repository named %s (%d)" % (repositoryid, len(l))
+                "Too many datasets repository named %s (%d)"
+                % (repositoryid, len(entry_points))
             )
-        return l[0].load()(self)
+        return entry_points[0].load()(self)
 
     @property
     def running_test(self):
@@ -175,7 +176,6 @@ class Context:
         if dlpath.is_file():
             logging.debug("Using cached file %s for %s", dlpath, url)
         else:
-
             logging.info("Downloading %s", url)
             tmppath = dlpath.with_suffix(".tmp")
 
@@ -188,7 +188,7 @@ class Context:
 
     def ask(self, question: str, options: Dict[str, str]):
         """Ask a question to the user"""
-        print(question)
+        print(question)  # noqa: T201
         answer = None
         while answer not in options:
             answer = input().strip().lower()
@@ -268,6 +268,7 @@ class Datasets(Iterable["AbstractDataset"]):
 
     def __iter__(self) -> Iterable["AbstractDataset"]:
         from .definitions import DatasetWrapper
+        from datamaestro.data import Base
 
         # Iterates over defined symbols
         for key, value in self.module.__dict__.items():
@@ -276,10 +277,18 @@ class Datasets(Iterable["AbstractDataset"]):
                 # Ensure it comes from the module
                 if self.module.__name__ == value.t.__module__:
                     yield value
+            elif (
+                inspect.isclass(value)
+                and issubclass(value, Base)
+                and hasattr(value, "__dataset__")
+            ):
+                if self.module.__name__ == value.__module__:
+                    yield value.__dataset__
 
 
 class Repository:
-    """A repository regroup a set of datasets and their corresponding specific handlers (downloading, filtering, etc.)"""
+    """A repository regroup a set of datasets and their corresponding specific
+    handlers (downloading, filtering, etc.)"""
 
     def __init__(self, context: Context):
         """Initialize a new repository
@@ -315,7 +324,7 @@ class Repository:
         try:
             return get_distribution(cls.__module__).version
         except DistributionNotFound:
-            __version__ = None
+            return None
 
     def __repr__(self):
         return "Repository(%s)" % self.basedir

datamaestro/data/ml.py

@@ -1,19 +1,27 @@
 """Machine learning generic data formats"""
-from typing import List
+from typing import Generic, TypeVar, Optional
 from pathlib import Path
-from . import Base, argument
+from experimaestro import Param, Meta, argument
+from . import Base
 
+Train = TypeVar("Train", bound=Base)
+Validation = TypeVar("Validation", bound=Base)
+Test = TypeVar("Test", bound=Base)
 
-@argument("train", type=Base, help="The training dataset")
-@argument("validation", type=Base, help="The validation dataset", required=False)
-@argument("test", type=Base, help="The test dataset", required=False)
-class Supervised(Base):
-    pass
+
+class Supervised(Base, Generic[Train, Validation, Test]):
+    train: Param[Base]
+    """The training dataset"""
+
+    validation: Param[Optional[Base]] = None
+    """The validation dataset (optional)"""
+
+    test: Param[Optional[Base]] = None
+    """The training optional"""
 
 
-@argument("path", type=Path)
 @argument("classes")
 class FolderBased(Base):
     """Classification dataset where folders give the basis"""
 
-    pass
+    path: Meta[Path]

datamaestro/definitions.py

@@ -127,6 +127,13 @@ class AbstractDataset(AbstractData):
     """
 
     name: Optional[str] = None
+    """The name of the dataset"""
+
+    url: Optional[str] = None
+    """The URL of the dataset"""
+
+    doi: Optional[str] = None
+    """The DOI of this dataset"""
 
     def __init__(self, repository: Optional["Repository"]):
         super().__init__()
@@ -136,6 +143,7 @@ class AbstractDataset(AbstractData):
 
         # Associated resources
         self.resources: Dict[str, "Download"] = {}
+        self.ordered_resources = []
 
         # Hooks
         # pre-use: before returning the dataset object
@@ -194,13 +202,15 @@ class AbstractDataset(AbstractData):
     def download(self, force=False):
         """Download all the necessary resources"""
         success = True
-        for key, resource in self.resources.items():
+        logging.info("Materializing %d resources", len(self.ordered_resources))
+        for resource in self.ordered_resources:
             try:
                 resource.download(force)
             except Exception:
-                logging.error("Could not download resource %s", key)
+                logging.error("Could not download resource %s", resource)
                 traceback.print_exc()
                 success = False
+                break
         return success
 
     @staticmethod
@@ -249,6 +259,7 @@ class DatasetWrapper(AbstractDataset):
     def __init__(self, annotation, t: type):
         self.t = t
         self.base = annotation.base
+        self.config = None
         assert self.base is not None, f"Could not set the Config type for {t}"
 
         repository, components = DataDefinition.repository_relpath(t)
@@ -256,6 +267,7 @@ class DatasetWrapper(AbstractDataset):
 
         # Set some variables
         self.url = annotation.url
+        self.doi = annotation.doi
 
         # Builds the ID:
         # Removes module_name.config prefix
@@ -322,7 +334,18 @@ class DatasetWrapper(AbstractDataset):
         """Returns a pointer to a potential attribute"""
         return FutureAttr(self, [key])
 
+    def download(self, force=False):
+        if self.base is self.t:
+            self._prepare()
+        return super().download(force=force)
+
     def _prepare(self, download=False) -> "Base":
+        if self.config is not None:
+            return self.config
+
+        if self.base is self.t:
+            self.config = self.base.__create_dataset__(self)
+
         if download:
             for hook in self.hooks["pre-download"]:
                 hook(self)
@@ -332,23 +355,23 @@ class DatasetWrapper(AbstractDataset):
         for hook in self.hooks["pre-use"]:
             hook(self)
 
-        resources = {key: value.prepare() for key, value in self.resources.items()}
-        dict = self.t(**resources)
-        if dict is None:
-            name = self.t.__name__
-            filename = inspect.getfile(self.t)
-            raise Exception(
-                f"The dataset method {name} defined in "
-                f"{filename} returned a null object"
-            )
-
         # Construct the object
-        data = self.base(**dict)
+        if self.config is None:
+            resources = {key: value.prepare() for key, value in self.resources.items()}
+            dict = self.t(**resources)
+            if dict is None:
+                name = self.t.__name__
+                filename = inspect.getfile(self.t)
+                raise Exception(
+                    f"The dataset method {name} defined in "
+                    f"{filename} returned a null object"
+                )
+            self.config = self.base(**dict)
 
         # Set the ids
-        self.setDataIDs(data, self.id)
+        self.setDataIDs(self.config, self.id)
 
-        return data
+        return self.config
 
     @property
     def _path(self) -> Path:
@@ -455,7 +478,9 @@ datatasks = DataTagging(lambda d: d.tasks)
 
 
 class dataset:
-    def __init__(self, base=None, *, timestamp=None, id=None, url=None, size=None):
+    def __init__(
+        self, base=None, *, timestamp=None, id=None, url=None, size=None, doi=None
+    ):
         """Creates a new (meta)dataset
 
         Meta-datasets are not associated with any base type
@@ -473,6 +498,8 @@ class dataset:
             url {[type]} -- [description] (default: {None})
 
             size {str} -- The size (should be a parsable format)
+
+            doi {str} -- The DOI of the corresponding paper
         """
         if hasattr(base, "__datamaestro__") and isinstance(
             base.__datamaestro__, metadataset
@@ -486,18 +513,31 @@ class dataset:
         self.meta = False
         self.timestamp = timestamp
         self.size = size
+        self.doi = doi
 
     def __call__(self, t):
         try:
             if self.base is None:
-                # Get type from return annotation
-                self.base = t.__annotations__["return"]
+                from datamaestro.data import Base
+
+                if inspect.isclass(t) and issubclass(t, Base):
+                    self.base = t
+                else:
+                    # Get type from return annotation
+                    try:
+                        self.base = t.__annotations__["return"]
+                    except KeyError:
+                        logging.warning("No return annotation in %s", t)
+                        raise
             object.__getattribute__(t, "__datamaestro__")
             raise AssertionError("@data should only be called once")
         except AttributeError:
             pass
 
         dw = DatasetWrapper(self, t)
+        t.__dataset__ = dw
+        if inspect.isclass(t) and issubclass(t, Base):
+            return t
         return dw
 
 

datamaestro/download/__init__.py

@@ -1,6 +1,8 @@
+from typing import Union
 from abc import ABC, abstractmethod
 from datamaestro.definitions import AbstractDataset, DatasetAnnotation
 from datamaestro.utils import deprecated
+from attrs import define
 
 
 def initialized(method):
@@ -15,7 +17,12 @@ def initialized(method):
     return wrapper
 
 
-class Download(DatasetAnnotation, ABC):
+@define(kw_only=True)
+class SetupOptions:
+    pass
+
+
+class Resource(DatasetAnnotation, ABC):
     """
     Base class for all download handlers
     """
@@ -24,13 +31,16 @@ class Download(DatasetAnnotation, ABC):
         self.varname = varname
         # Ensures that the object is initialized
         self._post = False
+        self.definition = None
 
     def annotate(self, dataset: AbstractDataset):
+        assert self.definition is None
         # Register has a resource download
         if self.varname in dataset.resources:
             raise AssertionError("Name %s already declared as a resource", self.varname)
 
         dataset.resources[self.varname] = self
+        dataset.ordered_resources.append(self)
         self.definition = dataset
 
     @property
@@ -53,10 +63,29 @@ class Download(DatasetAnnotation, ABC):
         """Prepares the dataset"""
         ...
 
+    def setup(
+        self,
+        dataset: Union[AbstractDataset],
+        options: SetupOptions = None,
+    ):
+        """Direct way to setup the resource (no annotation)"""
+        self(dataset)
+        return self.prepare()
+
+
+# Keeps downwards compatibility
+Download = Resource
+
 
 class reference(Download):
-    def __init__(self, varname, reference):
+    def __init__(self, varname=None, reference=None):
+        """References another dataset
+
+        :param varname: The name of the variable
+        :param reference: Another dataset
+        """
         super().__init__(varname)
+        assert reference is not None, "Reference cannot be null"
         self.reference = reference
 
     def prepare(self):

datamaestro/download/wayback.py

@@ -0,0 +1,163 @@
+import logging
+import json
+from datamaestro.download import Resource
+from typing import Callable, Iterator
+from pathlib import Path
+import requests
+import random
+import re
+from requests.exceptions import HTTPError
+from tqdm.auto import tqdm
+import time
+import urllib.parse
+import uuid
+
+
+wayback_prefix = re.compile(r"^https:\/\/web\.archive\.org\/web")
+replace_pattern = re.compile(r"(web\.archive\.org\/web\/\d+)")
+
+
+def download_with_retry(url: str, max_retries: int = 10) -> requests.Response:
+    """Download a URL with exponential backoff, until max_retries is reached."""
+    retry_num = 0
+    while True:
+        try:
+            response = requests.get(url)
+            response.raise_for_status()
+            return response
+        except HTTPError as e:
+            status_code = e.response.status_code
+            if not (status_code == 429 or status_code >= 500):
+                # This is not an error we should retry on
+                raise e
+
+            if retry_num > max_retries:
+                logging.error(
+                    f"Failed to perform GET request on {url}"
+                    f"after {max_retries} retries."
+                )
+                raise e
+
+            if status_code == 429:
+                time.sleep(5 + 2**retry_num + random.randint(0, 1000) / 1000)
+            else:
+                time.sleep(2**retry_num + random.randint(0, 1000) / 1000)
+            retry_num += 1
+
+
+def download_link(link: str, timestamp: str):
+    page_id = str(uuid.uuid4())
+    url_no_header = None
+
+    try:
+        # Find the Wayback Machine link
+        if not wayback_prefix.match(link):
+            link_encoded = urllib.parse.quote(link)
+
+            available, availability_attempt = False, 0
+            # Sometimes the API returns HTTP success code 200, but archived
+            # snapshots shows page is unavailable when it actually is. Give it a
+            # total of three tries.
+            while not available and availability_attempt < 3:
+                response = download_with_retry(
+                    "http://archive.org/wayback/available?"
+                    f"url={link_encoded}&timestamp={timestamp}"
+                )
+                json_response = response.json()
+                available = "closest" in json_response["archived_snapshots"]
+                availability_attempt += 1
+
+            if not available:
+                logging.warning(
+                    f"Not available on Wayback Machine: {link}, "
+                    f"HTTP code {response.status_code}, {json_response}"
+                )
+                return {"link": link, "page_id": page_id, "available": False}
+
+            url = json_response["archived_snapshots"]["closest"]["url"]
+        else:
+            url = link
+
+        match = replace_pattern.search(url)
+        assert match
+        url_no_header = replace_pattern.sub(f"{match.group(1)}id_", url)
+
+        response = download_with_retry(url_no_header)
+        html_page = response.text
+
+        return {
+            "link": link,
+            "id": url_no_header,
+            "contents": html_page,
+        }
+
+    except HTTPError as http_err:
+        logging.warning(f"HTTP error occurred: {http_err} for {link}")
+        return {
+            "link": link,
+            "page_id": page_id,
+            "available": False,
+            "status_code": http_err.response.status_code if http_err.response else None,
+            "wayback_url": url_no_header,
+        }
+    except UnicodeDecodeError as e:
+        logging.warning(f"Unicode decode error occurred: {e} for {link}")
+        return {
+            "link": link,
+            "page_id": page_id,
+            "available": False,
+            "status_code": response.status_code,
+            "wayback_url": url_no_header,
+        }
+    except Exception as e:
+        logging.warning(f"Exception occurred: {e} for {link}")
+        return {
+            "link": link,
+            "page_id": page_id,
+            "available": False,
+            "status_code": None,
+            "wayback_url": url_no_header,
+        }
+
+
+class wayback_documents(Resource):
+    """Collect documents from wayback"""
+
+    def __init__(self, timestamp: str, urls_fn: Callable[[], Iterator[str]], name=None):
+        super().__init__(name)
+        self.timestamp = timestamp
+        self.urls_fn = urls_fn
+
+    def prepare(self):
+        return self.definition.datapath / self.varname
+
+    def download(self, force=False):
+        # Creates directory if needed
+        destination: Path = self.definition.datapath / self.varname
+        self.definition.datapath.mkdir(exist_ok=True)
+
+        # Early exit
+        done_path = destination.with_suffix(".done")
+        if done_path.is_file() and not force:
+            return True
+
+        # Reads the URLs
+        logging.info("Retrieving URLs from wayback")
+        pos = 0
+        urls = set()
+        with destination.open("at+") as fp:
+            fp.seek(0)
+            try:
+                for line in fp:
+                    pos = fp.tell()
+                    urls.add(json.loads(line)["url"])
+            except json.JSONDecodeError:
+                logging.warning(f"JSON decoding error: getting back to position {pos}")
+                fp.seek(pos)
+
+            # Get the remaining ones
+            for url in tqdm(self.urls_fn()):
+                fp.write(json.dumps(download_link(url, self.timestamp)))
+
+        # Everything is fine
+        done_path.touch()

datamaestro/record.py

@@ -129,7 +129,20 @@ class Record:
     def __str__(self):
         return (
             "{"
-            + ", ".join(f"{key}: {value}" for key, value in self.items.items())
+            + ", ".join(
+                f"{key.__module__}.{key.__qualname__}: {value}"
+                for key, value in self.items.items()
+            )
+            + "}"
+        )
+
+    def __repr__(self):
+        return (
+            "{"
+            + ", ".join(
+                f"{key.__module__}.{key.__qualname__}: {repr(value)}"
+                for key, value in self.items.items()
+            )
             + "}"
         )
 

datamaestro/version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '1.1.0'
-__version_tuple__ = version_tuple = (1, 1, 0)
+__version__ = version = '1.2.1'
+__version_tuple__ = version_tuple = (1, 2, 1)

{datamaestro-1.1.0.dist-info → datamaestro-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: datamaestro
-Version: 1.1.0
+Version: 1.2.1
 Summary: "Dataset management command line and API"
 Home-page: https://github.com/experimaestro/datamaestro
 Author: Benjamin Piwowarski

{datamaestro-1.1.0.dist-info → datamaestro-1.2.1.dist-info}/RECORD

@@ -1,25 +1,25 @@
 datamaestro/__init__.py,sha256=9M5hA6FVngduJBcjInvJWQM8n0cqapXAFPzfRLHR74c,237
 datamaestro/__main__.py,sha256=tJTf1sTWKRIatvBcHlWDIZRZodAZ2B2zkD01pD89MYk,9024
-datamaestro/context.py,sha256=imDAs9v5yR_O871cdM4e5Q0KBSHmT-j5qc83sz6npWI,13210
-datamaestro/definitions.py,sha256=ORlD3kxLvmw1EScCepzGQOHjsTiC3yvY-z_7LxKDp08,15415
-datamaestro/record.py,sha256=ZpPxECeUgF2m_oW5TSme-xUxIsBmpxMnYUUijFQ3Now,5180
+datamaestro/context.py,sha256=8U5EYEdc9xcHnZFFk4PCZttxxGsmlzRVR8rLBy2zVBw,13605
+datamaestro/definitions.py,sha256=mBoLgrbO1eHVcqMPkb4lxadNdgSsy_w355nZofvBoF8,16732
+datamaestro/record.py,sha256=m3WGsPcZ1LouQXNJOBUK3QusAIRiuy6T_oqhq09-Ckg,5504
 datamaestro/registry.py,sha256=M7QJkcWJP_cxAoqIioLQ01ou2Zg9RqGQvW0XGVspYFE,1421
 datamaestro/search.py,sha256=PMceNp5hcp0dlzs4cLb6LJT7XHrdXo58oO7oTucawbE,2887
 datamaestro/settings.py,sha256=HYSElTUYZ6DZocBb9o3ifm6WW9knRO64XJUwxGIpvwQ,1304
 datamaestro/sphinx.py,sha256=bp7x_2BFoTSwTqcVZDM8R8cWa7G2pz0Zb8GS054lLYM,6996
 datamaestro/utils.py,sha256=Y3_aqeOHW8vuifwggGWJfgONyDG1FLX7ONAnX85jENI,6511
-datamaestro/version.py,sha256=CqDGE4B1ZqZ-56mxeOFcXRTmlxrdOh4ayrjbcPjziE4,411
+datamaestro/version.py,sha256=2U0Gn26fYI3Vgj5hgkLM8I3wI6YEVdffJGllaVW-sSc,411
 datamaestro/annotations/__init__.py,sha256=jLprrxSBa5QIqc--vqycEcxU4CR9WjVNRaqR5lH0EuE,39
-datamaestro/annotations/agreement.py,sha256=IPHjXX8ld5blvSDNXGt8RfuHDgVAITN52gJZh93AY4g,723
+datamaestro/annotations/agreement.py,sha256=xEH0ddZxdJ_oG_150PoOa-WjY_OaeQja3FzMzY5IB6k,955
 datamaestro/commands/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 datamaestro/commands/mainstyle.css,sha256=EAWq6hKWjLYZ-gUrGV-z3L8LtkubD7mLoYdSIC7kLOo,465
 datamaestro/commands/site.py,sha256=nnz4tOwKcgUmsLfPcQVo2SgFIC3OShYfJ8S2N6vuzAw,14173
 datamaestro/data/__init__.py,sha256=vOedQsnYtxI2yj-M2nm32eHpIu9S_WRzfA3futlHNs4,1412
 datamaestro/data/csv.py,sha256=-UXjEbKPvhhZ9_MdYnxUsD8Zsz2t4ZFbserFuHak8pw,2515
 datamaestro/data/huggingface.py,sha256=rCMiMqVgNI9zRAgm9PYnbwb7musYryBoIP3HuJmH4sg,691
-datamaestro/data/ml.py,sha256=My1KE8t8-LeUOgcf2V_7RX-T9BkHeucyXrO9oJea36E,517
+datamaestro/data/ml.py,sha256=guh1bxi7Dl3SajJdtBFrtPh6K8eNKiMkBKmBeKGuW5U,710
 datamaestro/data/tensor.py,sha256=OVzV1krIRslui8REdl7hPFu3AXlUyDxf5yUZlbNYsz8,2001
-datamaestro/download/__init__.py,sha256=SUQqRq2bwJ86mnWQ4OfBJOKRv2sdhfmHkcoP6Yvlfq8,1870
+datamaestro/download/__init__.py,sha256=Iqz7zEzeTsBWzE_6bpurhZVtzRjyXVUwCY6MEVjJpO0,2592
 datamaestro/download/archive.py,sha256=G-2gzepknqT7Us3naMGAApGVGJMeHQIxM-tSpaa9ark,5608
 datamaestro/download/huggingface.py,sha256=LkzmZo2Z0yccqAfj7di7jDNGFrMKN9m8IM8SfexOomY,1125
 datamaestro/download/links.py,sha256=GFnq_AzI_uen7JBuGWD9qveeC9QFBWDrSnj7pOcwWwM,3352
@@ -28,6 +28,7 @@ datamaestro/download/multiple.py,sha256=Mrr0ObHM5cE1CPSHE9PKIrox3qZVgxwRyxLzNXp0
 datamaestro/download/single.py,sha256=QSEviTP9lHLh3ZGyo_KoW3ro8UvWCGNPHeZiNj-9rLA,4134
 datamaestro/download/sync.py,sha256=Z_LsXj4kbZWIYKTVJZEhfdpYiv6wXOOIyw8LahmEcqs,836
 datamaestro/download/todo.py,sha256=y3YnmWC_i-u23ce-vreIwIXZcoO-uA0HXErgJPThnco,256
+datamaestro/download/wayback.py,sha256=B9X1P9jElvd_qnUs9aX0TAO-NrNyvuHLYDAcpNq354w,5430
 datamaestro/stream/__init__.py,sha256=Angu_Yg9rNKXb8s4at-DXYcnE-OTgSMLfUEfrL6APD8,896
 datamaestro/stream/compress.py,sha256=0ViFGpJc6pdvZGUNERE-3XV8jAOTSvhJurb2t0NW2eU,260
 datamaestro/stream/lines.py,sha256=UNGcyZlZxN0Q7kw717jbhZFdDVmtfJfkJZCgK7xzF9A,1996
@@ -38,9 +39,9 @@ datamaestro/test/conftest.py,sha256=it4S5Qq1CA_U8qM0pr4m7v-1dhLj5Y49WjVg5Ee3mpM,
 datamaestro/test/test_annotations.py,sha256=kRPUmS_UAN6JSSVPUwV4OM_LEuEUHF1OcLSiYXjsKjw,246
 datamaestro/test/test_download_handlers.py,sha256=Qqm-fML1KVp6dPwAUcH6xzi_dpQIshvROzviSYCUzc0,603
 datamaestro/test/test_record.py,sha256=hNZ3uo2i5FZ0VsOHRwvLO1Z6Zce92PdipAF65UptPB8,1156
-datamaestro-1.1.0.dist-info/LICENSE,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
-datamaestro-1.1.0.dist-info/METADATA,sha256=18AaNkyFs8N5PdYqEgEwPWeeF9_q5qmUXb550bR30dY,8999
-datamaestro-1.1.0.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
-datamaestro-1.1.0.dist-info/entry_points.txt,sha256=8qMhwSRvFG2iBqtJYVD22Zd4s4c3YkODtcp0Ajw1knw,133
-datamaestro-1.1.0.dist-info/top_level.txt,sha256=XSznaMNAA8jELV7-TOqaAgDsjLzUf9G9MxL7C4helT0,12
-datamaestro-1.1.0.dist-info/RECORD,,
+datamaestro-1.2.1.dist-info/LICENSE,sha256=WJ7YI-moTFb-uVrFjnzzhGJrnL9P2iqQe8NuED3hutI,35141
+datamaestro-1.2.1.dist-info/METADATA,sha256=2_TL_ysMtfV2a84_0Uu3UQloCHCvetGZWo5tcjdhNCA,8999
+datamaestro-1.2.1.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+datamaestro-1.2.1.dist-info/entry_points.txt,sha256=8qMhwSRvFG2iBqtJYVD22Zd4s4c3YkODtcp0Ajw1knw,133
+datamaestro-1.2.1.dist-info/top_level.txt,sha256=XSznaMNAA8jELV7-TOqaAgDsjLzUf9G9MxL7C4helT0,12
+datamaestro-1.2.1.dist-info/RECORD,,

{datamaestro-1.1.0.dist-info → datamaestro-1.2.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any