Run ruff format

Author: cderv

dev-docs/feature-format-matrix/create_table.py

@@ -2,8 +2,8 @@
 import json
 import pathlib
 
-class Trie:
 
+class Trie:
     def __init__(self):
         self.children = {}
         self.values = []
@@ -37,13 +37,12 @@ def tabulator(self):
             children = v.tabulator()
             feature = k
             if v.entry != "":
-                link = "<a href='%s' target='_blank'><i class='fa-solid fa-link' aria-label='link'></i></a>" % v.entry
+                link = (
+                    "<a href='%s' target='_blank'><i class='fa-solid fa-link' aria-label='link'></i></a>"
+                    % v.entry
+                )
                 feature = "%s %s" % (link, k)
-            d = {
-                "sort_key": k,
-                "feature": feature,
-                **v.tabulator_leaf()
-            }
+            d = {"sort_key": k, "feature": feature, **v.tabulator_leaf()}
             if children:
                 d["_children"] = children
             result.append(d)
@@ -60,13 +59,14 @@ def size(self):
             return 1
         return sum([v.size() for v in self.children.values()])
 
-    def walk(self, visitor, path = None):
+    def walk(self, visitor, path=None):
         if path is None:
             path = []
         visitor(self, path)
         for k, v in self.children.items():
             v.walk(visitor, path + [k])
 
+
 def extract_metadata_from_file(file):
     with open(file, "r") as f:
         lines = f.readlines()
@@ -78,10 +78,13 @@ def extract_metadata_from_file(file):
                 start = i
             else:
                 end = i
-                metadata = yaml.load("".join(lines[start+1:end]), Loader=yaml.SafeLoader)
+                metadata = yaml.load(
+                    "".join(lines[start + 1 : end]), Loader=yaml.SafeLoader
+                )
                 return metadata
     raise ValueError("No metadata found in file %s" % file)
 
+
 def table_cell(entry, _feature, _format_name, format_config):
     if type(format_config) == str:
         format_config = {}
@@ -90,8 +93,22 @@ def table_cell(entry, _feature, _format_name, format_config):
     if quality is not None:
         if type(quality) == str:
             quality = quality.lower()
-        qualities = {-1: "&#x1F6AB;", 0: "&#x26A0;", 1: "&#x2713;", 2: "&#x2713;&#x2713;", "unknown": "&#x2753;", "na": "NA"}
-        colors = {-1: "bad", 0: "ok", 1: "good", 2: "good", "unknown": "unknown", "na": "na"}
+        qualities = {
+            -1: "&#x1F6AB;",
+            0: "&#x26A0;",
+            1: "&#x2713;",
+            2: "&#x2713;&#x2713;",
+            "unknown": "&#x2753;",
+            "na": "NA",
+        }
+        colors = {
+            -1: "bad",
+            0: "ok",
+            1: "good",
+            2: "good",
+            "unknown": "unknown",
+            "na": "na",
+        }
         color = colors[quality]
         quality_icon = qualities.get(quality, "&#x2753;")
         result.append(f"<span class='{color}'>{quality_icon}</span>")
@@ -101,7 +118,8 @@ def table_cell(entry, _feature, _format_name, format_config):
         result.append(f"<span title='{comment}'>&#x1F4AC;</span>")
     return "".join(result)
 
-def compute_trie(detailed = False):
+
+def compute_trie(detailed=False):
     trie = Trie()
     pattern = "qmd-files/**/*.qmd" if detailed else "qmd-files/**/document.qmd"
     for entry in pathlib.Path(".").glob(pattern):
@@ -115,26 +133,37 @@ def compute_trie(detailed = False):
         except KeyError:
             raise Exception("No format found in %s" % entry)
         for format_name, format_config in format.items():
-            trie.insert(feature, {
-                "feature": "/".join(feature),
-                "format": format_name,
-                "entry": entry,
-                "format_config": format_config,
-                "table_cell": table_cell(entry, feature, format_name, format_config)
-            })
+            trie.insert(
+                feature,
+                {
+                    "feature": "/".join(feature),
+                    "format": format_name,
+                    "entry": entry,
+                    "format_config": format_config,
+                    "table_cell": table_cell(
+                        entry, feature, format_name, format_config
+                    ),
+                },
+            )
     return trie
 
-def render_features_formats_data(trie = None):
+
+def render_features_formats_data(trie=None):
     if trie is None:
         trie = compute_trie()
     entries = trie.tabulator()
-    return "```{=html}\n<script type='text/javascript'>\nvar tableData = %s;\n</script>\n```\n" % json.dumps(entries, indent=2)
+    return (
+        "```{=html}\n<script type='text/javascript'>\nvar tableData = %s;\n</script>\n```\n"
+        % json.dumps(entries, indent=2)
+    )
+
 
-def compute_quality_summary(trie = None):
+def compute_quality_summary(trie=None):
     if trie is None:
         trie = compute_trie()
     quality_summary = {"unknown": 0, -1: 0, 0: 0, 1: 0, 2: 0, "na": 0}
     n_rows = 0
+
     def visit(node, _path):
         nonlocal n_rows
         if not node.children or len(node.values):
@@ -149,5 +178,6 @@ def visit(node, _path):
             if quality_summary.get(quality) is None:
                 raise ValueError("Invalid quality value %s" % quality)
             quality_summary[quality] += 1
+
     trie.walk(visit)
-    return {"n_rows": n_rows, "quality": quality_summary}
+    return {"n_rows": n_rows, "quality": quality_summary}

quarto_cli/__init__.py

@@ -4,6 +4,7 @@
 from pathlib import Path
 import sys
 
+
 def find_version():
     g = str((Path(__file__).parent / "quarto-*").resolve())
     g = str((Path(glob.glob(g)[0]) / "bin" / "quarto").resolve())
@@ -12,8 +13,10 @@ def find_version():
         g += ".exe"
     return g
 
+
 def call_quarto(*args, **kwargs):
     return subprocess.run([find_version(), *sys.argv[1:], *args], **kwargs)
 
+
 def run_quarto(*args, **kwargs):
-    call_quarto(*args, **kwargs)
+    call_quarto(*args, **kwargs)

setup.py

@@ -16,6 +16,7 @@
 shutil.rmtree("build", ignore_errors=True)
 shutil.rmtree("quarto_cli.egg-info", ignore_errors=True)
 
+
 def get_platform_suffix():
     if sys.platform == "darwin":
         return "macos.tar.gz"
@@ -31,6 +32,7 @@ def get_platform_suffix():
     else:
         raise Exception("Platform not supported")
 
+
 def download_quarto(vers):
     global output_location
     global quarto_data
@@ -43,8 +45,28 @@ def download_quarto(vers):
         name, resp = urlretrieve(quarto_url)
     except Exception as e:
         print("Error downloading Quarto:", e)
-        commit=subprocess.run(["git","log","-1","--skip=1","--pretty=format:'%h'","--","version.txt"], check=True, text=True, capture_output=True, shell=True).stdout
-        version = subprocess.run(["git","show", commit.replace("'", "")+":version.txt"], check=True, capture_output=True, text=True, shell=True).stdout.replace("\n", "")
+        commit = subprocess.run(
+            [
+                "git",
+                "log",
+                "-1",
+                "--skip=1",
+                "--pretty=format:'%h'",
+                "--",
+                "version.txt",
+            ],
+            check=True,
+            text=True,
+            capture_output=True,
+            shell=True,
+        ).stdout
+        version = subprocess.run(
+            ["git", "show", commit.replace("'", "") + ":version.txt"],
+            check=True,
+            capture_output=True,
+            text=True,
+            shell=True,
+        ).stdout.replace("\n", "")
         quarto_url = f"https://github.com/quarto-dev/quarto-cli/releases/download/v{version}/quarto-{version}-{suffix}"
         name, resp = urlretrieve(quarto_url)
 
@@ -53,43 +75,48 @@ def download_quarto(vers):
 
     if suffix.endswith(".zip"):
         import zipfile
-        with zipfile.ZipFile(name, 'r') as zip_ref:
+
+        with zipfile.ZipFile(name, "r") as zip_ref:
             zip_ref.extractall(output_location)
     elif suffix.startswith("linux"):
         import tarfile
+
         with tarfile.open(name) as tf:
             tf.extractall(Path(output_location).parent.resolve())
     else:
         import tarfile
+
         with tarfile.open(name) as tf:
             tf.extractall(output_location)
 
     for path in glob.glob(str(Path(output_location, "**")), recursive=True):
         quarto_data.append(path.replace("quarto_cli" + os.path.sep, ""))
 
+
 def cleanup_quarto():
     shutil.rmtree(output_location)
 
+
 global version
 
 version = open("version.txt").read().strip()
 download_quarto(version)
 setup(
     version=version,
-    name='quarto_cli',
+    name="quarto_cli",
     install_requires=[
-        'jupyter',
-        'nbclient',
-        'wheel',
+        "jupyter",
+        "nbclient",
+        "wheel",
     ],
-    packages=find_packages(include=['quarto_cli', 'quarto_cli.*']),
+    packages=find_packages(include=["quarto_cli", "quarto_cli.*"]),
     entry_points={
-        'console_scripts': [
-            'quarto = quarto_cli:run_quarto',
+        "console_scripts": [
+            "quarto = quarto_cli:run_quarto",
         ]
     },
     package_data={
-        'quarto_cli': quarto_data,
+        "quarto_cli": quarto_data,
     },
     include_package_data=True,
 )

src/resources/capabilities/jupyter.py

@@ -2,35 +2,36 @@
 import os
 import importlib
 
-sys.stdout.write('versionMajor: ' + str(sys.version_info.major))
-sys.stdout.write('\nversionMinor: ' + str(sys.version_info.minor))
-sys.stdout.write('\nversionPatch: ' + str(sys.version_info.micro))
-sys.stdout.write('\nversionStr: "' + str(sys.version).replace('\n', ' ') + '"')
-if os.path.exists(os.path.join(sys.prefix, 'conda-meta', 'history')):
-  sys.stdout.write('\nconda: true')
+sys.stdout.write("versionMajor: " + str(sys.version_info.major))
+sys.stdout.write("\nversionMinor: " + str(sys.version_info.minor))
+sys.stdout.write("\nversionPatch: " + str(sys.version_info.micro))
+sys.stdout.write('\nversionStr: "' + str(sys.version).replace("\n", " ") + '"')
+if os.path.exists(os.path.join(sys.prefix, "conda-meta", "history")):
+    sys.stdout.write("\nconda: true")
 else:
-  sys.stdout.write('\nconda: false')
+    sys.stdout.write("\nconda: false")
 sys.stdout.write('\nexecPrefix: "' + sys.exec_prefix.replace("\\", "/") + '"')
 sys.stdout.write('\nexecutable: "' + sys.executable.replace("\\", "/") + '"')
 
+
 def discover_package(pkg):
-  sys.stdout.write('\n' + pkg + ': ')
-  v = 'null'
-  try:
+    sys.stdout.write("\n" + pkg + ": ")
+    v = "null"
     try:
-      from importlib.metadata import version
-      v = version(pkg)
-    except ImportError:
-      imp = importlib.import_module(pkg)
-      v = str(imp.__version__)
-  except Exception:
-    pass
-  sys.stdout.write(v)
- 
-discover_package('jupyter_core')  
-discover_package('nbformat')
-discover_package('nbclient')
-discover_package('ipykernel')
-discover_package('shiny')
+        try:
+            from importlib.metadata import version
+
+            v = version(pkg)
+        except ImportError:
+            imp = importlib.import_module(pkg)
+            v = str(imp.__version__)
+    except Exception:
+        pass
+    sys.stdout.write(v)
 
 
+discover_package("jupyter_core")
+discover_package("nbformat")
+discover_package("nbclient")
+discover_package("ipykernel")
+discover_package("shiny")