diff --git a/swh/graphql/errors/errors.py b/swh/graphql/errors/errors.py index 9a59444..6a587f5 100644 --- a/swh/graphql/errors/errors.py +++ b/swh/graphql/errors/errors.py @@ -1,3 +1,2 @@ class ObjectNotFoundError(Exception): - """ - """ + """ """ diff --git a/swh/graphql/resolvers/person.py b/swh/graphql/resolvers/person.py index c378389..ca55b85 100644 --- a/swh/graphql/resolvers/person.py +++ b/swh/graphql/resolvers/person.py @@ -1,6 +1,5 @@ from .base_node import BaseNode class PersonNode(BaseNode): - """ - """ + """ """ diff --git a/swh/graphql/resolvers/resolvers.py b/swh/graphql/resolvers/resolvers.py index 7153333..7f90546 100644 --- a/swh/graphql/resolvers/resolvers.py +++ b/swh/graphql/resolvers/resolvers.py @@ -1,126 +1,123 @@ """ High level resolvers Any schema attribute can be resolved by any of the following ways and in the following priority order - In this module using an annotation (eg: @visitstatus.field("snapshot")) - As a property in the Node object (eg: resolvers.visit.OriginVisitNode.id) - As an attribute/item in the object/dict returned by the backend (eg: Origin.url) """ from ariadne import ObjectType, UnionType from .resolver_factory import get_connection_resolver, get_node_resolver query = ObjectType("Query") origin = ObjectType("Origin") visit = ObjectType("Visit") visit_status = ObjectType("VisitStatus") snapshot = ObjectType("Snapshot") snapshot_branch = ObjectType("Branch") branch_target = UnionType("BranchTarget") # Node resolvers # A node resolver can return a node object or a data structure @query.field("origin") def origin_resolver(obj, info, **kw): - """ - """ + """ """ resolver = get_node_resolver("origin") return resolver(obj, info, **kw)() @query.field("visit") def visit_resolver(obj, info, **kw): - """ - """ + """ """ resolver = get_node_resolver("visit") return resolver(obj, info, **kw)() @query.field("snapshot") def snapshot_resolver(obj, info, **kw): - """ - """ + """ """ resolver = get_node_resolver("snapshot") return resolver(obj, info, **kw)() @visit_status.field("snapshot") def visit_snapshot_resolver(obj, info, **kw): resolver = get_node_resolver("visit-snapshot") return resolver(obj, info, **kw)() @snapshot_branch.field("target") def snapshot_branch_target_resolver(obj, info, **kw): """ Snapshot branch target can be a revision or a release """ resolver_type = f"branch-{obj.type}" resolver = get_node_resolver(resolver_type) return resolver(obj, info, **kw)() @query.field("revision") def revision_resolver(obj, info, **kw): resolver = get_node_resolver("revision") return resolver(obj, info, **kw)() @query.field("release") def release_resolver(obj, info, **kw): resolver = get_node_resolver("release") return resolver(obj, info, **kw)() @query.field("directory") def directory_resolver(obj, info, **kw): resolver = get_node_resolver("directory") return resolver(obj, info, **kw)() @query.field("content") def content_resolver(obj, info, **kw): resolver = get_node_resolver("content") return resolver(obj, info, **kw)() # Connection resolvers # A connection resolver will return a sub class of BaseConnection @query.field("origins") def origins_resolver(obj, info, **kw): resolver = get_connection_resolver("origins") return resolver(obj, info, **kw)() @origin.field("visits") def visits_resolver(obj, info, **kw): resolver = get_connection_resolver("origin-visits") return resolver(obj, info, **kw)() @visit.field("status") def visitstatus_resolver(obj, info, **kw): resolver = get_connection_resolver("visit-status") return resolver(obj, info, **kw)() @snapshot.field("branches") def snapshot_branches_resolver(obj, info, **kw): resolver = get_connection_resolver("snapshot-branches") return resolver(obj, info, **kw)() # Any other type of resolver @branch_target.type_resolver def union_resolver(obj, *_): """ Generic resolver for all the union types """ return obj.is_type_of() diff --git a/swh/graphql/resolvers/revision.py b/swh/graphql/resolvers/revision.py index 9580531..026d1be 100644 --- a/swh/graphql/resolvers/revision.py +++ b/swh/graphql/resolvers/revision.py @@ -1,98 +1,97 @@ from swh.graphql.backends import archive from swh.graphql.utils import utils from .base_node import BaseNode from .directory import RevisionDirectoryNode class BaseRevisionNode(BaseNode): def _get_revision_by_id(self, revision_id): # FIXME, make this call async return (archive.Archive().get_revision(revision_id) or None)[0] @property def author(self): # return a PersoneNode object return self._node.author @property def committer(self): # return a PersoneNode object return self._node.committer @property def parentIds(self): # To support the schema naming convention return self._node.parents # @paginatedlist @property def parents(self): """ Return a list of parent revisions """ # FIXME, change this to a paginated list # Storage fix or use paginatedlist decorator # change to node factory return [ ParentRevisionNode(obj=self, info=self.info, sha1=revision_id) for revision_id in self.parentIds ] @property def directoryId(self): # To support the schema naming convention - """ - """ + """ """ return self._node.directory @property def directory(self): """ Return the """ # FIXME change to node factory return RevisionDirectoryNode(obj=self, info=self.info, sha1=self.directoryId) def is_type_of(self): """ is_type_of is required only when requesting from a connection This is for ariadne to return the correct type in schema """ return "Revision" class RevisionNode(BaseRevisionNode): """ When the revision is requested directly (not from a connection) with an id """ def _get_node_data(self): revision_id = utils.str_to_swid(self.kwargs.get("Sha1")) return self._get_revision_by_id(revision_id) class ParentRevisionNode(BaseRevisionNode): """ When a parent revision is requested """ def _get_node_data(self): revision_id = self.kwargs.get("sha1") return self._get_revision_by_id(revision_id) class BranchRevisionNode(BaseRevisionNode): """ When the revision is requested from a snapshot branch self.obj is a branch object self.obj.target is the revision id """ def _get_node_data(self): """ self.obj.target is the Revision id """ return self._get_revision_by_id(self.obj.target) diff --git a/swh/graphql/resolvers/snapshot.py b/swh/graphql/resolvers/snapshot.py index 578477c..38a253b 100644 --- a/swh/graphql/resolvers/snapshot.py +++ b/swh/graphql/resolvers/snapshot.py @@ -1,43 +1,42 @@ from swh.graphql.backends import archive from swh.graphql.utils import utils from .base_node import BaseNode class BaseSnapshotNode(BaseNode): def _get_snapshot_by_id(self, snapshot_id): return archive.Archive().get_snapshot(snapshot_id) class SnapshotNode(BaseSnapshotNode): """ For directly accessing a snapshot with swhid """ def _get_node_data(self): - """ - """ + """ """ # FIXME, use methods from SWH core snapshot_id = utils.str_to_swid(self.kwargs.get("Sha1")) return self._get_snapshot_by_id(snapshot_id) class VisitSnapshotNode(BaseSnapshotNode): """ For accessing a snapshot from a visitstatus type """ def _get_node_data(self): """ self.obj is visitstatus here snapshot swhid is avaialbe in the parent (self.obj) """ return self._get_snapshot_by_id(self.obj.snapshot) # class SnapshotConnection(BaseConnection): # """ # To get all the snapshots under an origin # """ # _node_class = SnapshotNode diff --git a/swh/graphql/resolvers/snapshot_branch.py b/swh/graphql/resolvers/snapshot_branch.py index 9067013..63edd8e 100644 --- a/swh/graphql/resolvers/snapshot_branch.py +++ b/swh/graphql/resolvers/snapshot_branch.py @@ -1,52 +1,51 @@ # from swh.graphql.backends import archive # from swh.graphql.utils import utils from swh.storage.interface import PagedResult from .base_connection import BaseConnection from .base_node import BaseNode class SnapshotBranchNode(BaseNode): - """ - """ + """ """ class SnapshotBranchConnection(BaseConnection): _node_class = SnapshotBranchNode def _get_paged_result(self): return self._get_from_parent_node() # FIXME making extra query to the storage # This is not really needed as we have the data # in the self.obj itself # Mocking paged data # result = archive.Archive().get_snapshot_branches( # utils.str_to_swid(self.obj.id.hex()), # after=self._get_after_arg(), # first=self._get_first_arg()) # return PagedResult(results=result['branches'], # next_page_token=result['next_branch'].hex()) def _get_from_parent_node(self): """ Branches are avaialble in the snapshot object itself Not making an extra query """ results = [ { "name": key, "type": value["target_type"], "id": "temp-id", "target": value["target"], } for (key, value) in self.obj.branches.items() ][: self._get_first_arg()] # FIXME, this pagination is broken, fix it with swh-storage # Mocking PagedResult obj return PagedResult(results=results, next_page_token=self.obj.next_branch) def total_count(self): # FIXME, this can be implemented with current swh.storage API return None diff --git a/swh/graphql/resolvers/visit_status.py b/swh/graphql/resolvers/visit_status.py index f0a8ff8..470be8b 100644 --- a/swh/graphql/resolvers/visit_status.py +++ b/swh/graphql/resolvers/visit_status.py @@ -1,32 +1,31 @@ from swh.graphql.backends import archive from swh.graphql.utils import utils from .base_connection import BaseConnection from .base_node import BaseNode class VisitStatusNode(BaseNode): def _get_node_data(self): - """ - """ + """ """ @property def id(self): # FIXME, find logic to generate an id return utils.encode("dummy-id") class VisitStatusConnection(BaseConnection): """ self.obj is the visit object """ _node_class = VisitStatusNode def _get_paged_result(self): return archive.Archive().get_visit_status( self.obj.origin, self.obj.visit, after=self._get_after_arg(), first=self._get_first_arg(), )