Do not add package_uid to for_package if it exists

    * Add test for extracted pypi wheel
    * Update test expectations

Signed-off-by: Jono Yang <jyang@nexb.com>

Author: JonoYang

src/packagedcode/models.py

@@ -805,9 +805,12 @@ def compute_normalized_license(declared_license, expression_symbols=None):
 
 def add_to_package(package_uid, resource, codebase):
     """
-    Append `package_uid` to `resource.for_packages`, if the attribute exists.
+    Append `package_uid` to `resource.for_packages`, if the attribute exists and
+    `package_uid` is not already in `resource.for_packages`.
     """
     if hasattr(resource, 'for_packages') and isinstance(resource.for_packages, list):
+        if package_uid in resource.for_packages:
+            return
         resource.for_packages.append(package_uid)
         resource.save(codebase)
 

tests/packagedcode/data/debian/debian-container-layer.tar.xz.get-installed-expected.json

@@ -359,58 +359,6 @@
           }
         ],
         "for_packages": [
-          "pkg:deb/libndp0@1.4-2ubuntu0.16.04.1?architecture=amd64&uuid=fixed-uid-done-for-testing-5642512d1758",
-          "pkg:deb/libndp0@1.4-2ubuntu0.16.04.1?architecture=amd64&uuid=fixed-uid-done-for-testing-5642512d1758"
-        ],
-        "scan_errors": []
-      },
-      {
-        "path": "debian-container-layer.tar.xz/usr/share/doc/libndp0/copyright",
-        "type": "file",
-        "package_data": [
-          {
-            "type": "deb",
-            "namespace": null,
-            "name": "libndp0",
-            "version": null,
-            "qualifiers": {},
-            "subpath": null,
-            "primary_language": null,
-            "description": null,
-            "release_date": null,
-            "parties": [],
-            "keywords": [],
-            "homepage_url": null,
-            "download_url": null,
-            "size": null,
-            "sha1": null,
-            "md5": null,
-            "sha256": null,
-            "sha512": null,
-            "bug_tracking_url": null,
-            "code_view_url": null,
-            "vcs_url": null,
-            "copyright": "Copyright 2013 Jiri Pirko <jiri@resnulli.us>\nCopyright 2014 Andrew Ayer <agwa@andrewayer.name>",
-            "license_expression": "(lgpl-2.1-plus AND lgpl-2.1-plus AND lgpl-2.1) AND (lgpl-2.1-plus AND lgpl-2.1-plus AND lgpl-2.1)",
-            "declared_license": [
-              "LGPL-2.1+",
-              "LGPL-2.1+",
-              "LGPL-2.1+"
-            ],
-            "notice_text": null,
-            "source_packages": [],
-            "file_references": [],
-            "extra_data": {},
-            "dependencies": [],
-            "repository_homepage_url": null,
-            "repository_download_url": null,
-            "api_data_url": null,
-            "datasource_id": "debian_copyright_in_package",
-            "purl": "pkg:deb/libndp0"
-          }
-        ],
-        "for_packages": [
-          "pkg:deb/libndp0@1.4-2ubuntu0.16.04.1?architecture=amd64&uuid=fixed-uid-done-for-testing-5642512d1758",
           "pkg:deb/libndp0@1.4-2ubuntu0.16.04.1?architecture=amd64&uuid=fixed-uid-done-for-testing-5642512d1758"
         ],
         "scan_errors": []

tests/packagedcode/data/pypi/unpacked_wheel/daglib_wheel_extracted-expected.json

@@ -0,0 +1,19 @@
+Copyright (c) 2022 Michael Harris
+
+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.

tests/packagedcode/data/pypi/unpacked_wheel/daglib_wheel_extracted/daglib-0.6.0.dist-info/LICENSE

@@ -0,0 +1,168 @@
+Metadata-Version: 2.1
+Name: daglib
+Version: 0.6.0
+Summary: Lightweight DAG composition framework
+Home-page: https://github.com/mharrisb1/daglib
+License: MIT
+Author: Michael Harris
+Author-email: mharris@luabase.com
+Requires-Python: >=3.10,<4.0
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Provides-Extra: graphviz
+Provides-Extra: ipycytoscape
+Requires-Dist: dask[delayed] (>=2022.7.1,<2023.0.0)
+Requires-Dist: graphviz (>=0.20,<0.21); extra == "graphviz"
+Requires-Dist: ipycytoscape (>=1.3.3,<2.0.0); extra == "ipycytoscape"
+Requires-Dist: networkx (>=2.8.5,<3.0.0)
+Project-URL: Documentation, https://mharrisb1.github.io/daglib/
+Project-URL: Repository, https://github.com/mharrisb1/daglib
+Description-Content-Type: text/markdown
+
+# ⚗️ Daglib - Lightweight DAG composition framework
+
+[![PyPI version](https://badge.fury.io/py/daglib.svg)](https://badge.fury.io/py/daglib)
+[![PyPI - Downloads](https://img.shields.io/pypi/dm/daglib)](https://pypi.org/project/daglib/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/daglib.svg)](https://pypi.org/project/daglib/)
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/ambv/black)
+[![Checked with mypy](https://img.shields.io/badge/mypy-checked-blue.svg)](https://mypy.readthedocs.io/en/stable/)
+[![pre-commit](https://img.shields.io/badge/pre--commit-enabled-brightgreen?logo=pre-commit&logoColor=white)](https://github.com/pre-commit/pre-commit)
+
+Daglib is a lightweight, embeddable parallel task execution library used for turning pure Python functions into executable task graphs.
+
+# Installation
+
+Core
+
+```shell
+pip install daglib
+```
+
+With visualizations enabled
+
+```shell
+pip install 'daglib[graphviz]'  # static visualizations
+# or
+pip install 'daglib[ipycytoscape]'  # interactive visulizations
+```
+
+# Create your first DAG
+
+
+```python
+import daglib
+
+dag = daglib.Dag()
+
+
+@dag.task()
+def task_1a():
+    return "Hello"
+
+
+@dag.task()
+def task_1b():
+    return "world!"
+
+
+@dag.task()
+def task_2(task_1a, task_1b):
+    return f"{task_1a}, {task_1b}"
+
+
+dag.run()
+```
+
+
+
+
+    'Hello, world!'
+
+
+
+# Beyond the "Hello, world!" example
+
+For a more involved example, we will create a small pipeline that takes data from four source tables and creates a single reporting table. The data is driver-level information from the current 2022 Formula 1 season. The output will be a pivot table for team-level metrics.
+
+## Source Tables
+
+1. Team - Team of driver
+2. Points - Current total Driver's World Championship points for each driver for the season
+3. Wins - Current number of wins for each driver for the season
+4. Podiums - Current number of times the driver finished in the top 3 for the season
+
+
+```python
+import pandas as pd
+import daglib
+
+# Ignore. Used to render the DataFrame correctly in the README
+pd.set_option("display.notebook_repr_html", False)
+
+dag = daglib.Dag()
+
+
+@dag.task()
+def team():
+    return pd.DataFrame(dict(
+        driver=["Max", "Charles", "Lewis", "Sergio", "Carlos", "George"],
+        team=["Red Bull", "Ferrari", "Mercedes", "Red Bull", "Ferrari", "Mercedes"],
+    )).set_index("driver")
+
+
+@dag.task()
+def points():
+    return pd.DataFrame(dict(
+        driver=["Max", "Charles", "Lewis", "Sergio", "Carlos", "George"],
+        points=[258, 178, 146, 173, 156, 158]
+    )).set_index("driver")
+
+
+@dag.task()
+def wins():
+    return pd.DataFrame(dict(
+        driver=["Max", "Charles", "Lewis", "Sergio", "Carlos", "George"],
+        wins=[8, 3, 0, 1, 1, 0]
+    )).set_index("driver")
+
+
+@dag.task()
+def podiums():
+    return pd.DataFrame(dict(
+        driver=["Max", "Charles", "Lewis", "Sergio", "Carlos", "George"],
+        podiums=[10, 5, 6, 6, 6, 5]
+    )).set_index("driver")
+
+
+@dag.task()
+def driver_metrics(team, points, wins, podiums):
+    return team.join(points).join(wins).join(podiums)
+
+
+@dag.task()
+def team_metrics(driver_metrics):
+    return driver_metrics.groupby("team").sum().sort_values("points", ascending=False)
+
+
+dag.run()
+```
+
+
+
+
+              points  wins  podiums
+    team
+    Red Bull     431     9       16
+    Ferrari      334     4       11
+    Mercedes     304     0       11
+
+
+
+## Task Graph Visualization
+
+The DAG we created above will create a task graph that looks like the following
+
+![task graph](https://storage.googleapis.com/daglib-image-assets/example-dag.png)
+

tests/packagedcode/data/pypi/unpacked_wheel/daglib_wheel_extracted/daglib-0.6.0.dist-info/METADATA

@@ -0,0 +1,7 @@
+daglib/__init__.py,sha256=zZChUiwWHPYMiYHWpak0jHMt01MrLaKjtQjdHjqKZ3M,72
+daglib/dag.py,sha256=29Vm4DiQocV6tSVu9pZJUZPmqc-Q7EujHU7xD4qPJaY,2761
+daglib/task.py,sha256=ouWf979IU6OKgpj6j4301B2wo46wkTKjkkFr2Jp-xj0,4531
+daglib-0.6.0.dist-info/LICENSE,sha256=-TUoNdFfc-LQG650e2zjOGojvi-3PAbfeZ-6l6W8mKI,1058
+daglib-0.6.0.dist-info/WHEEL,sha256=DA86_h4QwwzGeRoz62o1svYt5kGEXpoUTuTtwzoTb30,83
+daglib-0.6.0.dist-info/METADATA,sha256=8BukUSgAbtR0jO-L0ef2a9S1-G8aZX4_Pk_uOk0yjPI,4493
+daglib-0.6.0.dist-info/RECORD,,

tests/packagedcode/data/pypi/unpacked_wheel/daglib_wheel_extracted/daglib-0.6.0.dist-info/RECORD

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry 1.0.8
+Root-Is-Purelib: true
+Tag: py3-none-any

tests/packagedcode/data/pypi/unpacked_wheel/daglib_wheel_extracted/daglib-0.6.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+from .dag import Dag
+from .task import Task, Arg
+
+__version__ = "0.5.0"

tests/packagedcode/data/pypi/unpacked_wheel/daglib_wheel_extracted/daglib/__init__.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+import uuid
+from typing import Any, Callable
+
+import networkx as nx
+from dask.delayed import Delayed
+from dask.optimization import cull
+
+from daglib.task import Task, Arg
+
+
+class Dag:
+    def __init__(self, name: str = uuid.uuid4().hex, description: str = "") -> None:
+        self.name = "".join(x for x in name if x.isalnum()).lower()
+        self.description = description
+        self._tasks_by_name: dict[str, Task] = {}
+        self.nxg = nx.DiGraph()
+
+    @property
+    def run_id(self) -> str:
+        return f"run_{uuid.uuid1().hex}"
+
+    def add_subdag(self, other: Dag) -> None:
+        self._tasks_by_name |= other._tasks_by_name
+
+    def register_task(self, task: Task) -> Task:
+        self._tasks_by_name[task.name] = task
+        return task
+
+    def register_task_from_function(
+        self, fn: Callable[..., Any], name: str | None = None, args: list[Arg] | None = None
+    ) -> Callable[..., Any]:
+        task = Task.from_function(fn, name=name, args=args)
+        self.register_task(task)
+        return fn
+
+    def task(self) -> Any:
+        def register(fn: Callable[..., Any]) -> Callable[..., Any]:
+            return self.register_task_from_function(fn)
+
+        return register
+
+    def _build_graph(self) -> None:
+        edges = [(self._tasks_by_name[arg.name], task) for task in self._tasks_by_name.values() for arg in task.args]
+        self.nxg = nx.DiGraph(edges)
+
+    @property
+    def _dsk(self) -> dict[str, tuple[Any, ...]]:
+        return {task.name: tuple([task.fn, *[arg.name for arg in task.args]]) for task in nx.topological_sort(self.nxg)}
+
+    @property
+    def _keys(self) -> list[str]:
+        return [task.name for task in self.nxg.nodes if not list(self.nxg.successors(task))]
+
+    def materialize(self, to_step: str | Callable[..., Any] | None = None, optimize: bool = False) -> Delayed:
+        self._build_graph()
+        keys: list[str] | str = self._keys
+        if len(keys) == 1:
+            keys = keys[0]
+        dsk = self._dsk
+        if to_step:
+            if callable(to_step):
+                keys = to_step.__name__
+            optimize = True
+        if optimize:
+            layers, _ = cull(dsk, keys)
+        return Delayed(keys, dsk)
+
+    def run(self, to_step: str | Callable[..., Any] | None = None, optimize: bool = False) -> Any:
+        return self.materialize(to_step, optimize).compute()
+
+    # noinspection PyShadowingBuiltins
+    def visualize(
+        self,
+        to_step: str | Callable[..., Any] | None = None,
+        optimize: bool = False,
+        filename: str | None = None,
+        format: str | None = None,
+        **kwargs: Any,
+    ) -> Any:
+        return self.materialize(to_step, optimize).visualize(filename, format, **kwargs)