wip

Author: MHajoha

questionpy_common/manifest.py

@@ -7,7 +7,15 @@
 from keyword import iskeyword, issoftkeyword
 from typing import Annotated, Literal, NewType
 
-from pydantic import AfterValidator, BaseModel, ByteSize, PositiveInt, StringConstraints, conset, field_validator
+from pydantic import (
+    AfterValidator,
+    BaseModel,
+    ByteSize,
+    PositiveInt,
+    StringConstraints,
+    conset,
+    field_validator,
+)
 from pydantic.fields import Field
 
 from questionpy_common import PackageNamespaceAndShortName
@@ -137,8 +145,13 @@ class PackageFile(BaseModel):
 
 
 class DistStaticQPyDependency(BaseModel):
-    dir_name: str
-    """Name (without `dist/dependencies/qpy/`) of the directory the dependency package contents reside in."""
+    namespace: Annotated[str, AfterValidator(ensure_is_valid_name)]
+    short_name: Annotated[str, AfterValidator(ensure_is_valid_name)]
+    version: Annotated[str, Field(pattern=RE_SEMVER)]
+
+    dependencies: "DistDependencies"
+    """Transitive dependencies of this dependency."""
+
     hash: str
     """Hash of the ZIP package whose contents lie in `dir_name`."""
 
@@ -158,9 +171,6 @@ class AbstractDynamicQPyDependency(BaseModel, ABC):
     version: QPyDependencyVersionSpecifier | None = None
     include_prereleases: bool = False
 
-    def to_specifier_str(self) -> str:
-        return f"@{self.namespace}/{self.short_name}{" " + str(self.version) if self.version else ""}"
-
 
 class DistDynamicQPyDependency(AbstractDynamicQPyDependency):
     locked: LockedDependencyInfo | None = None

questionpy_common/version_specifiers.py

@@ -1,4 +1,5 @@
 import re
+from collections.abc import Iterable
 from dataclasses import dataclass
 from typing import Any, Literal, Protocol, Self
 
@@ -81,7 +82,7 @@ def from_string(cls, string: str) -> Self:
             operator = next(filter(string.startswith, _OPERATORS), None)
             if operator:
                 version_string = string.removeprefix(operator).lstrip()
-                if not _SEMVER_PATTERN.match(string):
+                if not _SEMVER_PATTERN.match(version_string):
                     msg = f"Comparison version '{version_string}' of clause '{string}' does not conform to SemVer."
                     raise ValueError(msg)
 
@@ -91,7 +92,7 @@ def from_string(cls, string: str) -> Self:
                 if not _SEMVER_PATTERN.match(string):
                     msg = (
                         f"Version specifier clause '{string}' does not start with a valid operator and isn't a "
-                        f"version itself. Valid operators are {', '.join(_OPERATORS)}."
+                        f"version itself. Valid operators are {", ".join(_OPERATORS)}."
                     )
                     raise ValueError(msg)
 
@@ -103,10 +104,18 @@ def from_string(cls, string: str) -> Self:
         def __str__(self) -> str:
             return f"{self.operator} {self.operand}"
 
-    clauses: tuple[Clause, ...]
+    # Dict because we want to preserve order (for readability) but not compare order or allow dupes.
+    _clauses: dict[Clause, None]
+
+    def __init__(self, clauses: Iterable[Clause]) -> None:
+        super().__setattr__("_clauses", dict.fromkeys(clauses))
+
+    @property
+    def clauses(self) -> tuple[Clause, ...]:
+        return tuple(self._clauses)
 
     def __str__(self) -> str:
-        return ", ".join(map(str, self.clauses))
+        return ", ".join(map(str, self._clauses))
 
     @classmethod
     def from_string(cls, string: str) -> Self:
@@ -116,7 +125,7 @@ def from_string(cls, string: str) -> Self:
 
     def allows(self, version: VersionProtocol) -> bool:
         """Checks if _all_ clauses allow the given version."""
-        return all(clause.allows(version) for clause in self.clauses)
+        return all(clause.allows(version) for clause in self._clauses)
 
     @classmethod
     def __get_pydantic_core_schema__(cls, source_type: Any, handler: GetCoreSchemaHandler) -> CoreSchema:

questionpy_server/dependency_management/__init__.py

@@ -0,0 +1,64 @@
+from questionpy_common import PackageNamespaceAndShortName
+from questionpy_common.version_specifiers import QPyDependencyVersionSpecifier
+from questionpy_server.collector import PackageCollection
+from questionpy_server.dependency_management._dependency_tree import DependencySolution, resolve_dependency_tree
+from questionpy_server.dependency_management._dynamic_dependencies import (
+    AvailablePackageVersion,
+    DynamicDependencyResolver,
+    NoPackageMatchingVersionSpecError,
+)
+from questionpy_server.package import Package
+from questionpy_server.utils.manifest import ComparableManifest
+from questionpy_server.worker import PackageLocation
+
+
+class PackageCollectionAvailableVersion(AvailablePackageVersion):
+    def __init__(self, package: Package) -> None:
+        self._package = package
+
+    @property
+    def manifest(self) -> ComparableManifest:
+        return self._package.manifest
+
+    @property
+    def hash(self) -> str:
+        return self._package.hash
+
+    async def get_package_location(self) -> PackageLocation:
+        return await self._package.get_zip_package_location()
+
+
+class _PackageCollectionDependencyResolver(DynamicDependencyResolver[PackageCollectionAvailableVersion]):
+    def __init__(self, package_collection: PackageCollection) -> None:
+        self._package_collection = package_collection
+
+    async def resolve(
+        self,
+        nssn: PackageNamespaceAndShortName,
+        version_spec: QPyDependencyVersionSpecifier | None,
+        *,
+        include_prereleases: bool,
+    ) -> PackageCollectionAvailableVersion:
+        versions = self._package_collection.get_by_identifier(str(nssn))
+
+        allowed_versions = {
+            version: package
+            for version, package in versions.items()
+            if (include_prereleases or version.prerelease is None)
+            and (version_spec is None or version_spec.allows(version))
+        }
+
+        if not allowed_versions:
+            raise NoPackageMatchingVersionSpecError(
+                nssn, version_spec, tuple(versions.keys()), include_prereleases=include_prereleases
+            )
+
+        _, latest_package = max(allowed_versions.items(), key=lambda tup: tup[0])
+
+        return PackageCollectionAvailableVersion(latest_package)
+
+
+async def resolve_dependencies_for_execution(
+    package_collection: PackageCollection, package: Package
+) -> dict[PackageNamespaceAndShortName, DependencySolution]:
+    return await resolve_dependency_tree(package.manifest, _PackageCollectionDependencyResolver(package_collection))