ciel 0.21.0.dev0__py3-none-any.whl

ciel/manage.py

@@ -0,0 +1,355 @@
+# 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 io
+import os
+import shutil
+import tarfile
+import tempfile
+import warnings
+from typing import Iterable, List, Optional, Union
+
+import rich
+import httpx
+import rich.tree
+import rich.progress
+import zstandard as zstd
+from rich.console import Console
+
+from .build.git_multi_clone import mkdirp
+from .github import GitHubSession
+from .common import (
+    Version,
+    get_versions_dir,
+    get_cielo_dir,
+)
+from .build import build, push
+from .families import Family
+
+
+class VersionNotFound(Exception):
+    pass
+
+
+def print_installed_list(
+    pdk_root: str,
+    pdk: str,
+    *,
+    console: Console,
+    installed_list: List[Version],
+    session: Optional[GitHubSession] = None,
+):
+    if len(installed_list) == 0:
+        console.print("[red]No PDKs installed.")
+        return
+
+    versions = installed_list
+
+    try:
+        all_remote_versions = Version._from_github(session)
+        remote_versions = all_remote_versions.get(pdk) or []
+        remote_version_dict = {rv.name: rv for rv in remote_versions}
+        for installed in installed_list:
+            remote_version = remote_version_dict.get(installed.name)
+            if remote_version is not None:
+                installed.commit_date = remote_version.commit_date
+                installed.upload_date = remote_version.upload_date
+        versions.sort(reverse=True)
+    except httpx.HTTPError:
+        console.print(
+            "[red]Failed to connect to GitHub. Date information may be unavailable."
+        )
+
+    versions_dir = get_versions_dir(pdk_root, pdk)
+    tree = rich.tree.Tree(f"In {versions_dir}:")
+    for installed in versions:
+        day: Optional[str] = None
+        if installed.commit_date is not None:
+            day = installed.commit_date.strftime("%Y.%m.%d")
+        desc = f"{installed.name}"
+        if day is not None:
+            desc += f" ({day})"
+        if installed.is_current(pdk_root):
+            tree.add(f"[green][bold]{desc} (enabled)")
+        else:
+            tree.add(desc)
+    console.print(tree)
+
+
+def print_remote_list(
+    pdk_root: str,
+    pdk: str,
+    console: Console,
+    pdk_list: List[Version],
+):
+    installed_list = Version.get_all_installed(pdk_root, pdk)
+
+    tree = rich.tree.Tree(f"Pre-built {pdk} PDK versions")
+    for remote_version in pdk_list:
+        name = remote_version.name
+        assert (
+            remote_version.commit_date is not None
+        ), f"Remote version {name} has no commit date"
+        day = remote_version.commit_date.strftime("%Y.%m.%d")
+        desc = f"[green]{name} ({day})"
+        if remote_version.prerelease:
+            desc = f"[red]PRE-RELEASE {desc}"
+        if remote_version.is_current(pdk_root):
+            tree.add(f"[bold]{desc} (enabled)")
+        elif name in installed_list:
+            tree.add(f"{desc} (installed)")
+        else:
+            tree.add(desc)
+    console.print(tree)
+
+
+def fetch(
+    pdk_root: str,
+    pdk: str,
+    version: str,
+    *,
+    build_if_not_found=False,
+    also_push=False,
+    build_kwargs: dict = {},
+    push_kwargs: dict = {},
+    include_libraries: Optional[Iterable[str]] = None,
+    output: Union[Console, io.TextIOWrapper] = Console(),
+    session: Optional[GitHubSession] = None,
+) -> Version:
+    if session is None:
+        session = GitHubSession()
+
+    console = output
+    if not isinstance(console, Console):
+        console = Console(file=console)
+
+    version_object = Version(version, pdk)
+
+    version_directory = version_object.get_dir(pdk_root)
+
+    pdk_family = Family.by_name.get(pdk)
+    if pdk_family is None:
+        raise ValueError(f"Unsupported PDK family '{pdk}'.")
+
+    library_set = pdk_family.resolve_libraries(include_libraries)
+
+    variants = pdk_family.variants
+
+    common_missing = False
+    missing_libraries = set()
+    libs_tech = os.path.join(version_directory, variants[0], "libs.tech")
+    if not os.path.isdir(libs_tech):
+        common_missing = True
+
+    for library in library_set:
+        if library not in pdk_family.all_libraries:
+            raise RuntimeError(f"Unknown library {library}.")
+        found = False
+        for variant in variants:
+            lib_path = os.path.join(version_directory, variant, "libs.ref", library)
+            if os.path.isdir(lib_path):
+                found = True
+        if not found:
+            missing_libraries.add(library)
+
+    affected_paths = []
+    if len(missing_libraries) != 0 or common_missing:
+        if common_missing:
+            console.print(
+                f"Version {version} not found locally, attempting to download…"
+            )
+            affected_paths.append(version_directory)
+        else:
+            console.print(f"Libraries {missing_libraries} not found, downloading them…")
+            for variant in variants:
+                affected_paths.append(
+                    os.path.join(version_directory, variant, "libs.ref", library)
+                )
+
+        tarball_paths = []
+        try:
+            release_link_list = version_object.get_release_links(
+                missing_libraries,
+                include_common=common_missing,
+                session=session,
+            )
+            tarball_directory = tempfile.TemporaryDirectory(suffix=".cielo")
+            for name, link in release_link_list:
+                tarball_path = os.path.join(tarball_directory.name, name)
+                tarball_paths.append(tarball_path)
+                with session.stream("get", link) as r, rich.progress.Progress(
+                    console=console
+                ) as p:
+                    total_str: Optional[str] = r.headers.get("Content-length", None)
+                    total_int: Optional[int] = None
+                    if total_str is not None:
+                        total_int = int(total_str)
+                    task = p.add_task(
+                        f"Downloading {name}…",
+                        total=total_int,
+                    )
+                    r.raise_for_status()
+                    with open(tarball_path, "wb") as f:
+                        for chunk in r.iter_bytes(chunk_size=8192):
+                            p.advance(task, advance=len(chunk))
+                            f.write(chunk)
+
+                with console.status(f"Unpacking {name}…"):
+                    stream = zstd.open(tarball_path, mode="rb")
+                    with tarfile.TarFile(fileobj=stream, mode="r") as tf:
+                        for file in tf:
+                            if file.isdir():
+                                continue
+                            final_path = os.path.join(version_directory, file.name)
+                            final_dir = os.path.dirname(final_path)
+                            mkdirp(final_dir)
+                            io = tf.extractfile(file)
+                            if io is None:
+                                raise IOError(
+                                    f"Failed to unpack file in {name}'s tarball: {file.name}."
+                                )
+                            with open(final_path, "wb") as f:
+                                f.write(io.read())
+        except httpx.HTTPStatusError as e:
+            if e.response is not None and e.response.status_code == 404:
+                if not build_if_not_found:
+                    raise RuntimeError(f"Version {version} not found remotely.")
+                console.print(
+                    f"Version {version} not found remotely, attempting to build…"
+                )
+                build(
+                    pdk_root=pdk_root,
+                    pdk=pdk,
+                    version=version,
+                    **build_kwargs,
+                )
+                if also_push:
+                    if push_kwargs["push_libraries"] is None:
+                        push_kwargs["push_libraries"] = Family.by_name[
+                            pdk
+                        ].default_includes.copy()
+                    push(
+                        pdk_root=pdk_root,
+                        pdk=pdk,
+                        version=version,
+                        session=session,
+                        **push_kwargs,
+                    )
+            else:
+                if e.response is not None:
+                    raise RuntimeError(
+                        f"Failed to obtain {version} remotely: {e.response}."
+                    )
+                else:
+                    raise RuntimeError(f"Failed to request {version} from server: {e}.")
+        except KeyboardInterrupt as e:
+            console.print("Interrupted.")
+            for path in affected_paths:
+                shutil.rmtree(path, ignore_errors=True)
+            raise e from None
+        except Exception as e:
+            for path in affected_paths:
+                shutil.rmtree(path, ignore_errors=True)
+            raise e from None
+        finally:
+            for path in tarball_paths:
+                try:
+                    os.unlink(path)
+                except FileNotFoundError:
+                    pass
+
+        for variant in variants:
+            variant_install_path = os.path.join(version_directory, variant)
+            if not os.path.isdir(variant_install_path):
+                continue
+            variant_sources_file = os.path.join(variant_install_path, "SOURCES")
+            if not os.path.isfile(variant_sources_file):
+                with open(variant_sources_file, "w") as f:
+                    print(f"{pdk_family.repo.name} {version}", file=f)
+
+    return Version(version, pdk)
+
+
+def enable(
+    pdk_root: str,
+    pdk: str,
+    version: str,
+    *,
+    build_if_not_found: bool = False,
+    also_push: bool = False,
+    build_kwargs: dict = {},
+    push_kwargs: dict = {},
+    include_libraries: Optional[List[str]] = None,
+    output: Union[Console, io.TextIOWrapper] = Console(),
+    session: Optional[GitHubSession] = None,
+) -> Version:
+    if session is None:
+        session = GitHubSession()
+
+    console = output
+    if not isinstance(console, Console):
+        console = Console(file=console)
+
+    version_object = Version(version, pdk)
+    version_directory = version_object.get_dir(pdk_root)
+
+    pdk_family = Family.by_name.get(pdk)
+    if pdk_family is None:
+        raise ValueError(f"Unsupported PDK family '{pdk}'.")
+
+    variants = pdk_family.variants
+    version_paths = [os.path.join(version_directory, variant) for variant in variants]
+    final_paths = [os.path.join(pdk_root, variant) for variant in variants]
+
+    fetch(
+        pdk_root,
+        pdk,
+        version,
+        build_if_not_found=build_if_not_found,
+        also_push=also_push,
+        build_kwargs=build_kwargs,
+        push_kwargs=push_kwargs,
+        include_libraries=include_libraries,
+        output=output,
+        session=session,
+    )
+
+    current_file = os.path.join(get_cielo_dir(pdk_root, pdk), "current")
+    current_file_dir = os.path.dirname(current_file)
+    mkdirp(current_file_dir)
+
+    with console.status(f"Enabling version {version}…"):
+        for path in final_paths:
+            if os.path.exists(path):
+                if os.path.islink(path):
+                    os.unlink(path)
+                else:
+                    raise FileExistsError(
+                        f"{path} exists, and not as a symlink. Remove it then try re-enabling."
+                    )
+
+        for vpath, fpath in zip(version_paths, final_paths):
+            src = os.path.relpath(vpath, pdk_root)
+            if os.path.isdir(vpath):
+                os.symlink(src=src, dst=fpath)
+
+        with open(current_file, "w") as f:
+            f.write(version)
+
+    console.print(f"Version {version} enabled for the {pdk} PDK.")
+    return version_object
+
+
+def get(*args, **kwargs):
+    warnings.warn("get() has been deprecated: use fetch()")
+    return fetch(*args, **kwargs)

ciel-0.21.0.dev0.dist-info/METADATA

@@ -0,0 +1,168 @@
+Metadata-Version: 2.3
+Name: ciel
+Version: 0.21.0.dev0
+Summary: An PDK builder/version manager for PDKs in the open_pdks format
+License: Apache-2.0
+Author: Efabless Corporation and Contributors
+Author-email: donn@efabless.com
+Requires-Python: >=3.8
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (>=8,<9)
+Requires-Dist: httpx (>=0.22.0,<0.29)
+Requires-Dist: pcpp (>=1.2,<2)
+Requires-Dist: pyyaml (>=5,<7)
+Requires-Dist: rich (>=12,<14)
+Requires-Dist: zstandard (>=0.19.0,<1)
+Project-URL: Repository, https://github.com/donn/cielo
+Description-Content-Type: text/markdown
+
+<h1 align="center">☁️ Cielo</h1>
+<p align="center">
+    <a href="https://opensource.org/licenses/Apache-2.0"><img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg" alt="License: Apache 2.0"/></a>
+    <img src="https://github.com/efabless/cielo/actions/workflows/ci.yml/badge.svg?branch=main" alt="CI Status" />
+    <a href="https://invite.skywater.tools"><img src="https://img.shields.io/badge/Community-Skywater%20PDK%20Slack-ff69b4?logo=slack" alt="Invite to the Skywater PDK Slack"/></a>
+    <a href="https://github.com/psf/black"><img src="https://img.shields.io/badge/code%20style-black-000000.svg" alt="Code Style: Black"/></a>
+</p>
+
+<p align="center">Cielo is a version manager (and builder) for builds of <a href="https://github.com/google/open-source-pdks">Google open-source PDKs</a> using <a href="https://github.com/rtimothyedwards/open_pdks">open_pdks</a>.</p>
+
+# Requirements
+* Python 3.8+ with PIP
+* macOS or GNU/Linux
+
+## macOS
+Get [Homebrew](https://brew.sh) then:
+
+```sh
+brew install python3
+```
+
+## Debian and Ubuntu
+Debian 11+ or Ubuntu 20.04+ is required.
+
+```sh
+sudo apt-get update
+sudo apt-get install python3 python3-pip xz-utils
+```
+
+## RHEL and Derivatives
+RHEL 8+ or compatible operating system required.
+```sh
+sudo yum install -y python3 python3-pip
+```
+
+
+# Installation and Upgrades
+```sh
+# To install (or upgrade)
+python3 -m pip install --user --upgrade --no-cache-dir cielo
+
+# To verify it works
+cielo --version
+```
+
+# About the builds
+In its current inception, cielo supports builds of **sky130** and **gf180mcu** PDKs using [Open_PDKs](https://github.com/efabless/open_pdks), including the following libraries:
+
+|sky130|gf180mcu|
+|-|-|
+|sky130_fd_io|gf180mcu_fd_io|
+|sky130_fd_pr|gf180mcu_fd_pr|
+|sky130_fd_sc_hd|gf180mcu_fd_sc_mcu7t5v0|
+|sky130_fd_sc_hvl|gf180mcu_fd_sc_mcu9t5v0|
+|sky130 sram modules|gf180mcu_fd_ip_sram|
+
+All builds are identified by their **open_pdks** commit hash.
+
+# Usage
+Cielo requires a so-called **PDK Root**. This PDK root can be anywhere on your computer, but by default it's the folder `~/.cielo` in your home directory. If you have the variable `PDK_ROOT` set, cielo will use that instead. You can also manually override both values by supplying the `--pdk-root` commandline argument.
+
+## Listing All Available PDKs
+To list all available pre-built PDKs hosted in this repository, you can just invoke `cielo ls-remote --pdk <PDK>`. If you omit the `--pdk` argument, `sky130` will be used as a default.
+
+```sh
+$ cielo ls-remote --pdk sky130
+Pre-built sky130 PDK versions
+├── 44a43c23c81b45b8e774ae7a84899a5a778b6b0b (2022.08.16) (enabled)
+├── e8294524e5f67c533c5d0c3afa0bcc5b2a5fa066 (2022.07.29) (installed)
+├── 41c0908b47130d5675ff8484255b43f66463a7d6 (2022.04.14) (installed)
+├── 660c6bdc8715dc7b3db95a1ce85392bbf2a2b195 (2022.04.08)
+├── 5890e791e37699239abedfd2a67e55162e25cd94 (2022.04.06)
+├── 8fe7f760ece2bb49b1c310e60243f0558977dae5 (2022.04.06)
+└── 7519dfb04400f224f140749cda44ee7de6f5e095 (2022.02.10)
+
+$ cielo ls-remote --pdk gf180mcu
+Pre-built gf180mcu PDK versions
+└── 120b0bd69c745825a0b8b76f364043a1cd08bb6a (2022.09.22)
+```
+
+It includes a commit hash, which is the `open_pdks` version used to build this particular PDK, the date that this commit was created, and whether you already installed this PDK and/or if it is the currently enabled PDK.
+
+## Listing Installed PDKs
+Typing `cielo ls --pdk <pdk>` in the terminal shows you your PDK Root and the PDKs you currently have installed. Again, if you omit the `--pdk` argument, `sky130` will be used as a default.
+
+```sh
+$ cielo ls --pdk sky130
+/home/test/cielo/sky130/versions
+├── 44a43c23c81b45b8e774ae7a84899a5a778b6b0b (2022.08.16) (enabled)
+├── e8294524e5f67c533c5d0c3afa0bcc5b2a5fa066 (2022.07.29)
+└── 41c0908b47130d5675ff8484255b43f66463a7d6 (2022.04.14)
+```
+
+(If you're not connected to the Internet, the release date of the commit will not be included.)
+
+
+## Downloading and Enabling PDKs
+You can enable a particular sky130 PDK by invoking `cielo enable --pdk <pdk> <open_pdks commit hash>`. This will automatically download that particular version of the PDK, if found, and set it as your currently used PDK.
+
+For example, to activate a build of sky130 using open_pdks `7519dfb04400f224f140749cda44ee7de6f5e095`, you invoke `cielo enable --pdk sky130 7519dfb04400f224f140749cda44ee7de6f5e095`, as shown below:
+
+```sh
+$ cielo enable --pdk sky130 7519dfb04400f224f140749cda44ee7de6f5e095
+Downloading pre-built tarball for 7519dfb04400f224f140749cda44ee7de6f5e095… ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00
+Unpacking…                                                                  ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━ 100% 0:00:00
+PDK version 7519dfb04400f224f140749cda44ee7de6f5e095 enabled.
+```
+
+What's more is: if you're using a repository with a `tool_metadata.yml` file, such as [OpenLane](https://github.com/The-OpenROAD-Project/OpenLane) or [DFFRAM](https://github.com/Cloud-V/DFFRAM), you can just invoke `cielo enable --pdk sky130` without the commit hash and Cielo will automatically extract the version required by the utility. Once again, if you omit the `--pdk` argument, `sky130` will be used as a default.
+
+## Building PDKs
+For special cases, you may have to build the PDK yourself, which Cielo does support.
+
+You'll need Magic installed and in PATH. You can either do that manually or, if you have [Nix](https://nixos.org), invoke `nix shell github:efabless/openlane2#magic` before building.
+
+You can invoke `cielo build --help` for more options. Be aware, the built PDK won't automatically be enabled and you'll have to `cielo enable` the appropriate version.
+
+# License
+The Apache License, version 2.0. See 'License'.
+
+
+Cielo is based on [Volare](https://github.com/efabless/volare) by Efabless
+Corporation:
+
+```
+Copyright 2022-2025 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.
+```
+

ciel-0.21.0.dev0.dist-info/RECORD

@@ -0,0 +1,19 @@
+ciel/__init__.py,sha256=Ds7HveaY6MEuAefOAmZWUGZxlJbWmh0VNlI7iJdbi9U,858
+ciel/__main__.py,sha256=2aVGdjzPJO2O1UjDEeOyWxyAw_nqjvT7BDReu24hJlE,12021
+ciel/__version__.py,sha256=CiYOz2nsxhPOSiHi6nLpq-o6zdzLhvEVAG_58UzG5Xs,1510
+ciel/build/__init__.py,sha256=0a8KRwBcwZRFgcsZcYYLJuUMAjMsIfDF-nGt_1LKr3s,7378
+ciel/build/common.py,sha256=DAOaJVCyfgfBvPzhhLiYorRJoHqS4wQ5080VgGnd7Gg,3283
+ciel/build/gf180mcu.py,sha256=J1c9EPFVJpqhibAzle_hiVYNx3gOduE3x4EUBBMWPZM,8775
+ciel/build/git_multi_clone.py,sha256=lgjfZPN4KE9IJq4ph4xnst35hh4Rup16glhJtE8Srek,6902
+ciel/build/ihp_sg13g2.py,sha256=zDIoSL4rKk4XUqjBUZuMFFcngc7FsjuAti7ibqj3zt4,4940
+ciel/build/sky130.py,sha256=5scYrgKHpoTxkLmvxXEXkzfN8lVB60lI8R0iZaiT2RY,12047
+ciel/click_common.py,sha256=YD7OYskwSWKfis7kndPTK32VgqiPmZ2QvSoZljqc6Fw,3741
+ciel/common.py,sha256=tr-kIYvtjMpi9-spLQvlHm2r2eGJUXJFBDmFUwUpBK0,7913
+ciel/families.py,sha256=4ZNvDUSEknlFJmyyFGE-jgd7hkXnKcA9qnH_6GyIiqk,3525
+ciel/github.py,sha256=pFfmICJoTo188bp-3z7b2TLvKVmJC5PAd--ssC4pHSM,5111
+ciel/manage.py,sha256=S90KZHvUBSpkeeFPq1rwK6YKo4jFcHizdeCri4I9LzM,12371
+ciel/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ciel-0.21.0.dev0.dist-info/METADATA,sha256=ZORoGjY1EgRuYKWu5NgB62rDlhrXCe9R8DE5gkbmoZw,7700
+ciel-0.21.0.dev0.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+ciel-0.21.0.dev0.dist-info/entry_points.txt,sha256=XDz2ZqV8nlrFh2qQ3uqZwFl9lw-mm-FRcEyMXMtYTGY,44
+ciel-0.21.0.dev0.dist-info/RECORD,,

ciel-0.21.0.dev0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.1.1
+Root-Is-Purelib: true
+Tag: py3-none-any

ciel-0.21.0.dev0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cielo=cielo.__main__:cli
+