cola-cli 0.1.0__py3-none-any.whl

cola_cli/sources.py

@@ -0,0 +1,256 @@
+"""Source identity and snapshots. Language dependency solving belongs to their tools."""
+
+import fnmatch
+import hashlib
+import os
+import re
+import shutil
+import tempfile
+import tomllib
+from pathlib import Path
+from urllib.parse import urlparse
+
+from .common import ColaError, execute
+
+BUILTINS = {
+    "core": "https://github.com/Spectator-matter-group-INR-RAS/COLA.git",
+    "python": "https://github.com/ZakayZ/COLA-PY.git",
+    "julia": "https://github.com/ZakayZ/COLA_Julia.git",
+    "java": "https://github.com/ZakayZ/COLA_JVM.git",
+    "fortran": "https://github.com/ZakayZ/COLA_Fortran.git",
+}
+IGNORED = (
+    ".git",
+    ".venv",
+    ".gradle",
+    ".pytest_cache",
+    ".ruff_cache",
+    "__pycache__",
+    "*.egg-info",
+    "build",
+    "dist",
+    ".DS_Store",
+)
+IDENTIFIER = re.compile(r"[a-z][a-z0-9_-]{0,63}\Z")
+
+
+def name_check(name):
+    if not isinstance(name, str) or not IDENTIFIER.fullmatch(name):
+        raise ColaError(f"Invalid module name {name!r}; use lowercase letters, digits, '-' or '_'.")
+    return name
+
+
+def child(root, relative):
+    relative = Path(relative)
+    if relative.is_absolute() or ".." in relative.parts:
+        raise ColaError(f"Expected a relative subdirectory inside the repository: {relative}")
+    result = (root / relative).resolve()
+    if not result.is_relative_to(root.resolve()) or not result.is_dir():
+        raise ColaError(f"Source subdirectory does not exist inside {root}: {relative}")
+    return result
+
+
+def ignored(directory, names):
+    result = []
+    for name in names:
+        path = Path(directory) / name
+        generated_cmake = (
+            path.is_dir()
+            and any(fnmatch.fnmatch(name, pattern) for pattern in ("build-*", "build_*", "cmake-build-*"))
+            and ((path / "CMakeCache.txt").exists() or (path / "CMakeFiles").is_dir())
+        )
+        if generated_cmake or any(fnmatch.fnmatch(name, pattern) for pattern in IGNORED):
+            result.append(name)
+    return result
+
+
+def copy_source(source, destination):
+    """Copy build inputs, including untracked files, without modifying the checkout."""
+    for directory, dirs, files in os.walk(source, followlinks=False):
+        excluded = set(ignored(directory, dirs + files))
+        dirs[:] = [entry for entry in dirs if entry not in excluded]
+        for name in [*dirs, *(entry for entry in files if entry not in excluded)]:
+            path = Path(directory) / name
+            if path.is_symlink():
+                if path.is_dir() or not path.resolve().is_relative_to(source.resolve()):
+                    raise ColaError(f"Snapshot cannot include a directory or external symlink: {path}")
+    shutil.copytree(source, destination, ignore=ignored)
+
+
+def tree_hash(root):
+    digest = hashlib.sha256()
+    for path in sorted(root.rglob("*")):
+        if path.is_symlink():
+            raise ColaError(f"Unexpected symlink in stored source snapshot: {path}")
+        if path.is_file():
+            digest.update(path.relative_to(root).as_posix().encode())
+            digest.update(b"\0x\0" if path.stat().st_mode & 0o111 else b"\0-\0")
+            with path.open("rb") as stream:
+                for chunk in iter(lambda: stream.read(1024 * 1024), b""):
+                    digest.update(chunk)
+            digest.update(b"\0")
+    return digest.hexdigest()
+
+
+def source_spec(value, ref=None, subdirectory="."):
+    if value.startswith("github:"):
+        value = "https://github.com/" + value.removeprefix("github:").removesuffix(".git") + ".git"
+    if value.startswith(("https://", "ssh://", "git@", "file://")):
+        if value.startswith("https://") and urlparse(value).username:
+            raise ColaError("Use SSH or a Git credential helper; do not put credentials in the source URL.")
+        result = {"kind": "git", "url": value, "ref": ref or "HEAD"}
+    else:
+        path = Path(value).expanduser().resolve()
+        if not path.is_dir():
+            raise ColaError(f"No local source directory: {path}")
+        if ref:
+            # A local Git repository can also be used at an exact revision.
+            result = {"kind": "git", "url": path.as_uri(), "ref": ref}
+        else:
+            result = {"kind": "path", "path": str(path)}
+    if Path(subdirectory).is_absolute() or ".." in Path(subdirectory).parts:
+        raise ColaError("--subdirectory must stay inside the source repository.")
+    result["subdirectory"] = subdirectory
+    return result
+
+
+def snapshot(root, spec, *, commit=None):
+    (root / "tmp").mkdir(parents=True, exist_ok=True)
+    with tempfile.TemporaryDirectory(dir=root / "tmp") as temporary:
+        temporary = Path(temporary)
+        revision = None
+        if spec["kind"] == "git":
+            checkout = temporary / "checkout"
+            execute(["git", "clone", "--no-checkout", "--", spec["url"], checkout], capture=True)
+            ref = commit or spec["ref"]
+            command = ["git", "-C", checkout, "rev-parse", "--verify", "--end-of-options"]
+            try:
+                revision = execute([*command, ref + "^{commit}"], capture=True).strip()
+            except ColaError:
+                # clone creates only the default local branch; other branches are remote refs.
+                branch = ref.removeprefix("refs/heads/")
+                revision = execute([*command, f"refs/remotes/origin/{branch}^{{commit}}"], capture=True).strip()
+            execute(["git", "-C", checkout, "checkout", "--detach", revision], capture=True)
+            if (checkout / ".gitmodules").exists():
+                execute(["git", "-C", checkout, "submodule", "update", "--init", "--recursive"], capture=True)
+            origin = checkout
+        else:
+            origin = Path(spec["path"])
+        source = child(origin, spec["subdirectory"])
+        copied = temporary / "snapshot"
+        copy_source(source, copied)
+        identity = tree_hash(copied)
+        target = root / "sources" / identity
+        target.parent.mkdir(parents=True, exist_ok=True)
+        if target.exists():
+            if tree_hash(target) != identity:
+                raise ColaError(f"Source snapshot was modified: {target}")
+        else:
+            shutil.move(copied, target)
+        return {"sha256": identity, "commit": revision}
+
+
+def toml(path):
+    try:
+        return tomllib.loads(path.read_text(encoding="utf-8"))
+    except (OSError, ValueError) as error:
+        raise ColaError(f"Cannot read {path}: {error}") from error
+
+
+def describe(source, *, name=None, backend=None, libraries=(), depends=(), cmake_args=()):
+    descriptor = toml(source / "cola.toml").get("module", {}) if (source / "cola.toml").exists() else {}
+    if not isinstance(descriptor, dict):
+        raise ColaError("cola.toml must define a [module] table.")
+    for field in ("depends", "libraries", "cmake_args"):
+        value = descriptor.get(field, [])
+        if not isinstance(value, list) or not all(isinstance(item, str) for item in value):
+            raise ColaError(f"module.{field} must be an array of strings in cola.toml.")
+    py = toml(source / "pyproject.toml").get("project", {}) if (source / "pyproject.toml").exists() else {}
+    jl = toml(source / "Project.toml") if (source / "Project.toml").exists() else {}
+    cmake = (source / "CMakeLists.txt").read_text() if (source / "CMakeLists.txt").exists() else ""
+    project = re.search(r"\bproject\s*\(\s*([A-Za-z][A-Za-z0-9_-]*)", cmake, re.IGNORECASE)
+    project = project[1] if project else None
+    role = None
+    if py.get("name") == "colapy":
+        role, selected = "python", "python"
+    elif jl.get("uuid") == "e8fb5d31-b8d4-4e67-9fe8-a5a2e74aa831":
+        role, selected = "julia", "julia"
+    elif project in {"COLA", "COLA_Fortran", "COLA_JVM"}:
+        role = {"COLA": "core", "COLA_Fortran": "fortran", "COLA_JVM": "java"}[project]
+        selected = "cmake"
+    else:
+        selected = "python" if py else "julia" if jl else "cmake" if cmake else None
+    selected = backend or descriptor.get("backend") or selected
+    if selected not in {"python", "julia", "cmake"}:
+        raise ColaError("Cannot infer the build backend; provide cola.toml or --backend cmake/python/julia.")
+    inferred = py.get("name") if selected == "python" else jl.get("name") if selected == "julia" else project
+    identifier = name or descriptor.get("name") or role or (inferred or source.name).lower().replace(".", "-")
+    name_check(identifier)
+    if (role and identifier != role) or (identifier in BUILTINS and identifier != role):
+        raise ColaError(f"The names {', '.join(BUILTINS)} are reserved for the COLA core and bridges.")
+    requirements = list(depends or descriptor.get("depends", []))
+    if role != "core":
+        requirements.append("core")
+    if selected == "python" and role != "python":
+        requirements.append("python")
+    if selected == "julia" and role != "julia":
+        requirements.append("julia")
+    if "COLA_Fortran" in cmake and role != "fortran":
+        requirements.append("fortran")
+    if "COLA_JVM" in cmake and role != "java":
+        requirements.append("java")
+    requirements = sorted({name_check(entry) for entry in requirements})
+    if identifier in requirements:
+        raise ColaError(f"Module {identifier} depends on itself.")
+    default_libraries = {
+        "core": [],
+        "python": ["COLA-Py"],
+        "julia": ["COLA_Julia"],
+        "java": ["COLA_JVM"],
+        "fortran": [],
+    }
+    exported = list(libraries or descriptor.get("libraries", default_libraries.get(role, [project] if project else [])))
+    for library in exported:
+        if not isinstance(library, str) or not re.fullmatch(r"[A-Za-z][A-Za-z0-9_.-]*", library):
+            raise ColaError(f"Invalid COLA library name: {library!r}")
+    options = list(cmake_args or descriptor.get("cmake_args", []))
+    for option in options:
+        if (
+            not isinstance(option, str)
+            or not option.startswith("-D")
+            or any(key in option for key in ("CMAKE_INSTALL_PREFIX", "COLA_DIR", "COLA_INSTALL_PREFIX"))
+        ):
+            raise ColaError("cmake_args must be -D definitions and cannot override the managed installation prefix.")
+    return {
+        "name": identifier,
+        "backend": selected,
+        "role": role,
+        "depends": requirements,
+        "libraries": exported,
+        "cmake_args": options,
+        "package": py.get("name") if selected == "python" else jl.get("name") if selected == "julia" else None,
+        "version": py.get("version") if selected == "python" else jl.get("version"),
+    }
+
+
+def ordered(modules):
+    """Only order explicitly selected modules; do not implement a version solver."""
+    result, visiting, visited = [], set(), set()
+
+    def visit(name):
+        if name not in modules:
+            raise ColaError(f"Required module {name!r} is missing; add it before building.")
+        if name in visiting:
+            raise ColaError(f"Dependency cycle involving {name}.")
+        if name in visited:
+            return
+        visiting.add(name)
+        for requirement in modules[name]["depends"]:
+            visit(requirement)
+        visiting.remove(name)
+        visited.add(name)
+        result.append(name)
+
+    for name in modules:
+        visit(name)
+    return result

cola_cli/templates/common/.editorconfig.j2

@@ -0,0 +1,15 @@
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+insert_final_newline = true
+trim_trailing_whitespace = true
+indent_style = space
+indent_size = 4
+
+[*.{cc,cpp,hh,hpp}]
+indent_size = 2
+
+[*.{yml,yaml,xml}]
+indent_size = 2

cola_cli/templates/common/.gitignore.j2

@@ -0,0 +1,20 @@
+/build/
+/dist/
+/.venv/
+/.gradle/
+/.idea/
+/.vscode/
+__pycache__/
+*.py[cod]
+*.egg-info/
+.pytest_cache/
+*.mod
+*.smod
+*.o
+*.so
+*.dylib
+*.class
+*.jar
+CMakeUserPresets.json
+compile_commands.json
+.DS_Store

cola_cli/templates/common/cola.toml.j2

@@ -0,0 +1,8 @@
+[module]
+name = "{{ name.lower() }}"
+backend = "{{ language if language in ['python', 'julia'] else 'cmake' }}"
+{% if language in ['cpp', 'fortran', 'java'] %}
+libraries = ["{{ name }}"]
+{% else %}
+libraries = []
+{% endif %}

cola_cli/templates/cpp/.clang-format.j2

@@ -0,0 +1,6 @@
+BasedOnStyle: Google
+IndentWidth: 2
+ColumnLimit: 100
+PointerAlignment: Left
+SortIncludes: CaseSensitive
+AllowShortFunctionsOnASingleLine: Empty

cola_cli/templates/cpp/.clang-tidy.j2

@@ -0,0 +1,4 @@
+Checks: '-*,clang-analyzer-*,bugprone-*,performance-*,modernize-use-override,modernize-use-nullptr'
+WarningsAsErrors: '*'
+HeaderFilterRegex: '.*/include/.*'
+FormatStyle: file

cola_cli/templates/cpp/CMakeLists.txt.j2

@@ -0,0 +1,51 @@
+cmake_minimum_required(
+    VERSION
+        3.20
+)
+project(
+    {{ name }}
+    VERSION
+        {{ version }}
+    LANGUAGES
+        CXX
+)
+find_package(
+    COLA
+    CONFIG
+    REQUIRED
+)
+
+# Compile the declarations. Switch OBJECT to SHARED after implementing the module.
+add_library(
+    {{ name }}
+    OBJECT
+    src/{{ name }}.cc
+)
+target_compile_features(
+    {{ name }}
+    PUBLIC
+        cxx_std_17
+)
+target_include_directories(
+    {{ name }}
+    PUBLIC
+        "${CMAKE_CURRENT_SOURCE_DIR}/include"
+)
+target_link_libraries(
+    {{ name }}
+    PUBLIC
+        COLA
+)
+target_compile_options(
+    {{ name }}
+    PRIVATE
+        "$<$<CXX_COMPILER_ID:GNU,Clang,AppleClang>:-Wall;-Wextra;-Wpedantic>"
+)
+set_target_properties(
+    {{ name }}
+    PROPERTIES
+        POSITION_INDEPENDENT_CODE
+        TRUE
+)
+# Once the target is SHARED and LoadCOLAModule is defined:
+# install(TARGETS {{ name }} LIBRARY DESTINATION lib/{{ name }})

cola_cli/templates/cpp/include/{{ name }}.hh.j2

@@ -0,0 +1,23 @@
+#pragma once
+
+#include <COLA.hh>
+#include <memory>
+
+namespace {{ package }} {
+class Generator : public cola::VGenerator {
+ public:
+  std::unique_ptr<cola::EventData> operator()() override;
+};
+
+class Converter : public cola::VConverter {
+ public:
+  std::unique_ptr<cola::EventData> operator()(std::unique_ptr<cola::EventData>&& data) override;
+};
+
+class Writer : public cola::VWriter {
+ public:
+  void operator()(std::unique_ptr<cola::EventData>&& data) override;
+};
+}  // namespace {{ package }}
+
+extern "C" cola::VModule* LoadCOLAModule();

cola_cli/templates/cpp/src/{{ name }}.cc.j2

@@ -0,0 +1,3 @@
+#include "{{ name }}.hh"
+
+// Implement the declared generator, converter, writer and module entry point here.

cola_cli/templates/fortran/.fprettify.rc.j2

@@ -0,0 +1,2 @@
+indent = 4
+line-length = 100

cola_cli/templates/fortran/CMakeLists.txt.j2

@@ -0,0 +1,63 @@
+cmake_minimum_required(
+    VERSION
+        3.20
+)
+project(
+    {{ name }}
+    VERSION
+        {{ version }}
+    LANGUAGES
+        CXX
+        Fortran
+)
+find_package(
+    COLA_Fortran
+    CONFIG
+    REQUIRED
+)
+include(
+    GNUInstallDirs
+)
+
+# Fill in the filter procedure bodies before running the module.
+add_cola_fortran_library(
+    {{ name }}
+    SOURCES
+    src/{{ name }}.f90
+)
+target_include_directories(
+    {{ name }}
+    PRIVATE
+        "${CMAKE_CURRENT_BINARY_DIR}/generated"
+        "${CMAKE_CURRENT_BINARY_DIR}/modules"
+)
+set_target_properties(
+    {{ name }}
+    PROPERTIES
+        VERSION
+        "${PROJECT_VERSION}"
+        SOVERSION
+        "${PROJECT_VERSION_MAJOR}"
+        INSTALL_RPATH_USE_LINK_PATH
+        TRUE
+)
+if (CMAKE_Fortran_COMPILER_ID
+    STREQUAL
+    "GNU"
+)
+    target_compile_options(
+        {{ name }}
+        PRIVATE
+            "$<$<COMPILE_LANGUAGE:Fortran>:-Wall;-Wextra;-Wimplicit-interface>"
+            "$<$<AND:$<COMPILE_LANGUAGE:Fortran>,$<CONFIG:Debug>>:-fcheck=all;-fbacktrace>"
+    )
+endif (
+
+)
+install(
+    TARGETS
+        {{ name }}
+    LIBRARY
+        DESTINATION
+            ${CMAKE_INSTALL_LIBDIR}/{{ name }}
+)

cola_cli/templates/fortran/src/{{ name }}.f90.j2

@@ -0,0 +1,73 @@
+module {{ package }}
+    use cola, only: AbstractFortranGenerator, AbstractFortranConverter, AbstractFortranWriter, &
+                    EventData, ParametersMap
+    implicit none
+    private
+
+    type, public, extends(AbstractFortranGenerator) :: Generator
+    contains
+        procedure :: init => generator_init
+        procedure :: run => generator_run
+    end type Generator
+
+    type, public, extends(AbstractFortranConverter) :: Converter
+    contains
+        procedure :: init => converter_init
+        procedure :: run => converter_run
+    end type Converter
+
+    type, public, extends(AbstractFortranWriter) :: Writer
+    contains
+        procedure :: init => writer_init
+        procedure :: run => writer_run
+    end type Writer
+
+contains
+    subroutine generator_init(self, pmap, err)
+        class(Generator), intent(inout) :: self
+        type(ParametersMap), intent(in) :: pmap
+        character(len=:), allocatable, intent(out) :: err
+
+        ! TODO: Implement this procedure and assign its output arguments.
+    end subroutine generator_init
+
+    function generator_run(self, err) result(ed)
+        class(Generator), intent(in) :: self
+        character(len=:), allocatable, intent(out) :: err
+        type(EventData) :: ed
+
+        ! TODO: Implement this procedure and assign its output arguments.
+    end function generator_run
+
+    subroutine converter_init(self, pmap, err)
+        class(Converter), intent(inout) :: self
+        type(ParametersMap), intent(in) :: pmap
+        character(len=:), allocatable, intent(out) :: err
+
+        ! TODO: Implement this procedure and assign its output arguments.
+    end subroutine converter_init
+
+    subroutine converter_run(self, ed, err)
+        class(Converter), intent(in) :: self
+        type(EventData), intent(inout) :: ed
+        character(len=:), allocatable, intent(out) :: err
+
+        ! TODO: Implement this procedure and assign its output arguments.
+    end subroutine converter_run
+
+    subroutine writer_init(self, pmap, err)
+        class(Writer), intent(inout) :: self
+        type(ParametersMap), intent(in) :: pmap
+        character(len=:), allocatable, intent(out) :: err
+
+        ! TODO: Implement this procedure and assign its output arguments.
+    end subroutine writer_init
+
+    subroutine writer_run(self, ed, err)
+        class(Writer), intent(in) :: self
+        type(EventData), intent(in) :: ed
+        character(len=:), allocatable, intent(out) :: err
+
+        ! TODO: Implement this procedure and assign its output arguments.
+    end subroutine writer_run
+end module {{ package }}

cola_cli/templates/java/CMakeLists.txt.j2

@@ -0,0 +1,33 @@
+cmake_minimum_required(
+    VERSION
+        3.20
+)
+project(
+    {{ name }}
+    VERSION
+        {{ version }}
+    LANGUAGES
+        CXX
+)
+find_package(
+    COLA_JVM
+    CONFIG
+    REQUIRED
+)
+include(
+    GNUInstallDirs
+)
+
+# Implement the methods and make the registered classes concrete before running.
+# This helper builds and installs both the native module and its JAR.
+add_cola_gradle_library(
+    {{ name }}
+    JAR
+    "build/libs/{{ name }}-all.jar"
+    GENERATORS
+    "{{ name }}Generator=org.cola.generated.{{ package }}.{{ name }}Generator"
+    CONVERTERS
+    "{{ name }}Converter=org.cola.generated.{{ package }}.{{ name }}Converter"
+    WRITERS
+    "{{ name }}Writer=org.cola.generated.{{ package }}.{{ name }}Writer"
+)

cola_cli/templates/java/build.gradle.kts.j2

@@ -0,0 +1,35 @@
+plugins {
+    java
+    checkstyle
+}
+
+version = "{{ version }}"
+repositories { mavenCentral() }
+val colaJvmApi = providers.gradleProperty("colaJvmApi")
+dependencies {
+    if (colaJvmApi.isPresent) {
+        compileOnly(files(colaJvmApi.get()))
+    } else {
+        compileOnly("io.github.zakayz:cola-jvm-api:0.1.0")
+    }
+}
+
+tasks.withType<JavaCompile>().configureEach {
+    options.release.set(17)
+    options.encoding = "UTF-8"
+    options.compilerArgs.addAll(listOf("-Xlint:all", "-Werror"))
+}
+checkstyle {
+    toolVersion = "10.26.1"
+    configFile = file("config/checkstyle/checkstyle.xml")
+    isIgnoreFailures = false
+    maxWarnings = 0
+}
+
+tasks.register<Jar>("colaJar") {
+    archiveFileName.set("{{ name }}-all.jar")
+    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+    from(sourceSets.main.get().output)
+    dependsOn(configurations.runtimeClasspath)
+    from({ configurations.runtimeClasspath.get().map { if (it.isDirectory) it else zipTree(it) } })
+}

cola_cli/templates/java/config/checkstyle/checkstyle.xml.j2

@@ -0,0 +1,19 @@
+<?xml version="1.0"?>
+<!DOCTYPE module PUBLIC "-//Checkstyle//DTD Checkstyle Configuration 1.3//EN"
+    "https://checkstyle.org/dtds/configuration_1_3.dtd">
+<module name="Checker">
+  <property name="charset" value="UTF-8"/>
+  <module name="FileTabCharacter"/>
+  <module name="NewlineAtEndOfFile"/>
+  <module name="LineLength">
+    <property name="max" value="100"/>
+  </module>
+  <module name="TreeWalker">
+    <module name="UnusedImports"/>
+    <module name="AvoidStarImport"/>
+    <module name="NeedBraces"/>
+    <module name="TypeName"/>
+    <module name="MethodName"/>
+    <module name="ModifierOrder"/>
+  </module>
+</module>

cola_cli/templates/java/settings.gradle.kts.j2

@@ -0,0 +1 @@
+rootProject.name = "{{ name }}"

cola_cli/templates/java/src/main/java/org/cola/generated/{{ package }}/{{ name }}Converter.java.j2

@@ -0,0 +1,9 @@
+package org.cola.generated.{{ package }};
+
+import org.cola.api.Converter;
+import org.cola.api.EventData;
+
+public abstract class {{ name }}Converter implements Converter {
+    @Override
+    public abstract EventData convert(EventData event);
+}

cola_cli/templates/java/src/main/java/org/cola/generated/{{ package }}/{{ name }}Generator.java.j2

@@ -0,0 +1,9 @@
+package org.cola.generated.{{ package }};
+
+import org.cola.api.EventData;
+import org.cola.api.Generator;
+
+public abstract class {{ name }}Generator implements Generator {
+    @Override
+    public abstract EventData generate();
+}

cola_cli/templates/java/src/main/java/org/cola/generated/{{ package }}/{{ name }}Writer.java.j2

@@ -0,0 +1,9 @@
+package org.cola.generated.{{ package }};
+
+import org.cola.api.EventData;
+import org.cola.api.Writer;
+
+public abstract class {{ name }}Writer implements Writer {
+    @Override
+    public abstract void write(EventData event);
+}

cola_cli/templates/julia/.JuliaFormatter.toml.j2

@@ -0,0 +1,2 @@
+indent = 4
+margin = 100

cola_cli/templates/julia/Project.toml.j2

@@ -0,0 +1,10 @@
+name = "{{ name }}"
+uuid = "{{ uuid }}"
+version = "{{ version }}"
+
+[deps]
+COLA = "e8fb5d31-b8d4-4e67-9fe8-a5a2e74aa831"
+
+[compat]
+COLA = "0.2"
+julia = "1.10"