API Reference

class GearContext:
    """Context for gear runtime.

    * Provides methods for interacting with gear runtime objects such as:
        * `config.json` (Runtime configuration)
        * `manifest.json` (Defined configuration and gear metadata)
        * `.metadata.json` (Hierarchy metadata to be updated at end of gear run)
    * Configures gear logging


    Args:
        gear_path: Path to gear directory, default behavior will use `/flywheel/v0`.
        manifest_path: Path to the gear's manifest.json file,
            defaults to ``self.path/'manifest.json'``.
        config_path: Path to the gear's config.json file, defaults to
            ``self._path/'config.json'``.
        log_metadata: Whether to log .metadata.json to log upon write,
            defaults to True.
        clean_on_error: Whether to clean output directory upon exit
            with error, defaults to False.
    """

    def __init__(
        self,
        gear_path: t.Optional[str] = "/flywheel/v0",
        manifest_path: t.Optional[str] = "/flywheel/v0/manifest.json",
        config_path: t.Optional[str] = "/flywheel/v0/config.json",
        log_metadata: bool = True,
        fail_on_validation: bool = True,
        clean_on_error: bool = False,
    ):  # noqa: D107
        self._path = Path(gear_path or Path.cwd()).resolve()
        self.config = Config(None, self._load_json(config_path))
        self._client: t.Optional["flywheel.Client"] = self.get_client()
        self.config._client = self.config._client or self._client
        self._out_dir = None
        self._work_dir = None
        self._log_metadata = log_metadata
        self.fail_on_validation = fail_on_validation
        self._clean_on_error = clean_on_error
        self.manifest = None

        # Having a manifest.json is not required per gear specifications
        try:
            self.manifest = Manifest(manifest_path)
        except FileNotFoundError:
            log.debug(
                f"Manifest file not found at {manifest_path}. Continuing without manifest."
            )

        # Needs to be last
        self.metadata = Metadata(self)

    def init_logging(self, default_config_name=None, update_config=None):
        """Configures logging via `fw_gear.logging.configure_logging`.

        If no `default_config_name` is provided, will get `debug` from the
        configuration options. If `debug` is False or not defined in the gear
        configuration options, `default_config_name` will be set to info.

        If `update_config` is not provided, manifest['custom']['log_config'] will be
        used (if defined in the manifest).

        Args:
            default_config_name (str, optional): A string, 'info' or 'debug', indicating
                the default template to use. (Defaults to 'info').
            update_config (dict, optional): A dictionary containing the keys, sub-keys,
                and values of the templates to update. (Defaults to
                None).
        """
        if not default_config_name:
            if self.config.opts.get("debug"):
                default_config_name = "debug"
            else:
                default_config_name = "info"
        if not update_config:
            # Only try to get log_config from manifest if manifest exists
            if self.manifest is not None:
                if isinstance(self.manifest.get_value("custom"), dict):
                    update_config = self.manifest.get_value("custom").get(
                        "log_config", None
                    )

        configure_logging(
            default_config_name=default_config_name,
            update_config=update_config,
        )
        return default_config_name, update_config

    @property
    def work_dir(self) -> Path:
        """Get the absolute path to a work directory.

        Returns:
            pathlib.Path: The absolute path to work.
        """
        if self._work_dir is None:
            self._work_dir = self._path / "work"
            if not self._work_dir.exists():
                self._work_dir.mkdir(parents=True)
        return self._work_dir

    @property
    def output_dir(self) -> Path:
        """Get the absolute path to the output directory.

        Returns:
            pathlib.Path: The absolute path to outputs.
        """
        if self._out_dir is None:
            self._out_dir = self._path / "output"
            if not self._out_dir.exists():
                self._out_dir.mkdir(parents=True)
        return self._out_dir

    @property
    def client(self) -> t.Optional["flywheel.Client"]:  # noqa: D402
        """Wrapper around self.get_client()."""
        if not self._client:
            self._client = self.get_client()
        return self._client

    def is_fw_context(self) -> bool:
        """Return True if the gear is running in a Flywheel gear context, False otherwise."""

        gear_path = Path("/flywheel/v0")

        return gear_path.exists() and Path(gear_path / "config.json").exists()

    def get_client(self) -> t.Optional["flywheel.Client"]:
        """Get the SDK client, if an api key input exists or CLI client exists.

        Returns:
          flywheel.Client: The Flywheel SDK client.


        Raises:
            GearContextError: If the Flywheel SDK is not installed, no API key is found in `config.json`, or initializing the Flywheel Client fails.
        """
        if not HAVE_FLYWHEEL:
            warnings.warn(
                "Please install the `sdk` extra or install `flywheel-sdk` within"
                " your gear in order to use the SDK client."
            )
            return None
        api_key = None
        client = None

        for inp in self.config.inputs.values():
            if inp["base"] == "api-key" and inp["key"]:
                api_key = inp["key"]
                break
        if api_key:
            try:
                client = flywheel.Client(api_key)

            except Exception as exc:  # pylint: disable=broad-except
                log.exception(
                    "An exception was raised when initializing the Flywheel Client with the provided API key."
                )
                raise GearContextError(
                    "Failed to initialize the Flywheel Client with the provided API key."
                ) from exc
        return client

    def log_config(self):
        """Print the configuration and input files to the logger."""
        # Log destination
        log.info(
            "Destination is %s=%s",
            self.config.destination.get("type"),
            self.config.destination.get("id"),
        )

        # Log file inputs
        for inp_name, inp in self.config.inputs.items():
            if inp["base"] != "file":
                continue

            container_type = inp.get("hierarchy", {}).get("type")
            container_id = inp.get("hierarchy", {}).get("id")
            file_name = inp.get("location", {}).get("name")

            log.info(
                'Input file "%s" is %s from %s=%s',
                inp_name,
                file_name,
                container_type,
                container_id,
            )

        # Log configuration values
        for key, value in self.config.opts.items():
            log.info('Config "%s=%s"', key, value)

    def open_output(self, name: str, mode: str = "w", **kwargs) -> t.IO:
        """Open the named output file.

        Args:
            name: The name of the output.
            mode: The open mode (Default value = 'w').
            **kwargs (dict): Keyword arguments for `open`.

        Returns:
            File: The file object.
        """
        path = self.output_dir / name
        return path.open(mode, **kwargs)

    def get_context_value(self, name: str) -> t.Optional[dict]:
        """Get the context input for name.

        Args:
            name: The name of the input.

        Returns:
            dict: The input context value, or None if not found.
        """
        inp = self.config.get_input(name)
        if not inp:
            return None
        if inp["base"] != "context":
            raise ValueError(f"The specified input {name} is not a context input")
        return inp.get("value")

    def __enter__(self):  # noqa: D105
        return self

    def __exit__(self, exc_type, exc_value, _traceback):
        if exc_type is None or (
            issubclass(exc_type, SystemExit) and exc_value.code == 0
        ):
            self.metadata.update_zip_member_count(
                self.output_dir,
                container_type=self.config.destination.get("type"),
            )
            self.metadata.write(
                self.output_dir, self.fail_on_validation, self._log_metadata
            )
        elif self._clean_on_error:  # noqa: PLR5501
            log.info("Cleaning output folder.")
            self._clean_output()
        else:
            log.debug(f"Skipping cleanup of {self.output_dir}")

        if self._client:
            sdk_usage = getattr(
                self._client.api_client.rest_client, "request_counts", None
            )
            if not sdk_usage:
                log.debug("SDK profiling not available in this version of flywheel-sdk")
            else:
                log.debug(f"SDK usage:\n{pformat(sdk_usage, indent=2)}")

    def _clean_output(self):
        for path in Path(self.output_dir).glob("**/*"):
            if path.is_file():
                path.unlink()
            elif path.is_dir():
                rmtree(path)

    @staticmethod
    def _load_json(filepath):
        """Return dictionary for input json file.

        Args:
          filepath (str): Path to a JSON file.

        Raises:
            RuntimeError: If filepath cannot be parsed as JSON.

        Returns:
            (dict): The dictionary representation of the JSON file at filepath.
        """
        json_dict = dict()
        if os.path.isfile(filepath):
            try:
                with open(filepath, "r") as f:
                    json_dict = json.load(f)
            except json.JSONDecodeError:
                raise RuntimeError(f"Cannot parse {filepath} as JSON.")

        return json_dict

class Config:
    """Basic Config class akin to Manifest class.

    This class is mainly used as a helper for the
    `gear config create` function of the python-cli,
    however it may have unforeseen programmatic usages.

    There is some confusing nomenclature here.  The gear
    configuration is stored in a file named `config.json`,
    within the config.json file, there are at three keys:
        * config:  configuration options for the gear,
            often booleans, integers, floats, or short
            strings.
        * inputs: Gear inputs, usually in the form of files,
            longer text.
        * destination: Information on where the gear is
            being run within the flywheel hierarchy.

    This class represents the `config.json` file, meaning
    that is has attributes which store the configuration
    options, inputs, and destination. That means that the
    class `Config` has a `config` attribute (configuration
    options) and the constructor accepts a `config`
    dictionary that contains a `config` (configuration
    options) key.
    """

    def __init__(
        self,
        client: t.Optional["flywheel.Client"],
        config: t.Optional[dict],
        path: Path = Path.cwd(),
    ):
        """Load or generate config.

        Args:
            client: Optional flywheel SDK client.
            config: Config dictionary with any of
                the following keys: 'config','inputs','destination'.
                Defaults to None.
            path: Path to existing
                configuration or path to directory in which to create
                config. Defaults to Path.cwd().

        Raises:
            ConfigValidationError:
                1. When a config kwarg has been passed but is
                    not of type dict.
                2. When a config.json exists at the passed path,
                    but it is not valid JSON
                3. When a file is passed in for path, but it does
                    not exist.
        """
        self._opts = dict()
        self._inputs = dict()
        self._destination = dict()
        self._path = Path(path)
        self._job = dict()
        self._client = client
        if config is not None:
            self._load_config_from_dict(config)
        else:
            self._load_config_from_file()

    def _load_config_from_dict(self, config: dict):
        """Load config values from a provided dictionary."""
        if not isinstance(config, dict):
            raise ConfigValidationError("Passed in", ["Cannot read config"])

        self.opts = config.get("config", {})
        self.inputs = config.get("inputs", {})
        self.destination = config.get("destination", {})
        self.job = config.get("job", {})

    def _load_config_from_file(self):
        """Load config values from a JSON file."""
        if self._path.is_dir():
            self._path = self._path / "config.json"
        if not self._path.exists() or not self._path.is_file():
            raise ConfigValidationError(self._path, ["File doesn't exist"])

        try:
            with open(self._path, "r") as fp:
                cfg = json.load(fp)
            self.opts = cfg.get("config", {})
            self.inputs = cfg.get("inputs", {})
            self.destination = cfg.get("destination", {})
            self.job = cfg.get("job", {})
        except json.JSONDecodeError:
            raise ConfigValidationError(self._path, ["Cannot read config file"])

    @property
    def opts(self):
        """Get provided configuration values."""
        return self._opts

    @property
    def job(self):
        """Get provided job info when show-job set to true."""
        return self._job

    @property
    def inputs(self):
        """Get provided inputs."""
        return self._inputs

    @property
    def destination(self):
        """Get gear run destination."""
        return self._destination

    @opts.setter
    def opts(self, config: dict):
        """Set gear config (for use in building gear local runs)."""
        self._opts = config

    @job.setter
    def job(self, job: dict):
        """Set gear config (for use in building gear local runs)."""
        self._job = job

    @inputs.setter
    def inputs(self, inputs: dict):
        """Set gear inputs (for use in building gear local runs)."""
        self._inputs = inputs

    @destination.setter
    def destination(self, dest: dict):
        """Set gear destination (for use in building gear local runs)."""
        self._destination = dest

    def update_opts(self, vals: dict):
        """Perform dictionary update on configuration values."""
        self._opts.update(vals)

    def update_destination(self, dest: dict):
        """Perform dictionary on destination dictionary."""
        self._destination.update(dest)

    def add_input(
        self, name: str, val: str, type_: str = "file", file_: t.Optional[t.Any] = None
    ):
        """Add an input to the config.

        Args:
            name: name of input
            val (str): input value, file path, api-key, context
            type_: file, api-key, or context. Defaults to "file".
            file_: File object to set

        Raises:
            ValueError: When file doesn't exist.
            NotImplementedError: When type is not file or api-key
        """
        if type_ == "file":
            path = Path(val)
            try:
                stat_result = path.resolve().stat()
            except FileNotFoundError:
                raise ValueError(
                    f"Cannot resolve file input at {path}, is the path correct?"
                )

            if file_:
                obj = {
                    "size": file_.size,
                    "type": file_.type,
                    "mimetype": file_.mimetype,
                    "modality": file_.modality,
                    "classification": file_.classification,
                    "tags": file_.tags,
                    "info": file_.info,
                    "zip_member_count": file_.zip_member_count,
                    "version": file_.version,
                    "file_id": file_.file_id,
                    "origin": {"type": "user", "id": ""},
                }
            else:
                obj = {
                    "size": stat_result.st_size,
                    "type": None,
                    "mimetype": "application/octet-stream",
                    "modality": None,
                    "classification": {},
                    "tags": [],
                    "info": {},
                    "zip_member_count": None,
                    "version": 1,
                    "file_id": "",
                    "origin": {"type": "user", "id": ""},
                }
            file = {
                "base": "file",
                "location": {
                    "name": path.name,
                    "path": f"/flywheel/v0/input/{name}/{path.name}",
                },
                "object": obj,
            }
            self.inputs.update({name: file})
        elif type_ == "api-key":
            self.inputs.update({name: {"base": "api-key", "key": val}})
        else:
            raise NotImplementedError(f"Unknown input type {type_}")

    @classmethod
    def default_config_from_manifest(
        cls, manifest: t.Union[Path, Manifest]
    ) -> "Config":
        """Create a default config.json from a manifest file.

        Args:
            manifest: Path to manifest or instantiated Manifest object.

        Raises:
            ValueError: When there is a problem parsing the manifest.

        Returns:
            Config: new config class with a default configuration.
        """
        if not isinstance(manifest, Manifest):
            try:
                manifest = Manifest(manifest)
            except ManifestValidationError:
                raise ValueError("Could not load manifest to generate config")

        config = {}

        for k, v in manifest.config.items():
            if "default" in v:
                config[k] = v["default"]

        return cls(None, config={"config": config})

    def get_input(self, name: str) -> t.Optional[dict]:
        """Get raw input object by name.

        Args:
            name: Name of input.
        """
        return self._inputs.get(name)

    def get_input_path(self, name: str) -> t.Optional[Path]:
        """Get input filepath by name.

        Args:
            name: Input name

        Raises:
            ValueError: If found input is not a file.

        Returns:
            t.Optional[Path]: Input filepath if found
        """
        input_ = self.get_input(name)
        if input_ is None:
            return None
        if input_.get("base") != "file":
            raise ValueError(f"The specified input {name} is not a file")
        return input_.get("location", {}).get("path")

    def get_input_filename(self, name) -> t.Optional[str]:
        """Get the the filename of given input file.
        Sourced from the 'inputs' field in the manifest.json

        Args:
            name (str): The name of the input.

        Raises:
            ValueError: if the input exists, but is not a file.

        Returns:
            str: The filename to the input file if it exists, otherwise None.
        """
        input_ = self.get_input(name)
        if input_ is None:
            return None
        if input_.get("base") != "file":
            raise ValueError(f"The specified input {name} is not a file")
        return input_.get("location", {}).get("name")

    def get_input_file_object(self, name: str) -> t.Optional[dict]:
        """Get the specified input file object from config.json

        Args:
            name (str): The name of the input.

        Returns:
            dict: The input dictionary, or None if not found.
        """
        input_ = self.get_input(name)
        if input_ is None:
            return None
        if input_.get("base") != "file":
            raise ValueError(f"The specified input {name} is not a file")
        return input_.get("object")

    def get_input_file_object_value(self, name: str, key: str) -> t.Any:
        """Get the value of the input file metadata from config.json.

        Args:
            name (str): The name of the input.
            key (str): The name of the file container metadata.

        Raises:
            ValueError: if the input exists, but is not a file.

        Returns:
            Union[str, list, dict]: The value of the specified file metadata, or None if not found.

        """
        inp_obj = self.get_input_file_object(name)
        return inp_obj.get(key, None) if key in inp_obj.keys() else None

    def open_input(self, name: str, mode: str = "r", **kwargs) -> t.IO:
        """Open the named input file, derived from the 'inputs' field in the manifest.

        Args:
            name: The name of the input.
            mode: The open mode (Default value = 'r').
            **kwargs (dict): Keyword arguments for `open`.

        Raises:
            ValueError: If input `name` is not defined in config.json.
            FileNotFoundError: If the path in the config.json for input `name` is
                not a file/

        Returns:
            The file object.
        """
        path = self.get_input_path(name)
        if path is None:
            raise ValueError(f"Input {name} is not defined in the config.json")
        if not Path(path).is_file():
            raise FileNotFoundError(f"Input {name} does not exist at {path}")
        return open(path, mode, **kwargs)

    def get_destination_container(self):
        """Returns the destination container."""
        if not self._client:
            # Error that we need API key.
            unauthenticated("Config.get_destination_container")
        return get_container_from_ref(self._client, self.destination)

    def get_destination_parent(self):
        """Returns the parent container of the destination container."""
        if not self._client:
            # Error that we need API key.
            unauthenticated("Config.get_destination_container")
        dest = self.get_destination_container()
        return get_parent(self._client, dest)

    ############### Utilities
    def to_json(self, path: t.Optional[Path] = None):
        """Dump config to a file in config.json format."""
        to_write = {
            "config": self.opts,
            "inputs": self.inputs,
            "destination": self.destination,
        }
        with open(path if path is not None else str(self._path), "w") as fp:
            json.dump(to_write, fp, indent=4)

    def __str__(self):  # pragma: no cover
        """Return string representation."""
        to_write = {
            "config": self.opts,
            "inputs": self.inputs,
            "destination": self.destination,
        }
        return json.dumps(to_write, indent=4)

class Manifest:
    """A class to host a manifest and a methods around it.

    Args:
        manifest (Path-like or dict): Path to a manifest.json file or a manifest dictionary.
            If none is provided, try to load manifest.json from the current working directory.

    Attributes:
        manifest (dotty_dict.Dotty): Dictionary (dotty-enhanced version to be exact) of the
            manifest.json file.

    Raises:
        FileNotFoundError: If no manifest.json found
    """

    def __init__(self, manifest=None):  # noqa: D107
        self._schema = None
        self._path = None
        self._gear_spec_schema = None
        self.manifest = None
        if isinstance(manifest, dict):
            self.manifest = dotty(manifest)
        elif not manifest:  # noqa: PLR5501
            # look into current directory
            self._path = (Path(".") / "manifest.json").absolute()
            if not self._path.exists():
                raise FileNotFoundError(
                    f"manifest.json not found in cwd ({os.getcwd()}"
                )
            log.info("Using manifest.json in current working directory.")
            self.manifest = dotty(self.get_manifest_from_file(path=self._path))
        else:  # Load from path
            self._path = Path(manifest)
            self.manifest = dotty(self.get_manifest_from_file(path=self._path))

    @property
    def schema(self):
        """Returns the json schema definition of the manifest.json file."""
        if not self._schema:
            self._schema = get_master_schema()
        return self._schema

    @property
    def gear_spec_schema(self):
        """Returns the json schema of the gear spec."""
        if not self._gear_spec_schema:
            self._gear_spec_schema = get_master_gear_schema()
        return self._gear_spec_schema

    @property
    def author(self):
        """Returns manifest author."""
        return self.get_value("author")

    @property
    def config(self):
        """Returns manifest config."""
        return self.get_value("config")

    @property
    def description(self):
        """Returns manifest description."""
        return self.get_value("description")

    @property
    def inputs(self):
        """Returns manifest inputs."""
        return self.get_value("inputs")

    @property
    def label(self):
        """Returns manifest label."""
        return self.get_value("label")

    @property
    def license(self):
        """Returns manifest license."""
        return self.get_value("license")

    @property
    def name(self):
        """Returns manifest name."""
        return self.get_value("name")

    @property
    def source(self):
        """Returns manifest source."""
        return self.get_value("source")

    @property
    def url(self):
        """Returns manifest url."""
        return self.get_value("url")

    @property
    def version(self):
        """Returns manifest version."""
        return self.get_value("version")

    @property
    def environment(self):  # noqa: D102
        return self.get_value("environment")

    def __getitem__(self, dotty_key):
        """Return any value of the manifest by passing the dotty-dict key.

        Args:
            dotty_key (str): A string representing a key or nested key (e.g.
                custom.gear-builder.image)
        """
        return self.get_value(dotty_key)

    @staticmethod
    def get_manifest_from_file(path=None):
        """Returns the dictionary representation of the manifest.json at path.

        Args:
            path (Path-like): Path to manifest. If None, look for manifest.json in current
                directory.

        Returns:
            (dict): The manifest as a dictionary
        """
        if isinstance(path, str):
            path = Path(path)

        if not path.exists():
            raise FileNotFoundError(str(path))

        with open(path, "r") as fp:
            try:
                manifest = json.load(fp, object_pairs_hook=OrderedDict)
            except JSONDecodeError as e:
                raise ManifestValidationError(
                    path,
                    [f"Error decoding at line {e.lineno}, column {e.colno}"],
                )

        return manifest

    def get_value(self, dotty_key):
        """Returns value found at dotty_key (e.g. 'custom.gear-builder.image') if any.

        More on dotty-dict notation at [here](https://github.com/pawelzny/dotty_dict)

        Args:
            dotty_key (str): A string representing a key or nested key (e.g.
                custom.gear-builder.image)
        """
        return self.manifest.get(dotty_key)

    def to_json(self, path, validate=True, ensure_ascii=True):
        """Save as json file to `path`."""
        if not Path(path).name.endswith(".json"):
            raise ValueError("Incorrect path. Must end with .json")

        if validate:
            try:
                self.validate()
            except ManifestValidationError:
                log.warning("The saved manifest.json is invalid")

        with open(path, "w") as fp:
            json.dump(dict(self.manifest), fp, indent=2, ensure_ascii=ensure_ascii)

    def get_docker_image_name_tag(self):
        """Returns docker image tag from either locations.

        Look first at 'custom.gear-builder.image'. If not defined there, look at
        'custom.docker-image' and log a warning.
        """
        image = self.get_value("custom.gear-builder.image")
        if not image:
            deprecated_image = self.get_value("custom.docker-image")
            if deprecated_image:
                log.warning(
                    'Defining image in "custom.docker-image" is deprecated. '
                    'Please use "custom.gear-builder.image" instead'
                )
            image = None
        return image

    def validate(self, validate_classification=False):
        """Validates manifest.

        Raises:
            ManifestValidationError: If errors are found in the manifest.
        """
        errors = self._validate(validate_classification)
        if errors:
            raise ManifestValidationError(self._path, errors)

    def is_valid(self):
        """Returns True if manifest is valid, False otherwise."""
        try:
            self.validate()
        except ManifestValidationError:
            return False
        return True

    def _validate(self, validate_classification=False):
        """Runs validation checks on manifest.

        Returns:
            (list): List of errors found.
        """
        errors = []
        errors += self._validate_schema()
        errors += self._validate_config_default()
        errors += self._is_docker_image_defined()
        errors += self._is_version_matches()
        errors += self._is_docker_images_match()
        if validate_classification:
            errors += self._validate_gear_suite()
            errors += self._validate_gear_classification()
        # Don't need to enforce this
        # errors += self._is_docker_names_match()
        return errors

    def _validate_schema(self):
        """Validates the manifest against its schema definition."""
        validator = jsonschema.Draft4Validator(self.schema)
        errors = []
        for error in sorted(validator.iter_errors(dict(self.manifest)), key=str):
            errors.append(error.message)
        return errors

    def _validate_config_default(self):
        """Validate default value in manifest."""
        errors = []
        if "config" in self.manifest:
            config_schema = self.derive_config_schema(full=False)
            validator = jsonschema.Draft4Validator(config_schema)
            # mock a config dict with default values from manifest
            config = {
                "config": {
                    k: v["default"]
                    for k, v in self.manifest.get("config", {}).items()
                    if "default" in v
                }
            }

            for error in sorted(validator.iter_errors(config), key=str):
                errors.append(error.message)
        return errors

    def _validate_gear_suite(self):
        """Validates gear suite."""
        errors = []
        # get the suite
        manifest_suite = self.manifest.get("custom.flywheel.suite", None)

        # Check if the suite is missing
        if manifest_suite is None:
            errors += ["Suite is missing in manifest."]
        # Check if it is a string
        elif not isinstance(manifest_suite, str):
            errors += ["Suite must be a string"]

        # check if it is a valid suite
        suite_vals = self.gear_spec_schema["suite"]
        if manifest_suite not in suite_vals:
            errors += [
                f"Value {manifest_suite} not found in schema suite. Available values are {suite_vals}"
            ]
        return errors

    def _validate_gear_classification(self):
        """Validates gear classification."""
        errors = []
        manifest_classification = self.manifest.get(
            "custom.flywheel.classification", None
        )

        # Check if the classification is missing
        if manifest_classification is None:
            errors += ["Classification is missing in manifest."]
        # Check if it's a dictionary
        elif not isinstance(manifest_classification, dict):
            errors += ["Classification must be a dictionary"]
        else:
            # Iterate over the classification items and validate
            for classification, vals in manifest_classification.items():
                if classification not in self.gear_spec_schema.keys():
                    errors += [
                        f"Classification {classification} not found in gear spec schema"
                    ]
                    continue  # skip to the next classification if not found

                schema_val_list = self.gear_spec_schema[classification]

                for val in vals:
                    if val not in schema_val_list:
                        errors += [
                            f"Value {val} not found in {classification} classification"
                        ]
        return errors

    def derive_config_schema(self, full=True):
        """Returns json schema for config from manifest.

        Adapted from
        https://gitlab.com/flywheel-io/public/gears/-/blob/master/gears/generator.py#L66.

        Args:
            full (bool): Whether to derive a "full" config schema, to be used
                when validating a real config that has been populated.  Set
                "full" to false if you are just validating the default
                values in a config.
        """
        # Config jsonschema
        schema = {
            "title": "Config schema for manifest",
            "$schema": "http://json-schema.org/draft-04/schema#",
            "type": "object",
            "properties": {
                "config": {"type": "object", "properties": {}, "required": []},
            },
            "required": ["config"],
        }

        # Copy over constraints from manifest
        for key in self.manifest["config"]:
            # Copy constraints, removing 'base' and 'description' keywords which are not constraints
            value = copy.deepcopy(self.manifest["config"][key])
            value.pop("base", None)
            value.pop("description", None)
            optional = value.pop("optional", False)
            schema["properties"]["config"]["properties"][key] = value

            # Require the key be present unless optional flag is set.
            if not optional:
                # Always add the required key if full
                if full:
                    schema["properties"]["config"]["required"].append(key)
                # Else only add the required key if a default value is
                # specified (GEAR-1866)
                elif value.get("default"):
                    schema["properties"]["config"]["required"].append(key)

        # After handling each key, remove required array if none are present.
        # Required by jsonschema (minItems 1).
        if len(schema["properties"]["config"]["required"]) == 0:
            schema["properties"]["config"].pop("required", None)

        # Important: check our work - the schema must be a valid schema.
        jsonschema.Draft4Validator.check_schema(schema)

        return schema

    def _is_docker_image_defined(self):
        """Returns a list of errors if not defined."""
        errors = []
        docker_image = self.get_docker_image_name_tag()
        if not docker_image:
            errors += ['"custom.gear-builder.image" missing from manifest']
        return errors

    def _is_docker_images_match(self):
        """Returns a list of errors if docker images are different."""
        errors = []
        docker_image_1 = self.get_value("custom.gear-builder.image")
        docker_image_2 = self.get_value("custom.docker-image")
        if docker_image_1 and docker_image_2 and docker_image_1 != docker_image_2:
            errors += [
                '"custom.gear-builder.image" is different from "custom.docker-image"'
            ]
        return errors

    def _is_docker_names_match(self):
        """Returns a list of errors if docker name and image name are different."""
        errors = []
        docker_image = self.get_docker_image_name_tag()
        docker_name = self.name
        if docker_image and ":" in docker_image:
            im_path, _ = docker_image.split(":")
            if "/" in im_path:
                _, im_name = im_path.split("/")
                if im_name != docker_name:
                    errors += ['"custom.gear-builder.image" is different from "name"']
        return errors

    def _is_version_matches(self):
        """Returns a list of errors if version does not match."""
        errors = []
        docker_image = self.get_docker_image_name_tag()
        if docker_image and ":" in docker_image:
            _, im_tag = docker_image.split(":")
            if im_tag != self.version:
                errors += ["version and docker image tag do not match"]

        return errors