udata 10.5.1.dev36025__py2.py3-none-any.whl → 10.5.1.dev36034__py2.py3-none-any.whl

udata/core/dataset/recommendations.py

@@ -0,0 +1,208 @@
+import json
+import logging
+from importlib.resources import files
+
+import jsonschema
+import mongoengine
+import requests
+from flask import current_app
+
+from udata.commands import error, success
+from udata.models import Dataset, Reuse
+from udata.tasks import job
+from udata.uris import validate
+
+log = logging.getLogger(__name__)
+
+
+def recommendations_clean():
+    nb_datasets = Dataset.objects.filter(
+        **{
+            "extras__recommendations__exists": True,
+        }
+    ).update(
+        **{
+            "unset__extras__recommendations": True,
+            "unset__extras__recommendations-reuses": True,
+            "unset__extras__recommendations:sources": True,
+        }
+    )
+    success(f"Removed recommendations from {nb_datasets} dataset(s)")
+
+
+schema_path = files("udata").joinpath("schemas", "recommendations.json")
+
+
+def get_recommendations_data(url):
+    response = requests.get(url, timeout=10)
+    response.raise_for_status()
+    data = response.json()
+
+    with schema_path.open() as f:
+        schema = json.load(f)
+    jsonschema.validate(instance=data, schema=schema)
+
+    return data
+
+
+def get_unique_recommendations(recos):
+    """
+    This function returns a list of unique recos, based on the `id` key.
+    The first unique element found is kept, following ones are ignored.
+    Thus you should order the list accordingly before applying this function.
+    """
+    ids_seen = set()
+    unique_recos = []
+    for reco in recos:
+        if reco["id"] not in ids_seen:
+            ids_seen.add(reco["id"])
+            unique_recos.append(reco)
+    return unique_recos
+
+
+def get_dataset(id_or_slug):
+    obj = Dataset.objects(slug=id_or_slug).first()
+    return obj or Dataset.objects.get(id=id_or_slug)
+
+
+def get_reuse(id_or_slug):
+    obj = Reuse.objects(slug=id_or_slug).first()
+    return obj or Reuse.objects.get(id=id_or_slug)
+
+
+def process_source(source, recommendations_data):
+    for dataset in recommendations_data:
+        process_dataset(source, dataset)
+
+
+def process_dataset(source, dataset):
+    try:
+        target_dataset = get_dataset(dataset["id"])
+    except (Dataset.DoesNotExist, mongoengine.errors.ValidationError):
+        error(f"Dataset {dataset['id']} not found")
+        return
+
+    log.info(f"Processing recommendations for dataset {dataset['id']}")
+    valid_recos_datasets = []
+    valid_recos_reuses = []
+    valid_recos_externals = []
+    for reco in dataset["recommendations"]:
+        # default type is `dataset` for retrocompat
+        reco_type = reco.get("type", "dataset")
+        if reco_type == "dataset":
+            try:
+                reco_dataset_obj = get_dataset(reco["id"])
+                if reco_dataset_obj.id == target_dataset.id:
+                    continue
+                valid_recos_datasets.append(
+                    {
+                        "id": str(reco_dataset_obj.id),
+                        "score": reco["score"],
+                        "source": source,
+                    }
+                )
+            except (Dataset.DoesNotExist, mongoengine.errors.ValidationError):
+                error(f"Recommended dataset {reco['id']} not found")
+                continue
+        elif reco_type == "reuse":
+            try:
+                reuse = get_reuse(reco["id"])
+                valid_recos_reuses.append(
+                    {
+                        "id": str(reuse.id),
+                        "score": reco["score"],
+                        "source": source,
+                    }
+                )
+            except (Reuse.DoesNotExist, mongoengine.errors.ValidationError):
+                error(f"Recommended reuse {reco['id']} not found")
+                continue
+        elif reco_type == "external":
+            try:
+                external = validate(reco["id"])
+                valid_recos_externals.append(
+                    {
+                        "id": external,
+                        "score": reco["score"],
+                        "source": source,
+                        "messages": reco["messages"],
+                    }
+                )
+            except ValueError:
+                error(f"Recommended external {reco['id']} is not a valid url")
+                continue
+        else:
+            error(f"Unknown recommendation type {reco_type}")
+            continue
+
+    if len(valid_recos_datasets) or len(valid_recos_reuses) or len(valid_recos_externals):
+        new_sources = set(target_dataset.extras.get("recommendations:sources", []))
+        new_sources.add(source)
+        target_dataset.extras["recommendations:sources"] = list(new_sources)
+
+    if len(valid_recos_datasets):
+        success(
+            f"Found {len(valid_recos_datasets)} new dataset recommendations for dataset {dataset['id']}"
+        )
+
+        merged_recommendations = valid_recos_datasets + target_dataset.extras.get(
+            "recommendations", []
+        )
+        unique_recommendations = get_unique_recommendations(merged_recommendations)
+        new_recommendations = sorted(unique_recommendations, key=lambda k: k["score"], reverse=True)
+
+        target_dataset.extras["recommendations"] = new_recommendations
+
+    if len(valid_recos_reuses):
+        success(
+            f"Found {len(valid_recos_reuses)} new reuse recommendations for dataset {dataset['id']}"
+        )
+
+        merged_recommendations = valid_recos_reuses + target_dataset.extras.get(
+            "recommendations-reuses", []
+        )
+        unique_recommendations = get_unique_recommendations(merged_recommendations)
+        new_recommendations = sorted(unique_recommendations, key=lambda k: k["score"], reverse=True)
+
+        target_dataset.extras["recommendations-reuses"] = new_recommendations
+
+    if len(valid_recos_externals):
+        success(
+            f"Found {len(valid_recos_externals)} new external recommendations for dataset {dataset['id']}"
+        )
+
+        merged_recommendations = valid_recos_externals + target_dataset.extras.get(
+            "recommendations-externals", []
+        )
+        unique_recommendations = get_unique_recommendations(merged_recommendations)
+        new_recommendations = sorted(unique_recommendations, key=lambda k: k["score"], reverse=True)
+
+        target_dataset.extras["recommendations-externals"] = new_recommendations
+
+    if len(valid_recos_datasets) or len(valid_recos_reuses) or len(valid_recos_externals):
+        target_dataset.save()
+    else:
+        error(f"No recommendations found for dataset {dataset['id']}")
+
+
+def recommendations_add(sources, should_clean):
+    if should_clean:
+        log.info("Cleaning up dataset recommendations")
+        recommendations_clean()
+
+    for source, url in sources.items():
+        log.info(f"Fetching dataset recommendations from {url}, source {source}")
+        process_source(source, get_recommendations_data(url))
+
+
+@job("recommendations-clean")
+def run_recommendations_clean(self):
+    recommendations_clean()
+
+
+@job("recommendations-add")
+def run_recommendations_add(self, should_clean=True):
+    should_clean = should_clean in [True, "true", "True"]
+    sources = current_app.config.get("RECOMMENDATIONS_SOURCES", {})
+
+    recommendations_add(sources, should_clean)

udata/schemas/recommendations.json

@@ -0,0 +1,41 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "array",
+  "uniqueItems": true,
+  "items": {
+    "type": "object",
+    "properties": {
+      "id": {
+        "type": "string"
+      },
+      "type": {
+        "type": "string"
+      },
+      "recommendations": {
+        "type": "array",
+        "uniqueItems": true,
+        "items": {
+          "type": "object",
+          "properties": {
+            "id": {
+              "type": "string"
+            },
+            "score": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 100
+            }
+          },
+          "required": [
+            "id",
+            "score"
+          ]
+        }
+      }
+    },
+    "required": [
+      "id",
+      "recommendations"
+    ]
+  }
+}

udata/settings.py

@@ -516,6 +516,10 @@ class Defaults(object):
         "https://guides.data.gouv.fr/publier-des-donnees/guide-data.gouv.fr/api/reference"
     )
 
+    # Dataset recommendations
+    #########################
+    RECOMMENDATIONS_SOURCES = {}
+
     # Read Only Mode
     ####################
     # This mode can be used to mitigate a spam attack for example.

udata/tasks.py

@@ -163,6 +163,7 @@ def init_app(app):
     import udata.core.tags.tasks  # noqa
     import udata.core.activity.tasks  # noqa
     import udata.core.dataset.tasks  # noqa
+    import udata.core.dataset.recommendations  # noqa
     import udata.core.spatial.tasks  # noqa
     import udata.core.reuse.tasks  # noqa
     import udata.core.user.tasks  # noqa

udata/tests/dataset/test_dataset_recommendations.py

@@ -0,0 +1,207 @@
+import jsonschema
+import pytest
+
+from udata.core.dataset.factories import DatasetFactory
+from udata.core.dataset.recommendations import recommendations_add, recommendations_clean
+from udata.core.reuse.factories import ReuseFactory
+
+MOCK_URL = "http://reco.net"
+
+
+@pytest.fixture
+def datasets():
+    return DatasetFactory.create_batch(3)
+
+
+@pytest.fixture
+def reuses():
+    return ReuseFactory.create_batch(2)
+
+
+@pytest.fixture
+def mock_invalid_response():
+    return [{"foo": "bar"}]
+
+
+@pytest.fixture
+def mock_response(datasets, reuses):
+    ds1, ds2, ds3 = datasets
+    r1, r2 = reuses
+    return [
+        {
+            # Invalid ID, but valid reco: should not crash the command
+            "id": "1",
+            "recommendations": [{"id": str(ds1.id), "score": 50}],
+        },
+        {
+            # valid ID and recos,
+            # should process two elements w/o crashing
+            # should reorder by score and handle reco by ID and slug
+            "id": str(ds2.id),
+            "recommendations": [
+                {"id": str(ds3.id), "score": 1},
+                {"id": str(ds1.slug), "score": 2},
+                {"id": "nope", "score": 50},
+                {
+                    "id": str(r1.slug),
+                    "score": 50,
+                    "type": "reuse",
+                },
+                {
+                    "id": str(r2.id),
+                    "score": 100,
+                    "type": "reuse",
+                },
+            ],
+        },
+        {
+            # Valid ID but recommended dataset does not exist
+            "id": str(ds3.id),
+            "recommendations": [
+                {"id": "nope", "score": 50},
+            ],
+        },
+    ]
+
+
+@pytest.mark.usefixtures("clean_db")
+class DatasetRecommendationsTest:
+    def test_clean(self):
+        ds1 = DatasetFactory(
+            extras={
+                "untouched": "yep",
+                "recommendations:sources": ["foo", "bar"],
+                "recommendations": [
+                    {"id": "id1", "source": "bar", "score": 50},
+                    {"id": "id2", "source": "foo", "score": 50},
+                ],
+            }
+        )
+        ds2 = DatasetFactory(
+            extras={
+                "wait": "for it",
+                "recommendations:sources": ["baz"],
+                "recommendations": [
+                    {"id": "id2", "source": "baz", "score": 50},
+                ],
+            }
+        )
+
+        recommendations_clean()
+
+        ds1.reload()
+        ds2.reload()
+
+        assert ds1.extras == {"untouched": "yep"}
+        assert ds2.extras == {"wait": "for it"}
+
+    def test_datasets_recommendations_invalid_data_in_config(self, mock_invalid_response, rmock):
+        rmock.get(MOCK_URL, json=mock_invalid_response)
+
+        with pytest.raises(jsonschema.exceptions.ValidationError):
+            recommendations_add({"fake_source": MOCK_URL}, should_clean=False)
+
+    def test_datasets_recommendations_from_config_empty_db(self, rmock, mock_response, datasets):
+        ds1, ds2, ds3 = datasets
+        rmock.get(MOCK_URL, json=mock_response)
+
+        recommendations_add({"fake_source": MOCK_URL}, should_clean=False)
+
+        # Correct recommendations have been filled
+        ds2.reload()
+        assert ds2.extras["recommendations:sources"] == ["fake_source"]
+        assert ds2.extras["recommendations"] == [
+            {"id": str(ds1.id), "source": "fake_source", "score": 2},
+            {"id": str(ds3.id), "source": "fake_source", "score": 1},
+        ]
+
+        # Invalid recommendations have not been filled
+        ds1.reload()
+        ds3.reload()
+        assert ds1.extras == {}
+        assert ds3.extras == {}
+
+    def test_datasets_recommendations_from_config(self, rmock, mock_response, datasets, reuses):
+        ds1, ds2, ds3 = datasets
+        r1, r2 = reuses
+        ds4 = DatasetFactory()
+        rmock.get(MOCK_URL, json=mock_response)
+        ds2.extras["recommendations:sources"] = ["existing"]
+        ds2.extras["recommendations"] = [
+            {"id": str(ds4.id), "source": "existing", "score": 50},
+        ]
+        ds2.save()
+
+        recommendations_add({"fake_source": MOCK_URL}, should_clean=False)
+
+        # Recommendations have been merged, new source has been added
+        ds2.reload()
+        assert set(ds2.extras["recommendations:sources"]) == set(["existing", "fake_source"])
+        assert ds2.extras["recommendations"] == [
+            {"id": str(ds4.id), "source": "existing", "score": 50},
+            {"id": str(ds1.id), "source": "fake_source", "score": 2},
+            {"id": str(ds3.id), "source": "fake_source", "score": 1},
+        ]
+        assert ds2.extras["recommendations-reuses"] == [
+            {"id": str(r2.id), "source": "fake_source", "score": 100},
+            {"id": str(r1.id), "source": "fake_source", "score": 50},
+        ]
+
+    def test_datasets_recommendations_from_config_clean(self, mock_response, rmock, datasets):
+        ds1, ds2, ds3 = datasets
+        rmock.get(MOCK_URL, json=mock_response)
+
+        ds1.extras["recommendations:sources"] = ["fake_source"]
+        ds1.extras["recommendations"] = [{"id": str(ds2.id), "source": "fake_source", "score": 100}]
+        ds1.save()
+
+        recommendations_add({"fake_source": MOCK_URL}, should_clean=True)
+
+        # Correct recommendations have been filled
+        ds2.reload()
+        assert ds2.extras["recommendations:sources"] == ["fake_source"]
+        assert ds2.extras["recommendations"] == [
+            {"id": str(ds1.id), "source": "fake_source", "score": 2},
+            {"id": str(ds3.id), "source": "fake_source", "score": 1},
+        ]
+
+        # Previous recommendations have been cleaned
+        ds1.reload()
+        assert ds1.extras == {}
+
+    def test_datasets_recommendations_ignore_self_recommendation(self, rmock, datasets):
+        ds1, _, _ = datasets
+        rmock.get(
+            MOCK_URL,
+            json=[{"id": str(ds1.id), "recommendations": [{"id": str(ds1.id), "score": 50}]}],
+        )
+
+        recommendations_add({"fake_source": MOCK_URL}, should_clean=True)
+
+        ds1.reload()
+        assert ds1.extras == {}
+
+    def test_datasets_recommendations_ignore_duplicate_recommendation(self, rmock, datasets):
+        ds1, ds2, ds3 = datasets
+        ds1.extras = {"recommendations": [{"id": str(ds2), "source": "fake_source", "score": 1}]}
+        rmock.get(
+            MOCK_URL,
+            json=[
+                {
+                    "id": str(ds1.id),
+                    "recommendations": [
+                        {"id": str(ds2.id), "score": 4},
+                        {"id": str(ds3.id), "score": 5},
+                    ],
+                }
+            ],
+        )
+
+        recommendations_add({"fake_source": MOCK_URL}, should_clean=True)
+
+        # The new recommendation score for ds2 will be kept instead of the old one
+        ds1.reload()
+        assert ds1.extras["recommendations"] == [
+            {"id": str(ds3.id), "source": "fake_source", "score": 5},
+            {"id": str(ds2.id), "source": "fake_source", "score": 4},
+        ]

{udata-10.5.1.dev36025.dist-info → udata-10.5.1.dev36034.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: udata
-Version: 10.5.1.dev36025
+Version: 10.5.1.dev36034
 Summary: Open data portal
 Home-page: https://github.com/opendatateam/udata
 Author: Opendata Team
@@ -147,6 +147,7 @@ It is collectively taken care of by members of the
 - Expose `dataset_id` for CommunityResource in /dataset/resource/id [#3258](https://github.com/opendatateam/udata/pull/3258)
 - Add a CI job to create a release on Sentry [#3266](https://github.com/opendatateam/udata/pull/3266)
 - Sort extensions in `/api/1/datasets/extensions/` response alphabetically [#3358](https://github.com/opendatateam/udata/pull/3358)
+- Migrate recommendations tasks, [udata-recommendations](https://github.com/opendatateam/udata-recommendations/) is no longer required [#3355](https://github.com/opendatateam/udata/pull/3355)
 
 ## 10.5.0 (2025-07-02)
 

{udata-10.5.1.dev36025.dist-info → udata-10.5.1.dev36034.dist-info}/RECORD

@@ -13,10 +13,10 @@ udata/mail.py,sha256=FMGHcDAjHvk86iDUwBmVXpx3vbAb2c-j5C3BRnh9IYQ,2670
 udata/rdf.py,sha256=JmMxwq4fFBrBZQhJ6O9_nEeYUXspPzoZGTyGUD4Nyxs,18348
 udata/routing.py,sha256=E6sE1F74QyOoz5vcgEi-rNEhCegwLfOtBz5I9fWk-pM,7677
 udata/sentry.py,sha256=ekcxqUSqxfM98TtvCsPaOoX5i2l6PEcYt7kb4l3od-Q,3223
-udata/settings.py,sha256=3ufyiwtkdcrNL8zQf-oMMnn-qvbY0weW_BKvK_UekzQ,19251
+udata/settings.py,sha256=jXflM02A-l1qeGcjegRtkw56cbQUDOPzqY85OBs_dV0,19345
 udata/sitemap.py,sha256=oRRWoPI7ZsFFnUAOqGT1YuXFFKHBe8EcRnUCNHD7xjM,979
 udata/tags.py,sha256=ydq4uokd6bzdeGVSpEXASVtGvDfO2LfQs9mptvvKJCM,631
-udata/tasks.py,sha256=hLdmHV7ozeq803BRjU6X3DT3oVsZrV1beQILpbjsfQI,4978
+udata/tasks.py,sha256=Tt2Vy4fWyBkDz6cK4Mx3g2VdOLgfdDkWSNIc1QpoawQ,5032
 udata/terms.md,sha256=nFx978tUQ3vTEv6POykXaZvcQ5e_gcvmO4ZgcfbSWXo,187
 udata/tracking.py,sha256=WOcqA1RlHN8EPFuEc2kNau54mec4-pvi-wUFrMXevzg,345
 udata/uris.py,sha256=sIhlzpwFO7ftOHYgTZmR7mCoty6a1n4KC4c0Qmx3lqo,3655
@@ -109,6 +109,7 @@ udata/core/dataset/models.py,sha256=_zsUDRl4xUt2Rp1QuIw2f85FxBNx_e2XgpiXVxVQ-tE,
 udata/core/dataset/permissions.py,sha256=zXQ6kU-Ni3Pl5tDtat-ZPupug9InsNeCN7xRLc2Vcrc,1097
 udata/core/dataset/preview.py,sha256=IwCqiNTjjXbtA_SSKF52pwnzKKEz0GyYM95QNn2Dkog,2561
 udata/core/dataset/rdf.py,sha256=Bc83-JdY_2yuSUGnELVlhIQd7j1zIEX6d6CCw5RrOL4,31728
+udata/core/dataset/recommendations.py,sha256=DlGSLU8D0nW6Ds1rjBav1WxC-0VW5yOCjkO5w-ltFcI,7171
 udata/core/dataset/search.py,sha256=E7LqHBnq3sMefvmLwTpiw-Ovem2a3NJswHesRjctboE,5627
 udata/core/dataset/signals.py,sha256=WN4sV-lJlNsRkhcnhoy0SYJvCoYmK_5QFYZd1u-h4gs,161
 udata/core/dataset/tasks.py,sha256=6FzeLzJRQxzq7sBLUE8H8ZGLByix2EDOzGAsA8FteX8,10019
@@ -385,6 +386,7 @@ udata/mongo/url_field.py,sha256=UmUr9c5SxDFDpS5QsRTq2pKcCTOr1SoB4UITwNjtuaI,1345
 udata/mongo/uuid_fields.py,sha256=tuQ3zs_BnQHjaiKSIYv43jxvYtOvRLw9nP5CQ3fcMks,482
 udata/notifications/__init__.py,sha256=ZrSpV2zI9bZ0oz8tGsnA8hjDdGeU7YDdgvOLo70aohg,54
 udata/notifications/mattermost.py,sha256=v8VrDg0iEVsioSSEgukhCK0lz9Lxy8H16z_gTQry1ko,783
+udata/schemas/recommendations.json,sha256=VTQ3NbssGqYER2R9MKgjUfhVERox_PdR2Ccr1S-WAU8,778
 udata/search/__init__.py,sha256=09cBlIPoQePn20KL9AjfDwazFUmXTBiAOcUrcFtSA-o,3945
 udata/search/adapter.py,sha256=XgTUSLPEtJPsd1T2XKekOT4RYxIC2fKuwXGi_FuVnFw,2425
 udata/search/commands.py,sha256=_gKSBQGqZ06aE-6m-NqBH2xlIzezscNgpr9GyxCZLgA,5415
@@ -664,6 +666,7 @@ udata/tests/dataset/test_dataset_commands.py,sha256=zMPJG2wYwKBee2zI65kmboxf59Zq
 udata/tests/dataset/test_dataset_events.py,sha256=hlrpoOiBbnX_COUI9Pzdqlp45GZZDqu5piwupbnPiTI,3601
 udata/tests/dataset/test_dataset_model.py,sha256=av4RhOnT-52qs-WL1NCn6R2SMa_fzDcoV-06vjccsdw,33891
 udata/tests/dataset/test_dataset_rdf.py,sha256=7SorX0e0VD3hmj8C0qXA4Vb3Q3xl2qaE4ijRfeQ12PM,44537
+udata/tests/dataset/test_dataset_recommendations.py,sha256=K52HXGXi9DuUSiSRQWpqTrsFCkYbv7K3upNp0fFp5v8,7068
 udata/tests/dataset/test_dataset_tasks.py,sha256=n1W2Pg0ez02d66zQG3N93kh7dpR2yLMRDqUI6PnPaI0,3088
 udata/tests/dataset/test_resource_preview.py,sha256=fp9mSL7unhyM66GR0gwhgX3OGQ4TJt7G9xU-CjsL3HI,3908
 udata/tests/features/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -731,9 +734,9 @@ udata/translations/pt/LC_MESSAGES/udata.mo,sha256=9sCd1MUKvtVP_sOXvK-G5v4PfWkkdA
 udata/translations/pt/LC_MESSAGES/udata.po,sha256=-eJptz9s63rjkdm-3HJi_2t70pyv3-8EuXBn-B2qI_4,48419
 udata/translations/sr/LC_MESSAGES/udata.mo,sha256=qduXntHWe__KaUxJ4JwwyGG3eSgYb1auGdNax0lS49c,29169
 udata/translations/sr/LC_MESSAGES/udata.po,sha256=6QCuLMCRjgyAvu9U7i0P19ae8fm_uStfmxHLqUO9EoY,55394
-udata-10.5.1.dev36025.dist-info/LICENSE,sha256=V8j_M8nAz8PvAOZQocyRDX7keai8UJ9skgmnwqETmdY,34520
-udata-10.5.1.dev36025.dist-info/METADATA,sha256=237ROhTbnqYWcMMFPeEtkwsOS0zwENbwJOd7U8UDaO8,149464
-udata-10.5.1.dev36025.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
-udata-10.5.1.dev36025.dist-info/entry_points.txt,sha256=ETvkR4r6G1duBsh_V_fGWENQy17GTFuobi95MYBAl1A,498
-udata-10.5.1.dev36025.dist-info/top_level.txt,sha256=39OCg-VWFWOq4gCKnjKNu-s3OwFlZIu_dVH8Gl6ndHw,12
-udata-10.5.1.dev36025.dist-info/RECORD,,
+udata-10.5.1.dev36034.dist-info/LICENSE,sha256=V8j_M8nAz8PvAOZQocyRDX7keai8UJ9skgmnwqETmdY,34520
+udata-10.5.1.dev36034.dist-info/METADATA,sha256=j-kbOdj5x8dcfnIMgvlLhf-_h2pEL5-O9XNwNL0lANA,149656
+udata-10.5.1.dev36034.dist-info/WHEEL,sha256=Kh9pAotZVRFj97E15yTA4iADqXdQfIVTHcNaZTjxeGM,110
+udata-10.5.1.dev36034.dist-info/entry_points.txt,sha256=ETvkR4r6G1duBsh_V_fGWENQy17GTFuobi95MYBAl1A,498
+udata-10.5.1.dev36034.dist-info/top_level.txt,sha256=39OCg-VWFWOq4gCKnjKNu-s3OwFlZIu_dVH8Gl6ndHw,12
+udata-10.5.1.dev36034.dist-info/RECORD,,