ciel 0.21.0.dev0__py3-none-any.whl

ciel/common.py

@@ -0,0 +1,256 @@
+# Copyright 2022-2023 Efabless Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import re
+import shutil
+import pathlib
+from datetime import datetime
+from dataclasses import dataclass
+from typing import Iterable, Optional, List, Dict, Tuple
+
+from . import github
+from .families import Family
+
+# -- Assorted Helper Functions
+ISO8601_FMT = "%Y-%m-%dT%H:%M:%SZ"
+
+
+def date_to_iso8601(date: datetime) -> str:
+    return date.strftime(ISO8601_FMT)
+
+
+def date_from_iso8601(string: str) -> datetime:
+    return datetime.strptime(string, ISO8601_FMT)
+
+
+def mkdirp(path):
+    return pathlib.Path(path).mkdir(parents=True, exist_ok=True)
+
+
+# -- API Variables
+
+# -- PDK Root Management
+VOLARE_DEFAULT_HOME = os.path.join(os.path.expanduser("~"), ".cielo")
+VOLARE_RESOLVED_HOME = os.getenv("PDK_ROOT") or VOLARE_DEFAULT_HOME
+
+
+def _get_current_version(pdk_root: str, pdk: str) -> Optional[str]:
+    current_file = os.path.join(get_cielo_dir(pdk_root, pdk), "current")
+    current_file_dir = os.path.dirname(current_file)
+    mkdirp(current_file_dir)
+    version = None
+    try:
+        version = open(current_file).read().strip()
+    except FileNotFoundError:
+        pass
+
+    return version
+
+
+def get_cielo_home(pdk_root: Optional[str] = None) -> str:
+    return pdk_root or VOLARE_RESOLVED_HOME
+
+
+def get_cielo_dir(pdk_root: str, pdk: str) -> str:
+    return os.path.join(pdk_root, "cielo", pdk)
+
+
+def get_versions_dir(pdk_root: str, pdk: str) -> str:
+    return os.path.join(get_cielo_dir(pdk_root, pdk), "versions")
+
+
+@dataclass
+class Version(object):
+    name: str
+    pdk: str
+    commit_date: Optional[datetime] = None
+    upload_date: Optional[datetime] = None
+    prerelease: bool = False
+
+    def __lt__(self, rhs: "Version"):
+        return (self.commit_date or datetime.min) < (rhs.commit_date or datetime.min)
+
+    def __str__(self) -> str:
+        return self.name
+
+    def is_installed(self, pdk_root: str) -> bool:
+        version_dir = self.get_dir(pdk_root)
+        return os.path.isdir(version_dir)
+
+    def is_current(self, pdk_root: str) -> bool:
+        return self.name == _get_current_version(pdk_root, self.pdk)
+
+    def get_dir(self, pdk_root: str) -> str:
+        return os.path.join(get_versions_dir(pdk_root, self.pdk), self.name)
+
+    def unset_current(self, pdk_root: str):
+        if not self.is_installed(pdk_root):
+            return
+        if not self.is_current(pdk_root):
+            return
+
+        for variant in Family.by_name[self.pdk].variants:
+            try:
+                os.unlink(os.path.join(pdk_root, variant))
+            except FileNotFoundError:
+                pass
+
+        current_file = os.path.join(get_cielo_dir(pdk_root, self.pdk), "current")
+        os.unlink(current_file)
+
+    def uninstall(self, pdk_root: str):
+        if not self.is_installed(pdk_root):
+            raise ValueError(
+                f"Version {self.name} of the {self.pdk} PDK is not installed."
+            )
+
+        self.unset_current(pdk_root)
+
+        version_dir = self.get_dir(pdk_root)
+
+        shutil.rmtree(version_dir)
+
+    @classmethod
+    def get_current(Self, pdk_root: str, pdk: str) -> Optional["Version"]:
+        current_version = _get_current_version(pdk_root, pdk)
+        if current_version is None:
+            return None
+
+        return Version(current_version, pdk)
+
+    @classmethod
+    def get_all_installed(Self, pdk_root: str, pdk: str) -> List["Version"]:
+        versions_dir = get_versions_dir(pdk_root, pdk)
+        mkdirp(versions_dir)
+        return [
+            Version(
+                name=version,
+                pdk=pdk,
+            )
+            for version in os.listdir(versions_dir)
+            if os.path.isdir(os.path.join(versions_dir, version))
+        ]
+
+    @classmethod
+    def _from_github(
+        Self,
+        session: Optional[github.GitHubSession] = None,
+    ) -> Dict[str, List["Version"]]:
+        releases = github.get_releases(session)
+
+        rvs_by_pdk: Dict[str, List["Version"]] = {}
+
+        commit_rx = re.compile(r"released on ([\d\-\:TZ]+)")
+
+        for release in releases:
+            if release["draft"]:
+                continue
+            family, hash = release["tag_name"].rsplit("-", maxsplit=1)
+
+            upload_date = date_from_iso8601(release["published_at"])
+            commit_date = None
+
+            commit_date_match = commit_rx.search(release["body"])
+            if commit_date_match is not None:
+                commit_date = date_from_iso8601(commit_date_match[1])
+
+            remote_version = Self(
+                name=hash,
+                pdk=family,
+                commit_date=commit_date,
+                upload_date=upload_date,
+                prerelease=release["prerelease"],
+            )
+
+            if rvs_by_pdk.get(family) is None:
+                rvs_by_pdk[family] = rvs_by_pdk.get(family) or []
+
+            rvs_by_pdk[family].append(remote_version)
+
+        for family in rvs_by_pdk.keys():
+            rvs_by_pdk[family].sort(reverse=True)
+
+        return rvs_by_pdk
+
+    def get_release_links(
+        self,
+        scl_filter: Iterable[str],
+        include_common: bool,
+        session: Optional[github.GitHubSession] = None,
+    ) -> List[Tuple[str, str]]:
+        release = github.get_release_links(f"{self.pdk}-{self.name}", session)
+
+        assets = release["assets"]
+        zst_files = []
+        for asset in assets:
+            if asset["name"].endswith(".tar.zst"):
+                asset_scl = asset["name"][:-8]
+                if (
+                    asset_scl == "common" and include_common
+                ) or asset_scl in scl_filter:
+                    zst_files.append((asset["name"], asset["browser_download_url"]))
+
+        if len(zst_files) == 0:
+            raise ValueError(
+                f"No files found for standard cell libraries: {scl_filter}."
+            )
+
+        return zst_files
+
+
+def resolve_version(
+    version: Optional[str],
+    tool_metadata_file_path: Optional[str],
+) -> str:
+    """
+    Takes an optional version and tool_metadata_file_path.
+
+    If version is set, it is returned.
+
+    If not, tool_metadata_file_path is checked if it exists.
+
+    If not specified, ./tool_metadata.yml and ./dependencies/tool_metadata.yml
+    are both checked if they exist.
+
+    If none are specified, execution is halted.
+
+    Otherwise, the resulting metadata file is parsed for an open_pdks version,
+    which is then returned.
+    """
+    if version is not None:
+        return version
+
+    import yaml
+
+    if tool_metadata_file_path is None:
+        tool_metadata_file_path = os.path.join(".", "tool_metadata.yml")
+        if not os.path.isfile(tool_metadata_file_path):
+            tool_metadata_file_path = os.path.join(
+                ".", "dependencies", "tool_metadata.yml"
+            )
+            if not os.path.isfile(tool_metadata_file_path):
+                raise FileNotFoundError(
+                    "Any of ./tool_metadata.yml or ./dependencies/tool_metadata.yml not found. You'll need to specify the file path or the commits explicitly."
+                )
+
+    tool_metadata = yaml.safe_load(open(tool_metadata_file_path).read())
+
+    open_pdks_list = [tool for tool in tool_metadata if tool["name"] == "open_pdks"]
+
+    if len(open_pdks_list) < 1:
+        raise ValueError("No entry for open_pdks found in tool_metadata.yml")
+
+    version = open_pdks_list[0]["commit"]
+
+    return version

ciel/families.py

@@ -0,0 +1,119 @@
+# Copyright 2022-2023 Efabless Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+from dataclasses import dataclass
+from typing import Iterable, List, Dict, Optional, Set, ClassVar
+
+from .github import RepoInfo, opdks_repo, ihp_repo
+
+
+@dataclass
+class Family(object):
+    by_name: ClassVar[Dict[str, "Family"]] = {}
+
+    name: str
+    variants: List[str]
+    all_libraries: List[str]
+    repo: RepoInfo
+    # lol no implicitly unwrapped optionals
+    default_variant: str = None  # type: ignore
+    default_includes: List[str] = None  # type: ignore
+
+    def __post_init__(self):
+        if self.default_variant is None:
+            self.default_variant = self.variants[0]
+        if self.default_includes is None:
+            self.default_includes = self.all_libraries.copy()
+
+    def resolve_libraries(
+        self,
+        input: Optional[Iterable[str]],
+    ) -> Set[str]:
+        if input is None:
+            input = ("default",)
+        final_set: Set[str] = set()
+        for element in input:
+            if element.lower() == "all":
+                final_set = set(self.all_libraries)
+                return final_set
+            elif element.lower() == "default":
+                final_set = final_set.union(set(self.default_includes))
+            elif element in self.all_libraries:
+                final_set.add(element)
+            else:
+                raise ValueError(f"Unknown library {element} for PDK {self.name}")
+        return final_set
+
+
+Family.by_name = {}
+Family.by_name["sky130"] = Family(
+    name="sky130",
+    variants=["sky130A", "sky130B"],
+    default_variant="sky130A",
+    all_libraries=[
+        "sky130_fd_io",
+        "sky130_fd_pr",
+        "sky130_ml_xx_hd",
+        "sky130_fd_sc_hd",
+        "sky130_fd_sc_hdll",
+        "sky130_fd_sc_lp",
+        "sky130_fd_sc_hvl",
+        "sky130_fd_sc_ls",
+        "sky130_fd_sc_ms",
+        "sky130_fd_sc_hs",
+        "sky130_sram_macros",
+        "sky130_fd_pr_reram",
+    ],
+    default_includes=[
+        "sky130_fd_io",
+        "sky130_fd_pr",
+        "sky130_fd_sc_hd",
+        "sky130_fd_sc_hvl",
+        "sky130_ml_xx_hd",
+        "sky130_sram_macros",
+    ],
+    repo=opdks_repo,
+)
+Family.by_name["gf180mcu"] = Family(
+    name="gf180mcu",
+    variants=["gf180mcuA", "gf180mcuB", "gf180mcuC", "gf180mcuD"],
+    default_variant="gf180mcuD",
+    all_libraries=[
+        "gf180mcu_fd_io",
+        "gf180mcu_fd_pr",
+        "gf180mcu_fd_sc_mcu7t5v0",
+        "gf180mcu_fd_sc_mcu9t5v0",
+        "gf180mcu_fd_ip_sram",
+        "gf180mcu_osu_sc_gp12t3v3",
+        "gf180mcu_osu_sc_gp9t3v3",
+    ],
+    default_includes=[
+        "gf180mcu_fd_io",
+        "gf180mcu_fd_pr",
+        "gf180mcu_fd_sc_mcu7t5v0",
+        "gf180mcu_fd_sc_mcu9t5v0",
+        "gf180mcu_fd_ip_sram",
+    ],
+    repo=opdks_repo,
+)
+Family.by_name["ihp_sg13g2"] = Family(
+    name="ihp_sg13g2",
+    variants=["ihp-sg13g2"],
+    all_libraries=[
+        "sg13g2_io",
+        "sg13g2_pr",
+        "sg13g2_sram",
+        "sg13g2_stdcell",
+    ],
+    repo=ihp_repo,
+)

ciel/github.py

@@ -0,0 +1,184 @@
+# Copyright 2022-2023 Efabless Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+import os
+import subprocess
+import sys
+from datetime import datetime
+from dataclasses import dataclass
+from typing import Any, ClassVar, List, Mapping, Optional
+
+import httpx
+import ssl
+from .__version__ import __version__
+
+
+@dataclass
+class RepoInfo:
+    owner: str
+    name: str
+
+    @property
+    def id(self):
+        return f"{self.owner}/{self.name}"
+
+    @property
+    def link(self):
+        return f"https://github.com/{self.id}"
+
+    @property
+    def api(self):
+        return f"https://api.github.com/repos/{self.id}"
+
+
+volare_repo = RepoInfo(
+    os.getenv("VOLARE_REPO_OWNER", "efabless"),
+    os.getenv("VOLARE_REPO_NAME", "volare"),
+)
+
+opdks_repo = RepoInfo(
+    os.getenv("OPDKS_REPO_OWNER", "RTimothyEdwards"),
+    os.getenv("OPDKS_REPO_NAME", "open_pdks"),
+)
+
+ihp_repo = RepoInfo(
+    os.getenv("IHP_REPO_OWNER", "IHP-GmbH"),
+    os.getenv("IHP_REPO_NAME", "IHP-Open-PDK"),
+)
+
+
+class GitHubSession(httpx.Client):
+    class Token(object):
+        override: ClassVar[Optional[str]] = None
+
+        @classmethod
+        def get_gh_token(Self) -> Optional[str]:
+            token = None
+
+            # 0. Lowest priority: ghcli
+            try:
+                token = subprocess.check_output(
+                    [
+                        "gh",
+                        "auth",
+                        "token",
+                    ],
+                    encoding="utf8",
+                ).strip()
+            except FileNotFoundError:
+                pass
+            except subprocess.CalledProcessError:
+                pass
+
+            # 1. Higher priority: environment GITHUB_TOKEN
+            env_token = os.getenv("GITHUB_TOKEN")
+            if env_token is not None and env_token.strip() != "":
+                token = env_token
+
+            # 2. Highest priority: the -t flag
+            if Self.override is not None:
+                token = Self.override
+
+            return token
+
+    def __init__(
+        self,
+        *,
+        follow_redirects: bool = True,
+        github_token: Optional[str] = None,
+        ssl_context=None,
+        **kwargs,
+    ):
+        if ssl_context is None:
+            try:
+                import truststore
+
+                ssl_context = truststore.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
+            except ImportError:
+                pass
+
+        try:
+            super().__init__(
+                follow_redirects=follow_redirects,
+                verify=ssl_context,
+                **kwargs,
+            )
+        except ValueError as e:
+            if "Unknown scheme for proxy URL" in e.args[0] and "socks://" in e.args[0]:
+                print(
+                    f"Invalid SOCKS proxy: Cielo only supports http://, https:// and socks5:// schemes: {e.args[0]}",
+                    file=sys.stderr,
+                )
+                exit(-1)
+            else:
+                raise e from None
+        github_token = github_token or GitHubSession.Token.get_gh_token()
+        self.github_token = github_token
+
+        raw_headers = {
+            "User-Agent": type(self).get_user_agent(),
+        }
+        if github_token is not None:
+            raw_headers["Authorization"] = f"Bearer {github_token}"
+        self.headers = httpx.Headers(raw_headers)
+
+    def api(
+        self,
+        repo: RepoInfo,
+        endpoint: str,
+        method: str,
+        *args,
+        **kwargs,
+    ) -> Any:
+        url = repo.api + endpoint
+        req = self.request(method, url, *args, **kwargs)
+        req.raise_for_status()
+        return req.json()
+
+    @classmethod
+    def get_user_agent(Self) -> str:
+        return f"cielo/{__version__}"
+
+
+def get_commit_date(
+    commit: str,
+    repo: RepoInfo,
+    session: Optional[GitHubSession] = None,
+) -> Optional[datetime]:
+    if session is None:
+        session = GitHubSession()
+
+    try:
+        response = session.api(repo, f"/commits/{commit}", "get")
+    except httpx.HTTPError:
+        return None
+
+    date = response["commit"]["author"]["date"]
+    commit_date = datetime.strptime(date, "%Y-%m-%dT%H:%M:%SZ")
+    return commit_date
+
+
+def get_releases(session: Optional[GitHubSession] = None) -> List[Mapping[str, Any]]:
+    if session is None:
+        session = GitHubSession()
+
+    return session.api(volare_repo, "/releases", "get", params={"per_page": 100})
+
+
+def get_release_links(
+    release: str, session: Optional[GitHubSession] = None
+) -> Mapping[str, Any]:
+    if session is None:
+        session = GitHubSession()
+
+    return session.api(volare_repo, f"/releases/tags/{release}", "get")