a little docker fun

Author: martindurant

Dockerfile

@@ -0,0 +1,6 @@
+FROM python
+
+# todo: exclude potentially large env directories
+COPY . .
+RUN pip install . --no-cache-dir
+CMD ["projspec"]

src/projspec/__main__.py

@@ -50,7 +50,7 @@ def main(path, types, xtypes, walk, summary, make, storage_options):
     )
     if make:
         art: projspec.artifact.BaseArtifact
-        for art in proj.artifacts:
+        for art in proj.all_artifacts():
             if art.snake_name() == projspec.utils.camel_to_snake(make):
                 print("Launching:", art)
                 art.remake()

src/projspec/artifact/__init__.py

@@ -1,13 +1,15 @@
 """Things that a project can do or make"""
 
 from projspec.artifact.base import BaseArtifact, FileArtifact
+from projspec.artifact.container import DockerImage
 from projspec.artifact.installable import CondaPackage, Wheel
 from projspec.artifact.process import Process
 from projspec.artifact.python_env import EnvPack, CondaEnv, VirtualEnv, LockFile
 
 __all__ = [
     "BaseArtifact",
     "FileArtifact",
+    "DockerImage",
     "CondaPackage",
     "Wheel",
     "Process",

src/projspec/artifact/container.py

@@ -0,0 +1,46 @@
+import subprocess
+
+from projspec.proj.base import Project, ProjectExtra
+from projspec.artifact import BaseArtifact
+
+
+class DockerImage(BaseArtifact):
+    def __init__(self, proj: Project, cmd=None, tag=None):
+        if tag:
+            cmd = ["docker", "build", ".", "-t", tag]
+        else:
+            cmd = ["docker", "build", "."]
+        self.tag = tag
+        super().__init__(proj, cmd=cmd)
+
+
+class DockerRuntime(DockerImage):
+    # Note: there are many optional arguments to docker; we could surface the most common
+    #  ones (-it, -d, -p). This does the simplest thing.
+
+    def _make(self, *args, **kwargs) -> None:
+        """
+
+        :param args: added to the docker run command
+        :param kwargs: affect the docker run subprocess call
+        """
+        out = subprocess.check_output(self.cmd, cwd=self.proj.url, **kwargs)
+        if self.tag:
+            subprocess.check_call(["docker", "run", self.tag])
+        else:
+            lines = [
+                l for l in out.splitlines() if l.startswith(b"Successfully built ")
+            ]
+            img = lines[-1].split()[-1]
+            subprocess.check_call(
+                ["docker", "run", img.decode()] + list(args), **kwargs
+            )
+
+
+class Docker(ProjectExtra):
+    def match(self):
+        return "Dockerfile" in self.proj.basenames
+
+    def parse(self) -> None:
+        self._artifacts["docker_image"] = DockerImage(self.proj)
+        self._artifacts["docker_runtime"] = DockerRuntime(self.proj)

src/projspec/content/cicd.py

@@ -4,7 +4,7 @@
 
 
 class GithubAction(BaseContent):
-    """Run prescription that runs in github on push/merge"""
+    """A run prescription that runs in github on push/merge"""
 
     # TODO: we probably want to extract out the jobs and runs, maybe the steps.
     #  It may be interesting to provide links to the browser or API to view

src/projspec/proj/__init__.py

@@ -3,6 +3,7 @@
 from projspec.proj.conda_project import CondaProject
 from projspec.proj.documentation import RTD, MDBook
 from projspec.proj.git import GitRepo
+from projspec.proj.ide import JetbrainsIDE, NvidiaAIWorkbench, VSCode
 from projspec.proj.pixi import Pixi
 from projspec.proj.poetry import Poetry
 from projspec.proj.pyscript import PyScript
@@ -17,7 +18,9 @@
     "CondaRecipe",
     "CondaProject",
     "GitRepo",
+    "JetbrainsIDE",
     "MDBook",
+    "NvidiaAIWorkbench",
     "Poetry",
     "RattlerRecipe",
     "Pixi",
@@ -28,4 +31,5 @@
     "Rust",
     "RustPython",
     "Uv",
+    "VSCode",
 ]

src/projspec/proj/base.py

@@ -1,5 +1,6 @@
 import logging
 from collections.abc import Iterable
+from itertools import chain
 from functools import cached_property
 
 import fsspec
@@ -61,6 +62,8 @@ def __init__(
         self.url = path
         self.specs = AttrDict()
         self.children = AttrDict()
+        self.contents = AttrDict()
+        self.artifacts = AttrDict()
         self.excludes = excludes or default_excludes
         self._pyproject = None
         self.resolve(walk=walk, types=types, xtypes=xtypes)
@@ -90,17 +93,21 @@ def resolve(
         for name in sorted(registry):
             cls = registry[name]
             try:
-                logger.debug("resolving %s as %s", fullpath, cls)
                 name = cls.__name__
                 snake_name = camel_to_snake(cls.__name__)
                 if (types and {name, snake_name}.isdisjoint(types)) or {
                     name,
                     snake_name,
                 }.intersection(xtypes or set()):
                     continue
+                logger.debug("resolving %s as %s", fullpath, cls)
                 inst = cls(self)
                 inst.parse()
-                self.specs[snake_name] = inst
+                if isinstance(inst, ProjectExtra):
+                    self.contents.update(inst.contents)
+                    self.artifacts.update(inst.artifacts)
+                else:
+                    self.specs[snake_name] = inst
             except ParseFailed:
                 logger.debug("failed")
             except Exception as e:
@@ -148,7 +155,7 @@ def text_summary(self) -> str:
         """Only shows project types, not what they contain"""
         txt = f"<Project '{self.fs.unstrip_protocol(self.url)}'>\n"
         bits = [
-            f" {'/'}: {' '.join(type(_).__name__ for _ in self.specs.values())}"
+            f" {'/'}: {' '.join(type(_).__name__ for _ in chain(self.specs.values(), self.contents.values(), self.artifacts.values()))}"
         ] + [
             f" {k}: {' '.join(type(_).__name__ for _ in v.specs.values())}"
             for k, v in self.children.items()
@@ -160,6 +167,12 @@ def __repr__(self):
             self.fs.unstrip_protocol(self.url),
             "\n\n".join(str(_) for _ in self.specs.values()),
         )
+        if self.contents:
+            ch = "\n".join([f" {k}: {v}" for k, v in self.contents.items()])
+            txt += f"\nContents:\n{ch}"
+        if self.artifacts:
+            ch = "\n".join([f" {k}: {v}" for k, v in self.artifacts.items()])
+            txt += f"\nArtifacts:\n{ch}"
         if self.children:
             ch = "\n".join(
                 [
@@ -194,23 +207,32 @@ def pyproject(self):
                 pass
         return {}
 
-    @property
-    def artifacts(self) -> set:
+    def all_artifacts(self, names=None) -> list:
         """A flat list of all the artifact objects nested in this project."""
-        arts = set()
+        arts = set(self.artifacts.values())
         for spec in self.specs.values():
             arts.update(flatten(spec.artifacts))
         for child in self.children.values():
             arts.update(child.artifacts)
+        if names:
+            if isinstance(names, str):
+                names = {names}
+            arts = [
+                a
+                for a in arts
+                if any(a.snake_name() == camel_to_snake(n) for n in names)
+            ]
+        else:
+            arts = list(arts)
         return arts
 
-    def filter_by_type(self, types: Iterable[type]) -> bool:
+    def has_artifact_type(self, types: Iterable[type]) -> bool:
         """Answers 'does this project support outputting the given artifact type'
 
         This is an experimental example of filtering through projects
         """
         types = tuple(types)
-        return any(isinstance(_, types) for _ in self.artifacts)
+        return any(isinstance(_, types) for _ in self.all_artifacts())
 
     def __contains__(self, item) -> bool:
         """Is the given project type supported ANYWHERE in this directory?"""
@@ -222,6 +244,8 @@ def to_dict(self, compact=True) -> dict:
             children=self.children,
             url=self.url,
             storage_options=self.storage_options,
+            artifacts=self.artifacts,
+            contents=self.contents,
         )
         if not compact:
             dic["klass"] = "project"
@@ -346,11 +370,13 @@ def snake_name(cls) -> str:
 class ProjectExtra(ProjectSpec):
     """A special subcategory of project types with content but no structure.
 
-    Subclasses of this are special, in that they are not free-standing projects, but add
+    Subclasses of this are special: they are not free standing projects, but add
     contents onto the root project. Examples include data catalog specification, linters
-    and Ci/CD, that may be run against the root project without using a project-oriented
+    and CI/CD, that may be run against the root project without using a project-oriented
     tool.
 
     These classes do not appear in a Project's .specs, but do contribute .contents or
     .artifacts. They are still referenced when filtering spec types by name.
+
+    Commonly, subclasses are tied 1-1 to a particular content/artifact class.
     """

src/projspec/proj/ide.py

@@ -11,6 +11,9 @@ class NvidiaAIWorkbench(ProjectSpec):
     def match(self) -> bool:
         return self.proj.fs.exists(f"{self.proj.url}/.project/spec.yaml")
 
+    def parse(self) -> None:
+        ...
+
 
 class JetbrainsIDE(ProjectSpec):
     def match(self) -> bool:
@@ -25,9 +28,15 @@ class VSCode(ProjectSpec):
     def match(self) -> bool:
         return self.proj.fs.exists(f"{self.proj.url}/.vscode/settings.json")
 
+    def parse(self) -> None:
+        ...
+
 
 class Zed(ProjectSpec):
     spec_doc = "https://zed.dev/docs/configuring-zed#settings"
 
     def match(self) -> bool:
         return self.proj.fs.exists(f"{self.proj.url}/.zed/settings.json")
+
+    def parse(self) -> None:
+        ...

tests/test_basic.py

@@ -9,7 +9,7 @@
 def test_basic(proj):
     spec = proj.specs["python_library"]
     assert "wheel" in spec.artifacts
-    assert proj.artifacts
+    assert proj.all_artifacts()
     assert proj.children
     repr(proj)
     proj._repr_html_()
@@ -25,7 +25,7 @@ def test_contains(proj):
 
     assert proj.python_library is not None
     assert "python_library" in proj
-    assert proj.filter_by_type([Wheel])
+    assert proj.has_artifact_type([Wheel])
 
 
 def test_serialise(proj):