| import requests |
|
|
| import fsspec |
|
|
| from ..spec import AbstractFileSystem |
| from ..utils import infer_storage_options |
| from .memory import MemoryFile |
|
|
| |
|
|
|
|
| class GithubFileSystem(AbstractFileSystem): |
| """Interface to files in github |
| |
| An instance of this class provides the files residing within a remote github |
| repository. You may specify a point in the repos history, by SHA, branch |
| or tag (default is current master). |
| |
| Given that code files tend to be small, and that github does not support |
| retrieving partial content, we always fetch whole files. |
| |
| When using fsspec.open, allows URIs of the form: |
| |
| - "github://path/file", in which case you must specify org, repo and |
| may specify sha in the extra args |
| - 'github://org:repo@/precip/catalog.yml', where the org and repo are |
| part of the URI |
| - 'github://org:repo@sha/precip/catalog.yml', where the sha is also included |
| |
| ``sha`` can be the full or abbreviated hex of the commit you want to fetch |
| from, or a branch or tag name (so long as it doesn't contain special characters |
| like "/", "?", which would have to be HTTP-encoded). |
| |
| For authorised access, you must provide username and token, which can be made |
| at https://github.com/settings/tokens |
| """ |
|
|
| url = "https://api.github.com/repos/{org}/{repo}/git/trees/{sha}" |
| rurl = "https://raw.githubusercontent.com/{org}/{repo}/{sha}/{path}" |
| protocol = "github" |
| timeout = (60, 60) |
|
|
| def __init__( |
| self, org, repo, sha=None, username=None, token=None, timeout=None, **kwargs |
| ): |
| super().__init__(**kwargs) |
| self.org = org |
| self.repo = repo |
| if (username is None) ^ (token is None): |
| raise ValueError("Auth required both username and token") |
| self.username = username |
| self.token = token |
| if timeout is not None: |
| self.timeout = timeout |
| if sha is None: |
| |
| u = "https://api.github.com/repos/{org}/{repo}" |
| r = requests.get( |
| u.format(org=org, repo=repo), timeout=self.timeout, **self.kw |
| ) |
| r.raise_for_status() |
| sha = r.json()["default_branch"] |
|
|
| self.root = sha |
| self.ls("") |
|
|
| @property |
| def kw(self): |
| if self.username: |
| return {"auth": (self.username, self.token)} |
| return {} |
|
|
| @classmethod |
| def repos(cls, org_or_user, is_org=True): |
| """List repo names for given org or user |
| |
| This may become the top level of the FS |
| |
| Parameters |
| ---------- |
| org_or_user: str |
| Name of the github org or user to query |
| is_org: bool (default True) |
| Whether the name is an organisation (True) or user (False) |
| |
| Returns |
| ------- |
| List of string |
| """ |
| r = requests.get( |
| f"https://api.github.com/{['users', 'orgs'][is_org]}/{org_or_user}/repos", |
| timeout=cls.timeout, |
| ) |
| r.raise_for_status() |
| return [repo["name"] for repo in r.json()] |
|
|
| @property |
| def tags(self): |
| """Names of tags in the repo""" |
| r = requests.get( |
| f"https://api.github.com/repos/{self.org}/{self.repo}/tags", |
| timeout=self.timeout, |
| **self.kw, |
| ) |
| r.raise_for_status() |
| return [t["name"] for t in r.json()] |
|
|
| @property |
| def branches(self): |
| """Names of branches in the repo""" |
| r = requests.get( |
| f"https://api.github.com/repos/{self.org}/{self.repo}/branches", |
| timeout=self.timeout, |
| **self.kw, |
| ) |
| r.raise_for_status() |
| return [t["name"] for t in r.json()] |
|
|
| @property |
| def refs(self): |
| """Named references, tags and branches""" |
| return {"tags": self.tags, "branches": self.branches} |
|
|
| def ls(self, path, detail=False, sha=None, _sha=None, **kwargs): |
| """List files at given path |
| |
| Parameters |
| ---------- |
| path: str |
| Location to list, relative to repo root |
| detail: bool |
| If True, returns list of dicts, one per file; if False, returns |
| list of full filenames only |
| sha: str (optional) |
| List at the given point in the repo history, branch or tag name or commit |
| SHA |
| _sha: str (optional) |
| List this specific tree object (used internally to descend into trees) |
| """ |
| path = self._strip_protocol(path) |
| if path == "": |
| _sha = sha or self.root |
| if _sha is None: |
| parts = path.rstrip("/").split("/") |
| so_far = "" |
| _sha = sha or self.root |
| for part in parts: |
| out = self.ls(so_far, True, sha=sha, _sha=_sha) |
| so_far += "/" + part if so_far else part |
| out = [o for o in out if o["name"] == so_far] |
| if not out: |
| raise FileNotFoundError(path) |
| out = out[0] |
| if out["type"] == "file": |
| if detail: |
| return [out] |
| else: |
| return path |
| _sha = out["sha"] |
| if path not in self.dircache or sha not in [self.root, None]: |
| r = requests.get( |
| self.url.format(org=self.org, repo=self.repo, sha=_sha), |
| timeout=self.timeout, |
| **self.kw, |
| ) |
| if r.status_code == 404: |
| raise FileNotFoundError(path) |
| r.raise_for_status() |
| types = {"blob": "file", "tree": "directory"} |
| out = [ |
| { |
| "name": path + "/" + f["path"] if path else f["path"], |
| "mode": f["mode"], |
| "type": types[f["type"]], |
| "size": f.get("size", 0), |
| "sha": f["sha"], |
| } |
| for f in r.json()["tree"] |
| if f["type"] in types |
| ] |
| if sha in [self.root, None]: |
| self.dircache[path] = out |
| else: |
| out = self.dircache[path] |
| if detail: |
| return out |
| else: |
| return sorted([f["name"] for f in out]) |
|
|
| def invalidate_cache(self, path=None): |
| self.dircache.clear() |
|
|
| @classmethod |
| def _strip_protocol(cls, path): |
| opts = infer_storage_options(path) |
| if "username" not in opts: |
| return super()._strip_protocol(path) |
| return opts["path"].lstrip("/") |
|
|
| @staticmethod |
| def _get_kwargs_from_urls(path): |
| opts = infer_storage_options(path) |
| if "username" not in opts: |
| return {} |
| out = {"org": opts["username"], "repo": opts["password"]} |
| if opts["host"]: |
| out["sha"] = opts["host"] |
| return out |
|
|
| def _open( |
| self, |
| path, |
| mode="rb", |
| block_size=None, |
| autocommit=True, |
| cache_options=None, |
| sha=None, |
| **kwargs, |
| ): |
| if mode != "rb": |
| raise NotImplementedError |
| url = self.rurl.format( |
| org=self.org, repo=self.repo, path=path, sha=sha or self.root |
| ) |
| r = requests.get(url, timeout=self.timeout, **self.kw) |
| if r.status_code == 404: |
| raise FileNotFoundError(path) |
| r.raise_for_status() |
| return MemoryFile(None, None, r.content) |
|
|
| def cat(self, path, recursive=False, on_error="raise", **kwargs): |
| paths = self.expand_path(path, recursive=recursive) |
| urls = [ |
| self.rurl.format(org=self.org, repo=self.repo, path=u, sha=self.root) |
| for u, sh in paths |
| ] |
| fs = fsspec.filesystem("http") |
| data = fs.cat(urls, on_error="return") |
| return {u: v for ((k, v), u) in zip(data.items(), urls)} |
|
|
