gialint 0.1.0__tar.gz

gialint-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BMCV
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

gialint-0.1.0/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: gialint
+Version: 0.1.0
+Summary: Linter for tool wrappers in Galaxy Image Analysis
+Home-page: https://kostrykin.com
+Author: Leonid Kostrykin
+Author-email: leonid.kostrykin@bioquant.uni-heidelberg.de
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: galaxy-util>=25.0
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: Cheetah3>=3.2.6.post1
+Requires-Dist: pyyaml>=6.0.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

gialint-0.1.0/README.md

@@ -0,0 +1,13 @@
+# galaxy-image-analysis-lint
+
+[![Coverage](https://img.shields.io/endpoint?url=https://gist.githubusercontent.com/kostrykin/fff2bce97225bf905bae26d517a6c41c/raw/gialint.json)](https://github.com/BMCV/galaxy-image-analysis-lint/actions/workflows/testsuite.yml)
+
+Example usage:
+```bash
+python -m gialint --tool_path ../galaxy-image-analysis/tools/
+```
+
+Run tests:
+```bash
+python -m unittest
+```

gialint-0.1.0/gialint/__init__.py

@@ -0,0 +1,21 @@
+from . import codes
+from .version import __version__
+
+__all__ = [
+    '__version__',
+    'codes',
+    'list_codes',
+    'check',
+]
+
+
+def list_codes():
+    for attr in dir(codes):
+        if attr.startswith('GIA'):
+            yield attr
+
+
+def check(code, tool_xml_root):
+    check_name = f'_checks.{code.lower()}'
+    check_module = __import__(check_name, globals(), locals(), fromlist=['*'], level=1)
+    yield from check_module.check(tool_xml_root)

gialint-0.1.0/gialint/__main__.py

@@ -0,0 +1,101 @@
+import argparse
+import pathlib
+import sys
+
+import yaml
+from galaxy.util import xml_macros
+
+from . import (
+    check,
+    codes,
+    list_codes,
+)
+from ._context import Context
+
+# Monkey-patch `xml_macros` to not remove comments:
+xml_macros.raw_xml_tree = lambda path: (
+    xml_macros.parse_xml(path, strip_whitespace=False, remove_comments=False)
+)
+
+gialint_root_path = pathlib.Path(__file__).parent
+
+parser = argparse.ArgumentParser()
+parser.add_argument('--tool_path', required=False, type=str)
+parser.add_argument('--ignore', action='append', type=str, default=list())
+parser.add_argument('--details_indent', type=int, default=4)
+parser.add_argument('--config', type=str, default='.gialint.yml')
+args = parser.parse_args()
+
+# Load config (empty if not specified)
+config = dict()
+if args.config:
+    config_filepath = pathlib.Path(args.config)
+    if config_filepath.is_file():
+        with config_filepath.open('r') as fp:
+            config = yaml.safe_load(fp)
+
+
+def list_tool_xml(path):
+    if path.is_file():
+        yield path
+    else:
+        for xml_path in path.glob('**/*.xml'):
+            yield xml_path
+
+
+def list_violations(tool_xml_path, ignore_codes):
+    for code in list_codes():
+
+        # Skip the check if it was passed via `--ignore`
+        if code in ignore_codes:
+            continue
+
+        # Skip the check if it was listed in the `--config` file
+        skip = False
+        for pattern, c in config.items():
+            if pathlib.Path(tool_xml_path).match(pattern) and (
+                code in filter(lambda s: s.strip(), c.get('ignore', list()))
+            ):
+                skip = True
+                break
+        if skip:
+            continue
+
+        # Run the checks
+        for info in check(code, tree.getroot()):
+            if isinstance(info, int):
+                info = dict(line=info)
+            yield Context(code, getattr(codes, code), tool_xml_path, **info)
+
+
+working_path = pathlib.Path(args.tool_path) or pathlib.Path.cwd()
+violations_count = 0
+for tool_xml_path in list_tool_xml(working_path):
+    tree = xml_macros.load(tool_xml_path)
+    if tree.getroot().tag == 'tool':
+
+        sys.stdout.write(f'Linting {tool_xml_path}... ')
+        sys.stdout.flush()
+        violations = list(list_violations(tool_xml_path, args.ignore))
+
+        if violations:
+            print('FAILED')
+            print()
+            for context in violations:
+                print(str(context), file=sys.stderr)
+                if context.details:
+                    print(
+                        '\n'.join(
+                            (
+                                ' ' * args.details_indent + line
+                                for line in str(context.details).splitlines()
+                            ),
+                        ),
+                        file=sys.stderr,
+                    )
+            print()
+        else:
+            print('OK')
+        violations_count += len(violations)
+
+exit(violations_count)

gialint-0.1.0/gialint/_checks/gia101.py

@@ -0,0 +1,8 @@
+def check(tool_xml_root):
+    for param in tool_xml_root.findall(".//inputs//param[@type='data']"):
+        formats = [fmt.strip().lower() for fmt in param.get('format', '').split(',')]
+        if (
+            ('tabular' in formats) != ('tsv' in formats) or
+            ('csv' in formats and 'tsv' not in formats)
+        ):
+            yield param.sourceline

gialint-0.1.0/gialint/_checks/gia102.py

@@ -0,0 +1,12 @@
+def check(tool_xml_root):
+    for path in (
+        'inputs//param[@type="data"]',
+        'outputs/data',
+    ):
+        for param in tool_xml_root.findall(f'.//{path}'):
+            formats = [fmt.strip().lower() for fmt in param.get('format', '').split(',')]
+            if 'tif' in formats or param.get('from_work_dir', '').strip().lower().endswith('.tif'):
+                yield param.sourceline
+    for param in tool_xml_root.findall('.//tests/test//param'):
+        if param.get('ftype', '').strip().lower() == 'tif' or param.get('value', '').strip().lower().endswith('.tif'):
+            yield param.sourceline

gialint-0.1.0/gialint/_checks/gia201.py

@@ -0,0 +1,20 @@
+from ..utils import get_full_name
+
+
+def check(tool_xml_root):
+    commands = tool_xml_root.findall('./command')
+    command = commands[0].text if commands else None
+    for param in tool_xml_root.findall('.//inputs//param[@type="data"]'):
+        formats = [fmt.strip().lower() for fmt in param.get('format', '').split(',')]
+        if 'zarr' in formats or 'ome.zarr' in formats:
+            full_param_name = get_full_name(param)
+            if command is None or not all(
+                (
+                    token in command
+                    for token in (
+                        f'${full_param_name}.extension',
+                        f'${full_param_name}.extra_files_path/${full_param_name}.metadata.store_root',
+                    )
+                )
+            ):
+                yield param.sourceline

gialint-0.1.0/gialint/_checks/gia202.py

@@ -0,0 +1,45 @@
+from Cheetah import NameMapper
+from Cheetah.Parser import ParseError
+from Cheetah.Template import Template
+
+from ..utils import (
+    flat_dict_to_nested,
+    get_base_namespace,
+    get_test_inputs,
+    list_tests,
+)
+
+
+def check(tool_xml_root):
+    base_namespace = get_base_namespace(tool_xml_root)
+    for path in (
+        'command',
+        'configfiles/configfile',
+    ):
+        for template in tool_xml_root.findall(f'./{path}'):
+
+            # Test build the template
+            try:
+                Template(template.text, searchList=dict())
+            except ParseError as error:
+                yield dict(
+                    line=template.sourceline,
+                    details=error,
+                )
+                continue
+
+            # Build the template for each test (with the corresponding namespace)
+            if (inputs_xml_list := tool_xml_root.findall(f'./inputs')):
+                inputs_xml = inputs_xml_list[0]
+                for test_num, test_xml in enumerate(list_tests(tool_xml_root), start=1):
+                    namespace = base_namespace | flat_dict_to_nested(get_test_inputs(inputs_xml, test_xml))
+                    try:
+                        str(Template(template.text, searchList=namespace))
+                    except (
+                        NameMapper.NotFound,
+                        TypeError,
+                    ) as error:
+                        yield dict(
+                            line=template.sourceline,
+                            details=f'{error} from test {test_num} (line {test_xml.sourceline})',
+                        )

gialint-0.1.0/gialint/_checks/gia203.py

@@ -0,0 +1,36 @@
+import json
+import textwrap
+
+from Cheetah import NameMapper
+from Cheetah.Parser import ParseError
+from Cheetah.Template import Template
+
+from ..utils import (
+    flat_dict_to_nested,
+    get_base_namespace,
+    get_test_inputs,
+    list_tests,
+)
+
+
+def check(tool_xml_root):
+    base_namespace = get_base_namespace(tool_xml_root)
+    if (inputs_xml_list := tool_xml_root.findall(f'./inputs')):
+        inputs_xml = inputs_xml_list[0]
+        for test_num, test_xml in enumerate(list_tests(tool_xml_root), start=1):
+            for template in tool_xml_root.findall(f'./configfiles/configfile'):
+                namespace = base_namespace | flat_dict_to_nested(get_test_inputs(inputs_xml, test_xml))
+                try:
+                    s = str(Template(template.text, searchList=namespace))
+                    try:
+                        json.loads(s)
+                    except json.JSONDecodeError:
+                        yield dict(
+                            line=template.sourceline,
+                            details=(
+                                f'from test {test_num} (line {test_xml.sourceline}):\n' +
+                                textwrap.dedent(s).strip()
+                            ),
+                        )
+                except (ParseError, NameMapper.NotFound):
+                    pass  # parse errors are handled by a dedicated check

gialint-0.1.0/gialint/_checks/gia204.py

@@ -0,0 +1,99 @@
+import difflib
+import pathlib
+import textwrap
+
+from Cheetah import NameMapper
+from Cheetah.Parser import ParseError
+from Cheetah.Template import Template
+
+from ..utils import (
+    flat_dict_to_nested,
+    get_base_namespace,
+    get_test_inputs,
+    list_tests,
+)
+
+prefix = pathlib.Path(__file__).stem.upper() + ':'  # GIA204:
+
+
+def _xpath_or_none(root, xpath: str):
+    if (result := root.xpath(xpath)):
+        return result[0]
+    else:
+        return None
+
+
+def _list_nonempty_lines(s: str) -> list[str]:
+    return list(
+        filter(
+            lambda line: len(line.strip()) > 0,
+            s.splitlines(),
+        ),
+    )
+
+
+def check(tool_xml_root):
+    templates = {
+        template.attrib.get('name', ''): template
+        for template in tool_xml_root.xpath('./command | ./configfiles/configfile')
+    }
+
+    # Validate that annotations correspond to valid templates
+    for test_xml in list_tests(tool_xml_root):
+        for comment in test_xml.xpath(
+            f'./comment()[starts-with(normalize-space(.), "{prefix}")]',
+        ):
+            comment_text = textwrap.dedent(comment.text).strip()
+            header = _list_nonempty_lines(comment_text)
+
+            # Do not strip this, because the `xpath` lookup below requires the original tokens:
+            template_id = header.pop(0).removeprefix(prefix).removeprefix(' ')
+
+            # Validate that `template_id` is a valid template
+            if template_id not in templates.keys():
+                yield dict(
+                    line=comment.sourceline,
+                    details=f'No such template: "{template_id}"',
+                )
+
+    # Build and validate the template for each test (with the corresponding namespace)
+    base_namespace = get_base_namespace(tool_xml_root)
+    for template_id, template in templates.items():
+
+        # Find tests that have templates defined for the check
+        if (inputs_xml_list := tool_xml_root.findall(f'./inputs')):
+            inputs_xml = inputs_xml_list[0]
+            for test_xml in list_tests(tool_xml_root):
+                full_prefix = f'{prefix} {template_id}' if template_id else prefix
+                if (
+                    comment := _xpath_or_none(
+                        test_xml,
+                        f'./comment()[starts-with(normalize-space(.), "{full_prefix}")]',
+                    )
+                ) is not None:
+                    comment_text = textwrap.dedent(comment.text).strip()
+                    header = _list_nonempty_lines(comment_text)
+                    header.pop(0)
+
+                    # Build the template (with the corresponding namespace)
+                    namespace = base_namespace | flat_dict_to_nested(get_test_inputs(inputs_xml, test_xml))
+                    try:
+                        result = str(Template(template.text, searchList=namespace))
+                    except (ParseError, NameMapper.NotFound):
+                        continue  # Cheetah compile errors are handled by dedicated checks
+
+                    # Validate that `actual` corresponds to `header`
+                    actual = _list_nonempty_lines(textwrap.dedent(result))
+                    if actual != header:
+                        yield dict(
+                            line=comment.sourceline,
+                            details='\n'.join(
+                                difflib.unified_diff(
+                                    header,
+                                    actual,
+                                    fromfile='expected',
+                                    tofile='actual',
+                                    lineterm='',  # avoid extra newlines
+                                ),
+                            ),
+                        )

gialint-0.1.0/gialint/_context.py

@@ -0,0 +1,15 @@
+class Context(BaseException):
+
+    def __init__(self, code, description, filepath, line, details=None):
+        super().__init__(description)
+        self.code = code
+        self.description = description
+        self.filepath = filepath
+        self.line = line
+        self.details = details
+
+    def __str__(self):
+        where = str(self.filepath)
+        if self.line is not None:
+            where += f':{self.line}'
+        return f'{where} {self.description} ({self.code})'

gialint-0.1.0/gialint/codes.py

@@ -0,0 +1,9 @@
+# Issues with input and output datatypes
+GIA101 = 'Use `format="tabular,tsv"` for table data input parameters or a superset thereof.'
+GIA102 = 'Use `tiff` instead of `tif`'
+
+# Issues with the `command` or `configfiles` sections
+GIA201 = 'Zarr input images require special treatment within the `command` of the tool.'
+GIA202 = 'Cheetah code is invalid.'
+GIA203 = 'Cheetah code for `configfile` recognized as JSON but JSON code is invalid.'
+GIA204 = 'Cheetah code yields not the expected result.'

gialint-0.1.0/gialint/utils.py

@@ -0,0 +1,285 @@
+import pathlib
+
+from lxml import etree
+
+
+def _create_simple_type_converter(target_type):
+    def _type(value: str):
+        if value == '':
+            return UnsetValue()
+        else:
+            return target_type(value)
+    return _type
+
+
+def _create_boolean_converter(param):
+    def _type(checked):
+        return param.attrib.get(f'{checked.lower()}value', checked.lower())
+    return _type
+
+
+def _create_type_converter(param):
+    param_type = param.attrib.get('type', '').lower()
+    assert param_type != ''  # pre-condition
+    match param_type:
+        case 'integer':
+            return _create_simple_type_converter(int)
+        case 'float':
+            return _create_simple_type_converter(float)
+        case 'color':
+            return _create_simple_type_converter(str)
+        case 'boolean':
+            return _create_boolean_converter(param)
+        case 'data':
+            return InputDataset.converter(
+                param.attrib.get('multiple', '').lower() == 'true',
+            )
+        case _:
+            return None
+
+
+def _list_parents(node, include_self=False, stop_at=('inputs', 'test', 'repeat')):
+    current = node
+    while current is node or current.tag not in stop_at:
+        if current is not node or include_self:
+            yield current
+        current = current.getparent()
+
+
+def get_full_name(node):
+    tokens = list()
+    for p in _list_parents(node, include_self=True):
+        if (p_name := p.get('name')):
+            tokens.append(p_name)
+        elif len(tokens) == 0 and (p_argument := p.get('argument')):
+            tokens.append(p_argument.removeprefix('--').replace('-', '_'))
+    return '.'.join(tokens[::-1])
+
+
+def _get_node_by_name(full_name, root_xml, multiple: bool = False):
+    nodes = root_xml.findall(
+        './' + '/'.join(f'*[@name="{name}"]' for name in full_name.split('.'))
+    )
+    if multiple:
+        return nodes
+    else:
+        return nodes[0] if nodes else None
+
+
+class InputDataset:
+
+    class Metadata:
+        pass
+
+    class ZarrMetadata(Metadata):
+        def store_root(self):
+            return 'store_root'
+
+    def __init__(self, filepath: str):
+        self._filepath = filepath
+
+    def __str__(self) -> str:
+        return self._filepath
+
+    def extension(self) -> str:
+        return '.'.join(self.name().split('.')[1:]).lower()
+
+    def ext(self) -> str:
+        return self.extension()
+
+    def file_ext(self) -> str:
+        return self.extension()
+
+    def name(self) -> str:
+        return pathlib.Path(self._filepath).name
+
+    def id(self) -> str:
+        return str(hash(self._filepath))
+
+    def element_identifier(self) -> str:
+        return self.id()
+
+    def extra_files_path(self) -> str:
+        return self._filepath
+
+    def metadata(self):
+        match self.extension():
+            case 'zarr' | 'ome_zarr':
+                return self.ZarrMetadata()
+            case _:
+                return self.Metadata()
+
+    def is_of_type(self, ext) -> bool:
+        """
+        Mocks the behaviour of `galaxy.tools.wrappers.DatasetFilenameWrapper.is_of_type` naively.
+        """
+        return ext.lower() in self.name().lower().split('.')[1:]
+
+    @staticmethod
+    def converter(multiple: bool = False):
+        def _converter(value: str):
+            if multiple:
+                return [
+                    InputDataset(filepath) for filepath in value.split(',')
+                ]
+            else:
+                return InputDataset(value)
+        return _converter
+
+
+class UnsetValue:
+
+    def __bool__(self):
+        return False
+
+    def __str__(self):
+        return ''
+
+    def __eq__(self, other):
+        return isinstance(other, UnsetValue)
+
+    def __lt__(self, other):
+        return False
+
+    def __gt__(self, other):
+        return False
+
+
+def get_test_inputs(inputs_root, test_root):
+    inputs = dict()  # mps the full name of an input parameter to its raw value (prior to type conversion)
+    input_types = dict()  # maps the full name of an input parameter to its type converter
+    conditional_inputs = dict()  # maps the full name of a conditional to its first input parameter
+
+    # Parse input parameters, default values, test values, and type converters
+    for node in inputs_root.xpath('.//param | .//repeat'):
+        full_node_name = get_full_name(node)
+
+        # Ignore the `node` if it is an ancestor of a `repeat` block (those are handled explicitly below),
+        # but ignore the tag of the root node
+        is_repeat_ancestor = False
+        for container in _list_parents(node, stop_at=tuple()):
+            if container is inputs_root:
+                break
+            if container.tag == 'repeat':
+                is_repeat_ancestor = True
+                break
+        if is_repeat_ancestor:
+            continue
+
+        # Skip if the parameter is inactive due to a parent conditional
+        is_active = True
+        for container in _list_parents(node):
+            if container.tag == 'when' and container.getparent().tag == 'conditional':
+                conditional_name = get_full_name(container.getparent())
+                if (
+                    conditional_name not in conditional_inputs or
+                    conditional_inputs[conditional_name] not in inputs or (
+                        inputs[conditional_inputs[conditional_name]] != container.attrib.get('value')
+                    )
+                ):
+                    is_active = False
+                    break
+        if not is_active:
+            continue
+
+        # Handle `repeat` blocks recursively
+        if node.tag == 'repeat':
+            if len(inputs.setdefault(full_node_name, list())) == 0:
+                if (test_repeat_nodes := _get_node_by_name(full_node_name, test_root, multiple=True)):
+                    for test_repeat_node in test_repeat_nodes:
+                        inputs[full_node_name].append(get_test_inputs(node, test_repeat_node))
+                else:
+                    for input_repeat_node in _get_node_by_name(full_node_name, inputs_root, multiple=True):
+                        inputs[full_node_name].append(get_test_inputs(input_repeat_node, etree.Element('repeat')))
+                input_types[full_node_name] = list
+            continue
+
+        # Skip invalid parameters (this is handled by `planemo lint`)
+        if (param_type := node.attrib.get('type', '').lower()) == '':
+            continue
+        else:
+            converter = _create_type_converter(node)
+
+        # Read the value from the `value` attribute
+        if param_type in ('text', 'integer', 'float', 'color', 'hidden', 'data'):
+            inputs[full_node_name] = node.attrib.get('value', '')
+
+        # Read the value from the `checked` attribute
+        if param_type in ('boolean',):
+            inputs[full_node_name] = node.attrib.get('checked', 'false')
+
+        # Read the value from children elements
+        if (default_options := node.xpath('./option[translate(@selected, "TRUE", "true")="true"]')):
+            inputs[full_node_name] = default_options[0].attrib.get('value')  # read from selected option
+        elif (options := node.findall('./option')):
+            inputs[full_node_name] = options[0].attrib.get('value')  # read from first option
+
+        # Register type converter
+        input_types[full_node_name] = converter or str
+
+        # Register the input for a conditional
+        if node.getparent().tag == 'conditional':
+            conditional_name = get_full_name(node.getparent())
+            conditional_inputs[conditional_name] = full_node_name
+
+        # Read test value
+        if (test_param := _get_node_by_name(full_node_name, test_root)) is not None:
+            inputs[full_node_name] = test_param.attrib.get('value', '')
+
+    # Return inputs and apply type converters
+    return {
+        key: (
+            None if value is None else input_types[key](value)
+        ) for key, value in inputs.items()
+    }
+
+
+def list_tests(tool_xml_root):
+    yield from tool_xml_root.findall('./tests/test')
+
+
+class Output:
+
+    def __init__(self, name: str):
+        self._name = name
+
+    def __str__(self) -> str:
+        return f'${self._name}'
+
+    def files_path(self) -> str:
+        return f'${self._name}.files_path'
+
+
+def get_base_namespace(tool_xml_root):
+    ns = {
+        '__tool_directory__': '$__tool_directory__',
+        'input': None,  # shadow the built-in `input` because it causes hang-ups
+    }
+    for configfile in tool_xml_root.xpath('./configfiles/*[self::configfile or self::inputs]'):
+        if (name := configfile.attrib.get('name')):
+            ns[name] = f'${name}'
+    for output in tool_xml_root.findall('./outputs/data'):
+        if (name := output.attrib.get('name')):
+            ns[name] = Output(name)
+    return ns
+
+
+def flat_dict_to_nested(flat_dict):
+    root = dict()
+    for key, value in flat_dict.items():
+        path = key.split('.')
+
+        # Find/create the parent `dict` of where `value` must go
+        current = root
+        for token in path[:-1]:
+            current = current.setdefault(token, dict())
+
+        # Propagate to `value` if it is a list of dictionaries
+        if isinstance(value, list) and isinstance(value[0], dict):
+            value = [
+                flat_dict_to_nested(item) for item in value
+            ]
+
+        # Put `value` into the hierarchy
+        current[path[-1]] = value
+    return root

gialint-0.1.0/gialint/version.py

@@ -0,0 +1,5 @@
+VERSION_MAJOR = 0
+VERSION_MINOR = 1
+VERSION_PATCH = 0
+
+__version__ = '%d.%d.%d' % (VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH)

gialint-0.1.0/gialint.egg-info/PKG-INFO

@@ -0,0 +1,22 @@
+Metadata-Version: 2.4
+Name: gialint
+Version: 0.1.0
+Summary: Linter for tool wrappers in Galaxy Image Analysis
+Home-page: https://kostrykin.com
+Author: Leonid Kostrykin
+Author-email: leonid.kostrykin@bioquant.uni-heidelberg.de
+License: MIT
+Requires-Python: >=3.10
+License-File: LICENSE
+Requires-Dist: galaxy-util>=25.0
+Requires-Dist: lxml>=6.0.2
+Requires-Dist: Cheetah3>=3.2.6.post1
+Requires-Dist: pyyaml>=6.0.3
+Dynamic: author
+Dynamic: author-email
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary

gialint-0.1.0/gialint.egg-info/SOURCES.txt

@@ -0,0 +1,24 @@
+LICENSE
+README.md
+setup.py
+gialint/__init__.py
+gialint/__main__.py
+gialint/_context.py
+gialint/codes.py
+gialint/utils.py
+gialint/version.py
+gialint.egg-info/PKG-INFO
+gialint.egg-info/SOURCES.txt
+gialint.egg-info/dependency_links.txt
+gialint.egg-info/requires.txt
+gialint.egg-info/top_level.txt
+gialint/_checks/__init__.py
+gialint/_checks/gia101.py
+gialint/_checks/gia102.py
+gialint/_checks/gia201.py
+gialint/_checks/gia202.py
+gialint/_checks/gia203.py
+gialint/_checks/gia204.py
+tests/test_checks.py
+tests/test_system.py
+tests/test_utils.py

gialint-0.1.0/gialint.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

gialint-0.1.0/gialint.egg-info/requires.txt

@@ -0,0 +1,4 @@
+galaxy-util>=25.0
+lxml>=6.0.2
+Cheetah3>=3.2.6.post1
+pyyaml>=6.0.3

gialint-0.1.0/gialint.egg-info/top_level.txt

@@ -0,0 +1 @@
+gialint

gialint-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

gialint-0.1.0/setup.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python
+
+from setuptools import setup
+
+version = dict()
+with open('gialint/version.py') as f:
+    exec(f.read(), version)
+
+
+setup(
+    name='gialint',
+    version=version['__version__'],
+    description='Linter for tool wrappers in Galaxy Image Analysis',
+    author='Leonid Kostrykin',
+    author_email='leonid.kostrykin@bioquant.uni-heidelberg.de',
+    url='https://kostrykin.com',
+    license='MIT',
+    packages=['gialint', 'gialint._checks'],
+    python_requires='>=3.10',
+    install_requires=[
+        'galaxy-util>=25.0',
+        'lxml>=6.0.2',
+        'Cheetah3>=3.2.6.post1',
+        'pyyaml>=6.0.3',
+    ],
+)

gialint-0.1.0/tests/test_checks.py

@@ -0,0 +1,53 @@
+import pathlib
+import unittest
+
+from lxml import etree
+
+import gialint
+
+tests_root_path = pathlib.Path(__file__).parent
+
+
+def _create_test(code, xml_tests_filepath, xml_test):
+    expected_lines_with_violations_str = xml_test.attrib.get('lines_with_volations', '')
+    expected_lines_with_violations = (
+        [int(line.strip()) for line in expected_lines_with_violations_str.split(',')]
+        if expected_lines_with_violations_str.strip() else list()
+    )
+
+    def format_lines_list(lines_list):
+        return ', '.join(f'{line}' for line in lines_list) or 'none'
+
+    def test(testcase):
+        check_results = list(gialint.check(code, xml_test))
+        actual_lines_with_violations = [
+            info if isinstance(info, int) else info['line'] for info in check_results
+        ]
+        if actual_lines_with_violations != expected_lines_with_violations:
+            testcase.fail(
+                f'{xml_tests_filepath}:{xml_test.sourceline}\n'
+                f'    expected failures on lines: {format_lines_list(expected_lines_with_violations)}\n'
+                f'    but actual failures were on: {format_lines_list(actual_lines_with_violations)}'
+            )
+
+    return test
+
+
+def _create_tests(code):
+    xml_tests_filepath = tests_root_path / 'checks' / f'{code}.xml'
+    xml_tests = etree.parse(xml_tests_filepath).getroot()
+    for xml_test in xml_tests:
+        if isinstance(xml_test, etree._Comment):
+            continue
+        assert xml_test.tag == 'test-tool', xml_test.tag
+        yield _create_test(code, xml_tests_filepath, xml_test)
+
+
+class CodesTestCase(unittest.TestCase):
+
+    pass
+
+
+for code in gialint.list_codes():
+    for test_idx, test in enumerate(_create_tests(code)):
+        setattr(CodesTestCase, f'test_{code}_{test_idx + 1}', test)

gialint-0.1.0/tests/test_system.py

@@ -0,0 +1,47 @@
+import pathlib
+import subprocess
+import sys
+import tempfile
+import unittest
+
+repo_root_path = pathlib.Path(__file__).parent.parent
+
+
+class SystemTest(unittest.TestCase):
+
+    def setUp(self):
+        self.tempdir = tempfile.TemporaryDirectory()
+        subprocess.run(
+            ';'.join(
+                [
+                    'cd "{}"'.format(self.tempdir.name),
+                    '{} -m venv ./venv'.format(sys.executable),
+                    './venv/bin/python -m pip install "{}" -qq'.format(repo_root_path),
+                ]
+            ),
+            shell=True,
+            check=True,
+            stdout=subprocess.PIPE,
+        )
+
+    def tearDown(self):
+        self.tempdir.cleanup()
+
+    def test(self):
+        result = subprocess.run(
+            ';'.join(
+                [
+                    'cd "{}"'.format(self.tempdir.name),
+                    'git clone https://github.com/BMCV/galaxy-image-analysis.git',
+                    './venv/bin/python -m gialint --tool_path galaxy-image-analysis/tools',
+                ]
+            ),
+            shell=True,
+            check=False,
+            text=True,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+        )
+        if 'traceback' in result.stderr.lower():
+            print('\n', result.stderr, file=sys.stderr)
+            self.fail()

gialint-0.1.0/tests/test_utils.py

@@ -0,0 +1,271 @@
+import pathlib
+import unittest
+
+from lxml import etree
+
+from gialint import utils
+
+tools_root_path = pathlib.Path(__file__).parent / 'tools'
+
+
+class flat_dict_to_nested(unittest.TestCase):
+
+    def test(self):
+        flat = {
+            'root.key1': '1',
+            'root.key2': '2',
+            'root.sub1.key1': '1.1',
+            'root.sub1.key2': '1.2',
+            'root.list': [
+                {
+                    'key1': 'a',
+                    'key2': 'b',
+                },
+                {
+                    'list_item_root.key1': 'c',
+                    'list_item_root.key2': 'd',
+                },
+            ],
+        }
+        self.assertEqual(
+            utils.flat_dict_to_nested(flat),
+            {
+                'root': {
+                    'key1': '1',
+                    'key2': '2',
+                    'sub1': {
+                        'key1': '1.1',
+                        'key2': '1.2',
+                    },
+                    'list': [
+                        {
+                            'key1': 'a',
+                            'key2': 'b',
+                        },
+                        {
+                            'list_item_root': {
+                                'key1': 'c',
+                                'key2': 'd',
+                            },
+                        },
+                    ]
+                },
+            },
+        )
+
+
+class InputDataset(unittest.TestCase):
+
+    def setUp(self):
+        self.filepath = '/path/filename.ext1.ext2'
+        self.dataset = utils.InputDataset(self.filepath)
+
+    def test_ext(self):
+        self.assertEqual(self.dataset.ext(), 'ext1.ext2')
+
+    def test_extension(self):
+        self.assertEqual(self.dataset.extension(), 'ext1.ext2')
+
+    def test_file_ext(self):
+        self.assertEqual(self.dataset.file_ext(), 'ext1.ext2')
+
+    def test__str__(self):
+        self.assertEqual(str(self.dataset), self.filepath)
+
+    def test_name(self):
+        self.assertEqual(self.dataset.name(), 'filename.ext1.ext2')
+
+    def test_id(self):
+        self.assertEqual(self.dataset.id(), str(hash(self.filepath)))
+
+    def test_element_identifier(self):
+        self.assertEqual(self.dataset.element_identifier(), str(hash(self.filepath)))
+
+    def test_extra_files_path(self):
+        self.assertEqual(self.dataset.extra_files_path(), self.filepath)
+
+    def test_metadata(self):
+        self.assertFalse(hasattr(self.dataset.metadata(), 'store_root'))
+        self.assertEqual(
+            utils.InputDataset('filename.zarr').metadata().store_root(),
+            'store_root',
+        )
+
+    def test_is_of_type(self):
+        self.assertTrue(self.dataset.is_of_type('ext1'))
+        self.assertTrue(self.dataset.is_of_type('ext2'))
+        self.assertFalse(self.dataset.is_of_type('filename'))
+        self.assertTrue(
+            utils.InputDataset('.txt').is_of_type('txt'),
+        )
+        self.assertFalse(
+            utils.InputDataset('txt').is_of_type('txt'),
+        )
+
+
+class ToolTest(unittest.TestCase):
+
+    tool: str
+
+    def setUp(self):
+        self.tool_xml_root = etree.parse(tools_root_path / self.tool).getroot()
+        if (inputs := self.tool_xml_root.findall('./inputs')):
+            self.inputs_xml = inputs[0]
+        else:
+            self.inputs_xml = None
+        self.test_xml_list = self.tool_xml_root.findall('./tests/test')
+
+
+class MinimalTest(ToolTest):
+
+    tool = 'utils_minimal.xml'
+
+    def test_list_tests(self):
+        self.assertEqual(len(list(utils.list_tests(self.tool_xml_root))), 1)
+
+
+class IllegalTest(ToolTest):
+
+    tool = 'utils_illegal.xml'
+
+    def test_list_tests(self):
+        self.assertEqual(len(list(utils.list_tests(self.tool_xml_root))), 1)
+
+    def test_get_test_inputs1(self):
+        test_inputs = (
+            utils.get_test_inputs(self.inputs_xml, self.test_xml_list[0])
+        )
+        self.assertEqual(test_inputs, dict())
+
+
+class FullTest(ToolTest):
+
+    tool = 'utils_full.xml'
+
+    def test_list_tests(self):
+        self.assertEqual(len(list(utils.list_tests(self.tool_xml_root))), 3)
+
+    def test_get_test_inputs1(self):
+        test_inputs = (
+            utils.get_test_inputs(self.inputs_xml, self.test_xml_list[0])
+        )
+
+        # Validate input parameters without default values
+        self.assertEqual(test_inputs['section_1.no_name'], 'false')
+        self.assertEqual(test_inputs['section_1.text_without_default'], '')
+        self.assertEqual(test_inputs['text_without_default'], '')
+        self.assertEqual(test_inputs['hidden_without_default'], '')
+        for key in (
+            'integer_without_default',
+            'float_without_default',
+            'color_without_default',
+        ):
+            with self.subTest(key):
+                self.assertIsInstance(test_inputs[key], utils.UnsetValue)
+
+        # Validate input parameters with default values
+        self.assertEqual(test_inputs['text_with_default'], 'default')
+        self.assertEqual(test_inputs['integer_with_default'], 1)
+        self.assertEqual(test_inputs['float_with_default'], 1.0)
+        self.assertEqual(test_inputs['boolean_1'], 'true')
+        self.assertEqual(test_inputs['boolean_2'], 'FALSE')
+        self.assertEqual(test_inputs['color_with_default'], '#ff0000')
+        self.assertEqual(test_inputs['hidden_with_default'], 'default')
+        self.assertEqual(test_inputs['select_1'], 'default')
+        self.assertEqual(test_inputs['select_2'], 'default')
+        self.assertEqual(test_inputs['section_1.text_with_default'], 'section_default')
+        self.assertNotIn('section_1', test_inputs)
+
+        # Validate conditionals
+        self.assertEqual(test_inputs['cond.text_1'], 'value_1')
+        self.assertEqual(test_inputs['cond.text_2'], 'value_2')
+        self.assertNotIn('cond', test_inputs)
+        self.assertNotIn('cond.text_0', test_inputs)
+
+        # Validate repeats
+        self.assertEqual(
+            test_inputs['repeat_1'],
+            [
+                dict(repeat_integer_with_default=1, repeat_integer_without_default=utils.UnsetValue()),
+                dict(repeat_integer_with_default=2, repeat_integer_without_default=utils.UnsetValue()),
+            ],
+        )
+        self.assertEqual(
+            test_inputs['repeat_2'],
+            [
+                dict(repeat_integer_with_default=3, repeat_integer_without_default=utils.UnsetValue()),
+            ],
+        )
+        self.assertEqual(
+            [
+                key for key in test_inputs
+                if key.startswith('repeat_')
+            ],
+            [
+                'repeat_1',
+                'repeat_2',
+            ],
+        )
+
+    def test_get_test_inputs2(self):
+        test_inputs = (
+            utils.get_test_inputs(self.inputs_xml, self.test_xml_list[1])
+        )
+
+        self.assertEqual(test_inputs['text_with_default'], 'override')
+        self.assertEqual(test_inputs['text_without_default'], 'override')
+        self.assertEqual(test_inputs['integer_with_default'], 2)
+        self.assertEqual(test_inputs['integer_without_default'], 2)
+        self.assertEqual(test_inputs['float_with_default'], 2.0)
+        self.assertEqual(test_inputs['float_without_default'], 2.0)
+        self.assertEqual(test_inputs['boolean_1'], 'false')
+        self.assertEqual(test_inputs['boolean_2'], 'TRUE')
+        self.assertEqual(test_inputs['color_with_default'], '#00ff00')
+        self.assertEqual(test_inputs['color_without_default'], '#00ff00')
+        self.assertEqual(test_inputs['hidden_with_default'], 'override')
+        self.assertEqual(test_inputs['hidden_without_default'], 'override')
+        self.assertEqual(test_inputs['select_1'], 'other')
+        self.assertEqual(test_inputs['select_2'], 'other')
+        self.assertEqual(test_inputs['section_1.text_with_default'], 'section_override')
+        self.assertEqual(test_inputs['section_1.text_without_default'], 'section_override')
+        self.assertEqual(test_inputs['section_1.no_name'], 'true')
+        self.assertNotIn('section_1', test_inputs)
+
+        # Validate conditionals
+        self.assertEqual(test_inputs['cond.text_0'], 'override')
+        self.assertEqual(test_inputs['cond.text_1'], 'value_3')
+        self.assertNotIn('cond', test_inputs)
+        self.assertNotIn('cond.text_2', test_inputs)
+
+        # Validate repeats
+        self.assertEqual(
+            test_inputs['repeat_1'],
+            [
+                dict(repeat_integer_with_default=10, repeat_integer_without_default=11),
+            ],
+        )
+        self.assertEqual(
+            test_inputs['repeat_2'],
+            [
+                dict(repeat_integer_with_default=20, repeat_integer_without_default=21),
+                dict(repeat_integer_with_default=30, repeat_integer_without_default=31),
+            ],
+        )
+        self.assertEqual(
+            [
+                key for key in test_inputs
+                if key.startswith('repeat_')
+            ],
+            [
+                'repeat_1',
+                'repeat_2',
+            ],
+        )
+
+    def test_get_test_inputs3(self):
+        test_inputs = (
+            utils.get_test_inputs(self.inputs_xml, self.test_xml_list[2])
+        )
+
+        self.assertEqual(test_inputs['boolean_1'], 'false')
+        self.assertEqual(test_inputs['boolean_2'], 'TRUE')