Fix bug in packages

Author: 1ucian0

ecosystem/github.py

@@ -1,6 +1,5 @@
 """GitHub section."""
 
-from urllib.parse import ParseResult
 from re import match
 from functools import reduce
 from jsonpath import findall
@@ -12,6 +11,7 @@
     parse_github_package_ids,
     parse_github_dependants,
     parse_github_front_page,
+    URL,
 )
 
 
@@ -74,12 +74,12 @@ def to_dict(self) -> dict:
         return dictionary
 
     @classmethod
-    def from_url(cls, github_project_url: ParseResult):
+    def from_url(cls, github_project_url: URL):
         """
         Builds a GitHubSection from an url. Returns None
         if the given url is not a GitHub url
         """
-        if "github.com" not in github_project_url:
+        if "github.com" not in github_project_url.hostname:
             # github_project_url is not a GitHub URL
             return None
 

ecosystem/julia.py

@@ -13,7 +13,7 @@
 
 from .serializable import JsonSerializable
 from .error_handling import EcosystemError
-from .request import request_json, parse_url, parse_juliapackages, find_first_in_csv_gz
+from .request import request_json, URL, parse_juliapackages, find_first_in_csv_gz
 
 
 class JuliaData(JsonSerializable):
@@ -174,7 +174,7 @@ def get_juliahub_url(self):
         try:
             empty = request_json(url, parser=lambda x: {})
             if empty == {}:
-                self.juliahub_url = parse_url(url).geturl()
+                self.juliahub_url = URL(url)
         except EcosystemError:
             self.juliahub_url = None
 
@@ -198,7 +198,7 @@ def get_general_registry_url(self):
         try:
             empty = request_json(url, parser=lambda x: {})
             if empty == {}:
-                self.general_registry_url = parse_url(url).geturl()
+                self.general_registry_url = URL(url)
         except EcosystemError:
             self.general_registry_url = None
 

ecosystem/member.py

@@ -1,47 +1,66 @@
 """Submission model."""
 
 import pprint
-from dataclasses import dataclass, fields
 from uuid import uuid4
-from urllib.parse import urlparse
 
 from .julia import JuliaData
 from .serializable import JsonSerializable, parse_datetime
 from .github import GitHubData
 from .pypi import PyPIData
+from .request import URL
 
 
-@dataclass
-class Member(JsonSerializable):
+class Member(JsonSerializable):  # pylint: disable=too-many-instance-attributes
     """main Members class that represent a single entry in the Ecosystem."""
 
-    # pylint: disable=too-many-instance-attributes
-    name: str
-    url: str | None = None
-    description: str | None = None
-    licence: str | None = None
-    contact_info: str | None = None
-    affiliations: str | None = None
-    labels: list[str] | None = None
-    ibm_maintained: bool = False
-    created_at: int | None = None
-    updated_at: int | None = None
-    website: str | None = None
-    group: str | None = None
-    category: str | None = None
-    reference_paper: str | None = None
-    documentation: str | None = None
-    packages: list[str] | None = None
-    uuid: str | None = None
-    github: GitHubData | None = None
-    pypi: dict[str, PyPIData] | None = None
-    julia: JuliaData | None = None
-
-    def __post_init__(self):
+    def __init__(  # pylint: disable=too-many-arguments, too-many-locals
+        self,
+        name: str,
+        url: str | URL | None = None,
+        description: str | None = None,
+        licence: str | None = None,
+        contact_info: str | None = None,
+        affiliations: str | None = None,
+        labels: list[str] | None = None,
+        ibm_maintained: bool = False,
+        created_at: int | None = None,
+        updated_at: int | None = None,
+        website: str | None = None,
+        group: str | None = None,
+        category: str | None = None,
+        reference_paper: URL | None = None,
+        documentation: URL | None = None,
+        packages: list[URL] | None = None,
+        uuid: str | None = None,
+        github: GitHubData | None = None,
+        pypi: dict[str, PyPIData] | None = None,
+        julia: JuliaData | None = None,
+    ):
+        self.name = name
+        self.url = URL(url) if isinstance(url, str) else url
+        self.description = description
+        self.licence = licence
+        self.contact_info = contact_info
+        self.affiliations = affiliations
+        self.labels = labels
+        self.ibm_maintained = ibm_maintained
+        self.created_at = created_at
+        self.updated_at = updated_at
+        self.website = website
+        self.group = group
+        self.category = category
+        self.reference_paper = reference_paper
+        self.documentation = documentation
+        self.packages = packages
+        self.uuid = uuid
+        self.github = github
+        self.pypi = pypi
+        self.julia = julia
+
         self.__dict__.setdefault("created_at", parse_datetime("now"))
         self.__dict__.setdefault("updated_at", parse_datetime("now"))
         if self.github is None:
-            self.github = GitHubData.from_url(urlparse(self.url))
+            self.github = GitHubData.from_url(self.url)
         if self.uuid is None:
             self.uuid = str(uuid4())
         if self.labels is None:
@@ -63,7 +82,7 @@ def from_dict(cls, dictionary: dict):
 
         Return: Member
         """
-        submission_fields = [f.name for f in fields(Member)]
+        submission_fields = vars(Member)["__static_attributes__"]
         filtered_dict = {k: v for k, v in dictionary.items() if k in submission_fields}
         if "julia" in filtered_dict:
             filtered_dict["julia"] = JuliaData.from_dict(filtered_dict["julia"])
@@ -108,7 +127,7 @@ def name_id(self):
         It is used to create the TOML file name
         """
         # TODO: it is not uniq tho. Maybe add a random number at the end?  pylint: disable=W0511
-        repo_dir = self.url.strip("/").split("/")[-1]
+        repo_dir = self.url.path.rstrip("/").split("/")[-1]
         return repo_dir.lower().replace(".", "_")
 
     def update_github(self):
@@ -137,26 +156,17 @@ def from_submission(cls, submission):
         """
         Takes a submission object and creates a very basic Member object
         """
-        # TODO? licence
-
-        url = submission.source_url.geturl() if submission.source_url else None
-        website = submission.home_url.geturl() if submission.home_url else None
-        reference_paper = (
-            submission.paper_url.geturl() if submission.paper_url else None
-        )
-        documentation = submission.docs_url.geturl() if submission.docs_url else None
-
         return Member(
             name=submission.name,
-            url=url,
+            url=submission.source_url,
             description=submission.description,
             contact_info=submission.contact_info,
             labels=submission.labels,
             ibm_maintained=submission.is_ibm_maintained,
-            website=website,
+            website=submission.home_url,
             group=submission.category,
-            reference_paper=reference_paper,
-            documentation=documentation,
+            reference_paper=submission.paper_url,
+            documentation=submission.docs_url,
             github=GitHubData.from_url(submission.source_url),
             packages=submission.package_urls,
         )

ecosystem/request.py

@@ -25,7 +25,7 @@ def request_json(
     """Requests the JSON in <url> with <headers>"""
     if parser is None:
         parser = json.loads
-    url = parse_url(url)
+    url = URL(url)
     headers = headers or {
         "Accept": "application/json,"
         "application/vnd.github+json,"
@@ -41,10 +41,10 @@ def request_json(
             headers["Authorization"] = "token " + token
         headers["User-Agent"] = "github.com/Qiskit/ecosystem/"
 
-    response = requests.get(url.geturl(), headers=headers, timeout=240)
+    response = requests.get(str(url), headers=headers, timeout=240)
     if not response.ok:
         raise EcosystemError(
-            f"Bad response {url.geturl()}: {response.reason} ({response.status_code})"
+            f"Bad response {str(url)}: {response.reason} ({response.status_code})"
         )
     if content_handler:
         content = content_handler(response.content)
@@ -53,24 +53,54 @@ def request_json(
     return parser(content)
 
 
-def parse_url(original_url: str):
-    """Normalizes and parses a URL"""
-    if "_No response_" in original_url:
-        raise EcosystemError(
-            f"{original_url} does not look like a URL", logger_level=lambda x: x
+class URL:
+    """Wraps URLs"""
+
+    def __init__(self, original_url: str):
+        self.original_url = original_url
+        self._parse_result = None
+        self.logger = True
+
+    def parse_url(self):
+        """Normalizes and parses a URL"""
+        logger_level = None if self.logger else lambda x: x
+        if "_No response_" in self.original_url:
+            raise EcosystemError(
+                f"{self.original_url} does not look like a URL",
+                logger_level=logger_level,
+            )
+
+        url = urlparse(self.original_url)
+        scheme = "https"
+        if url.netloc:
+            netloc, path = url.hostname, url.path
+        else:
+            url_path_parts = url.path.split("/")
+            netloc = url_path_parts[0]
+            path = "/".join(url_path_parts[1:])
+        self._parse_result = urlparse(
+            urlunparse((scheme, netloc.lower(), path, url.params, url.query, ""))
         )
 
-    url = urlparse(original_url)
-    scheme = "https"
-    if url.netloc:
-        netloc, path = url.hostname, url.path
-    else:
-        url_path_parts = url.path.split("/")
-        netloc = url_path_parts[0]
-        path = "/".join(url_path_parts[1:])
-    return urlparse(
-        urlunparse((scheme, netloc.lower(), path, url.params, url.query, ""))
-    )
+    @property
+    def hostname(self):
+        """ Hostname part of the URL """
+        if self._parse_result is None:
+            self.parse_url()
+        return self._parse_result.hostname
+
+    @property
+    def path(self):
+        """ Path part of the URL """
+        if self._parse_result is None:
+            self.parse_url()
+        return self._parse_result.path
+
+    def __eq__(self, other):
+        return str(self) == str(other)
+
+    def __str__(self):
+        return self._parse_result.geturl() if self._parse_result else self.original_url
 
 
 def parse_github_front_page(html_text):

ecosystem/resources/members/qiskit_jl.toml

@@ -28,4 +28,6 @@ version = "0.3.0"
 license = "Apache-2.0"
 owner = "Qiskit"
 release_date = 2025-11-01
+juliahub_url = "<ecosystem.request.URL object at 0x10a53b470>"
+general_registry_url = "<ecosystem.request.URL object at 0x10a5384d0>"
 uuid = "91d9a17d-f964-4b6c-a3c4-2f4cfdea2c95"

ecosystem/resources/members/qiskitopt_jl.toml

@@ -31,5 +31,7 @@ version = "0.3.0"
 license = "MIT"
 owner = "psrenergy"
 release_date = 2024-05-01
+juliahub_url = "<ecosystem.request.URL object at 0x10a7550d0>"
+general_registry_url = "<ecosystem.request.URL object at 0x10a2f1250>"
 uuid = "81b20daf-e62b-4502-a0d1-aa084de80e33"
 estimated_unique_users = "20"

ecosystem/serializable.py

@@ -3,6 +3,8 @@
 from abc import ABC
 from datetime import datetime
 
+from ecosystem.request import URL
+
 
 class JsonSerializable(ABC):
     """Classes that can be serialized as json."""
@@ -24,7 +26,7 @@ def from_dict(cls, dictionary: dict):
         """
         return cls(**dictionary)
 
-    def to_dict(self) -> dict:
+    def to_dict(self) -> dict:  # pylint: disable=too-many-branches
         """Converts Object to dict."""
         result = {}
         for key, val in self.__dict__.items():
@@ -35,6 +37,8 @@ def to_dict(self) -> dict:
                 for item in val:
                     if isinstance(item, JsonSerializable):
                         element.append(item.to_dict())
+                    if isinstance(item, URL):
+                        element.append(str(item))
                     else:
                         element.append(item)
             elif isinstance(val, dict):
@@ -47,6 +51,8 @@ def to_dict(self) -> dict:
                     continue
             elif isinstance(val, JsonSerializable):
                 element = val.to_dict()
+            elif isinstance(val, URL):
+                element = str(val)
             else:
                 element = val
             result[key] = element

ecosystem/submission.py

@@ -6,7 +6,7 @@
 import yaml
 
 from .error_handling import EcosystemError
-from .request import parse_url
+from .request import URL
 
 
 @dataclass
@@ -100,14 +100,14 @@ def _parse_section(section: str, label_to_id: dict[str, str]):
             content = raw_content[0].startswith("- [x]")
         elif field_id.endswith("_url"):
             try:
-                content = parse_url(raw_content[0]) if raw_content else None
+                content = URL(raw_content[0]) if raw_content else None
             except EcosystemError:
                 content = None
         elif field_id.endswith("_urls"):
             content = []
             for url in raw_content:
                 try:
-                    content.append(parse_url(url))
+                    content.append(URL(url))
                 except EcosystemError:
                     pass
         else:

tests/daos/test_dao.py

@@ -38,7 +38,7 @@ def test_repository_insert_and_delete(self):
 
         # insert entry
         dao.write(main_repo)
-        fetched_repo = dao.get_by_url(main_repo.url)
+        fetched_repo = dao.get_by_url(str(main_repo.url))
         self.assertEqual(main_repo, fetched_repo)
 
         # delete entry

tests/test_cli.py

@@ -71,6 +71,12 @@ def test_add_member_from_issue(self):
             "reference_paper": "https://arxiv.org/abs/5555.22222",
             "github": {"owner": "somebody", "repo": "banana-compiler"},
             "group": "circuit manipulation",
+            "packages": [
+                "https://pypi.org/project/banana-compiler",
+                "https://pypi.org/project/banana-compiler-hpc",
+                "https://crates.io/crates/rusty-banana-compiler",
+                "https://marketplace.visualstudio.com/items?itemName=banana-code-assistance",
+            ],
         }
         self.assertEqual(len(retrieved_repos), 1)
         retrieved = list(retrieved_repos)[0].to_dict()