camel-core 0.1.0__tar.gz

camel_core-0.1.0/.gitignore

@@ -0,0 +1 @@
+.idea/

camel_core-0.1.0/PKG-INFO

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: camel_core
+Version: 0.1.0
+Summary: CAMEL core is a set of utilities used by Bioinformatics Platform at the Belgian Public Health institute (Sciensano).
+Project-URL: Homepage, https://github.com/BioinformaticsPlatformWIV-ISP/MiST
+Project-URL: Issues, https://github.com/BioinformaticsPlatformWIV-ISP/MiST/issues
+Author-email: Sciensano BIOIT team <bioit@sciensano.be>
+License-Expression: GPL-3.0-or-later
+Keywords: genomics,microbial,research
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Requires-Python: ==3.12.*
+Requires-Dist: biopython
+Requires-Dist: bs4
+Requires-Dist: click
+Requires-Dist: cyvcf2
+Requires-Dist: furl
+Requires-Dist: humanize
+Requires-Dist: pandas
+Requires-Dist: pysam
+Requires-Dist: rauth
+Requires-Dist: requests
+Requires-Dist: scipy
+Requires-Dist: snakemake
+Requires-Dist: yattag
+Provides-Extra: dev
+Requires-Dist: pytest; extra == 'dev'
+Requires-Dist: pytest-xdist; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# CAMEL core
+
+CAMEL core is a set of utilities used by Bioinformatics Platform at the Belgian Public Health institute (Sciensano).
+
+This package is not meant to be used directly, but contains functionality that is shared between various projects.
+
+
+## Functionality
+
+- Command execution through subprocess
+- Input/output (IO) classes for handling tool / input output
+- Utility functions for handling common bioinformatics formats such as FASTQ, FASTA, BAM
+- HTML reports
+- Utility functions for working with Snakemake
+- BaseTool class
+- Logging

camel_core-0.1.0/README.md

@@ -0,0 +1,16 @@
+# CAMEL core
+
+CAMEL core is a set of utilities used by Bioinformatics Platform at the Belgian Public Health institute (Sciensano).
+
+This package is not meant to be used directly, but contains functionality that is shared between various projects.
+
+
+## Functionality
+
+- Command execution through subprocess
+- Input/output (IO) classes for handling tool / input output
+- Utility functions for handling common bioinformatics formats such as FASTQ, FASTA, BAM
+- HTML reports
+- Utility functions for working with Snakemake
+- BaseTool class
+- Logging

camel_core-0.1.0/camel.log

@@ -0,0 +1,9 @@
+2026-03-10 13:29:33,135 -     lmodservice -   DEBUG - Loading environment using LMOD
+2026-03-10 13:29:33,135 -         command -    INFO - Executing command: module load amrfinder/4.0.19 blast/2.16.0 hmmer/3.4; amrfinder --version
+2026-03-10 13:29:33,258 -         command -   DEBUG - stdout: 4.0.19
+
+2026-03-10 13:29:33,258 -         command -   DEBUG - stderr: 
+2026-03-10 13:29:33,258 -            tool -   DEBUG - Initializing tool: AMRFinder 4.0.19
+2026-03-10 13:29:33,258 -            tool -    INFO - Running tool AMRFinder
+2026-03-10 13:29:33,258 -            tool -    INFO - Working directory: /home/bebogaerts/PycharmProjects/CAMEL_core
+2026-03-10 13:29:33,259 -            tool -    INFO - Tool parameters: output_path: amrfinder_out.tsv, organism: Salmonella, min_cov: 0.5

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

@@ -0,0 +1,48 @@
+Metadata-Version: 2.4
+Name: camel_core
+Version: 0.1.0
+Summary: CAMEL core is a set of utilities used by Bioinformatics Platform at the Belgian Public Health institute (Sciensano).
+Author-email: Sciensano BIOIT team <bioit@sciensano.be>
+License-Expression: GPL-3.0-or-later
+Project-URL: Homepage, https://github.com/BioinformaticsPlatformWIV-ISP/MiST
+Project-URL: Issues, https://github.com/BioinformaticsPlatformWIV-ISP/MiST/issues
+Keywords: research,microbial,genomics
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: Topic :: Scientific/Engineering :: Bio-Informatics
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3
+Description-Content-Type: text/markdown
+Requires-Dist: biopython
+Requires-Dist: bs4
+Requires-Dist: click
+Requires-Dist: cyvcf2
+Requires-Dist: furl
+Requires-Dist: humanize
+Requires-Dist: pandas
+Requires-Dist: pysam
+Requires-Dist: rauth
+Requires-Dist: requests
+Requires-Dist: scipy
+Requires-Dist: snakemake
+Requires-Dist: yattag
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-xdist; extra == "dev"
+
+# CAMEL core
+
+CAMEL core is a set of utilities used by Bioinformatics Platform at the Belgian Public Health institute (Sciensano).
+
+This package is not meant to be used directly, but contains functionality that is shared between various projects.
+
+
+## Functionality
+
+- Command execution through subprocess
+- Input/output (IO) classes for handling tool / input output
+- Utility functions for handling common bioinformatics formats such as FASTQ, FASTA, BAM
+- HTML reports
+- Utility functions for working with Snakemake
+- BaseTool class
+- Logging

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

@@ -0,0 +1,52 @@
+README.md
+pyproject.toml
+camel_core.egg-info/PKG-INFO
+camel_core.egg-info/SOURCES.txt
+camel_core.egg-info/dependency_links.txt
+camel_core.egg-info/requires.txt
+camel_core.egg-info/top_level.txt
+camelcore/__init__.py
+camelcore/version.py
+camelcore/app/__init__.py
+camelcore/app/command.py
+camelcore/app/errors.py
+camelcore/app/logger.py
+camelcore/app/testsuite.py
+camelcore/app/io/__init__.py
+camelcore/app/io/toolio.py
+camelcore/app/io/tooliodirectory.py
+camelcore/app/io/tooliofile.py
+camelcore/app/io/tooliovalue.py
+camelcore/app/reports/__init__.py
+camelcore/app/reports/htmlbase.py
+camelcore/app/reports/htmlcitation.py
+camelcore/app/reports/htmlelement.py
+camelcore/app/reports/htmlexpandablediv.py
+camelcore/app/reports/htmlexpandabletable.py
+camelcore/app/reports/htmlreport.py
+camelcore/app/reports/htmlreportsection.py
+camelcore/app/reports/htmltablecell.py
+camelcore/app/reports/htmltableformatter.py
+camelcore/app/utils/__init__.py
+camelcore/app/utils/fastautils.py
+camelcore/app/utils/fastqutils.py
+camelcore/app/utils/fileutils.py
+camelcore/app/utils/galaxyutils.py
+camelcore/app/utils/reportutils.py
+camelcore/app/utils/sambamutils.py
+camelcore/app/utils/snakeutils.py
+camelcore/app/utils/vcfutils.py
+camelcore/resources/__init__.py
+camelcore/tests/__init__.py
+camelcore/tests/test_command.py
+camelcore/tests/reports/__init__.py
+camelcore/tests/reports/test_htmlreport.py
+camelcore/tests/reports/test_htmltableformatter.py
+camelcore/tests/snakemake/__init__.py
+camelcore/tests/snakemake/test_snakeutils.py
+camelcore/tests/utils/__init__.py
+camelcore/tests/utils/test_fastautils.py
+camelcore/tests/utils/test_fastqutils.py
+camelcore/tests/utils/test_fileutils.py
+camelcore/tests/utils/test_sambamutils.py
+camelcore/tests/utils/test_vcfutils.py

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

@@ -0,0 +1 @@
+

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

@@ -0,0 +1,17 @@
+biopython
+bs4
+click
+cyvcf2
+furl
+humanize
+pandas
+pysam
+rauth
+requests
+scipy
+snakemake
+yattag
+
+[dev]
+pytest
+pytest-xdist

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

@@ -0,0 +1 @@
+camelcore

camel_core-0.1.0/camelcore/app/command.py

@@ -0,0 +1,139 @@
+import os
+import subprocess
+import warnings
+from pathlib import Path
+from typing import Any
+from camelcore.app.logger import logger
+
+
+class Command:
+    """
+    Helper class to run commands.
+    """
+
+    def __init__(self, command: str | list[str] = None, stdout_path: Path | None = None) -> None:
+        """
+        Initializes the command object.
+        Note it is strongly recommended to initialize commands as a list of string for security
+        :param command: (optional) Command line call or list of arguments
+        :param stdout_path: stdout path
+        :return: None
+        """
+        self._stdout = None
+        self._stderr = None
+        self._procedure = None
+        self._return_code = None
+        self._command = command
+        self._stdout_path = stdout_path
+
+    @property
+    def stderr(self) -> str:
+        """
+        Returns the stderr from the command execution.
+        :return: Standard error
+        """
+        return self._stderr
+
+    @property
+    def stdout(self) -> str:
+        """
+        Returns the stdout from the command execution.
+        :return: Standard error
+        """
+        return self._stdout
+
+    @property
+    def exit_code(self) -> int:
+        """
+        Returns the exit code from the command execution.
+        """
+        return self._return_code
+
+    @property
+    def command(self) -> str | list[str]:
+        """
+        Returns the command line call.
+        :return: Command line call
+        """
+        return self._command
+
+    @command.setter
+    def command(self, cmd: str) -> None:
+        """
+        Sets the command line call.
+        :param cmd: Command
+        :return: None
+        """
+        self._command = cmd
+
+    def run(
+        self,
+        folder: Path,
+        stderr_handle=subprocess.PIPE,
+        disable_logging: bool = False,
+        prefix: str | None = None,
+        env: dict[str, Any] | None = None,
+    ) -> None:
+        """
+        Runs the command given at command initialization
+        :param folder: Folder where the command is executed
+        :param stderr_handle: Handle for the standard error (e.g. PIPE or STDOUT)
+        :param disable_logging: If True, logging is disabled
+        :param prefix: If given, this prefix will be added to the commands
+        :param env: Environment variables to be set for the command
+        :return: None
+        """
+        if self.command is None:
+            raise ValueError("Invalid command 'None'")
+        is_shell = isinstance(self._command, str)
+
+        # Add the prefix
+        command = self._command
+        if prefix:
+            if is_shell:
+                command = f"{prefix}{self._command}"
+            else:
+                logger.info('Prefix is not supported when providing command as a list')
+
+        # Log the execution
+        if disable_logging is False:
+            logger.info(
+                f"Executing command: {' '.join(self.command) if isinstance(self.command, list) else self.command}"
+            )
+
+        # Output file
+        stdout_handle = self._stdout_path.open('w', encoding='utf-8') if self._stdout_path else subprocess.PIPE
+
+        try:
+            self._procedure = subprocess.run(
+                command,
+                stdout=stdout_handle,
+                stderr=stderr_handle,
+                shell=is_shell,
+                env={**os.environ, **env} if env is not None else None,
+                cwd=folder,
+                text=True,
+            )
+            self._stdout = self._procedure.stdout or ''
+            self._stderr = self._procedure.stderr or ''
+            self._return_code = self._procedure.returncode
+        except FileNotFoundError as err:
+            self._stdout = ''
+            self._stderr = str(err)
+            self._return_code = 1
+        finally:
+            if stdout_handle is not subprocess.PIPE:
+                stdout_handle.close()
+        if disable_logging is False:
+            logger.debug(f'stdout: {self._stdout}')
+            logger.debug(f'stderr: {self._stderr}')
+
+    def run_command(self, folder: Path, stderr_handle=subprocess.PIPE) -> None:
+        """
+        Runs the command given at command initialization
+        :param folder: Folder where the command is executed
+        :param stderr_handle: Handle for the standard error (e.g. PIPE or STDOUT)
+        :return: None
+        """
+        warnings.warn('The run_command method is deprecated, please use the run() method instead.', DeprecationWarning)
+        self.run(folder, stderr_handle)

camel_core-0.1.0/camelcore/app/errors.py

@@ -0,0 +1,23 @@
+class SnakemakeExecutionError(RuntimeError):
+    """
+    This error is raised when a Snakemake execution error occurs.
+    """
+
+    def __init__(self, stdout: str, stderr: str, failed_rule: str | None = None) -> None:
+        """
+        This class is raised when a snakemake error occurs.
+        :param stdout: Standard output
+        :param stderr: Error output
+        """
+        super().__init__(f"Failed at rule: {failed_rule if failed_rule else 'n/a'}")
+        self.stdout = stdout
+        self.stderr = stderr
+        self.failed_rule = failed_rule
+
+
+class DependencyError(ValueError):
+    """
+    Error that is raised when a dependency is not available..
+    """
+
+    pass

camel_core-0.1.0/camelcore/app/io/toolio.py

@@ -0,0 +1,49 @@
+import abc
+from abc import ABCMeta
+
+
+class ToolIO(metaclass=ABCMeta):
+    """
+    Class that represents the input or output of a tool.
+    """
+
+    def __init__(self, logged: bool) -> None:
+        """
+        Initializes a tool input / output.
+        :param logged: If true, the output can be logged
+        """
+        self._logged = logged
+
+    @property
+    def is_logged(self) -> bool:
+        """
+        Returns True if the output is logged.
+        :return: True / False
+        """
+        return self._logged
+
+    @abc.abstractmethod
+    def is_valid(self) -> bool:
+        """
+        Checks whether the tool input / output is valid.
+        :return: None
+        """
+        pass
+
+    @property
+    @abc.abstractmethod
+    def hash(self) -> str:
+        """
+        Returns the hash value.
+        :return: Hash value
+        """
+        pass
+
+    @property
+    @abc.abstractmethod
+    def type_name(self) -> str:
+        """
+        Returns the type of the IO object.
+        :return: Type value
+        """
+        pass

camel_core-0.1.0/camelcore/app/io/tooliodirectory.py

@@ -0,0 +1,80 @@
+from pathlib import Path
+
+from camelcore.app.utils import fileutils
+from camelcore.app.io.toolio import ToolIO
+
+
+class ToolIODirectory(ToolIO):
+    """
+    Class that represents an input / output directory of a tool.
+    """
+
+    def __init__(self, path: Path, logged: bool = True) -> None:
+        """
+        Initializes a tool input / output directory.
+        :param path: Path to the directory
+        :param logged: If True, the output can be logged
+        """
+        super().__init__(logged)
+        self._path = path.absolute()
+
+    def __str__(self) -> str:
+        """
+        String representation.
+        :return: String representation
+        """
+        return str(self._path)
+
+    def __repr__(self) -> str:
+        """
+        Internal representation.
+        :return: Internal representation
+        """
+        return f'ToolIODirectory("{self.path}")'
+
+    def is_valid(self) -> bool:
+        """
+        Checks if the tool input / output directory is valid.
+        :return: True if valid
+        """
+        return self.exists
+
+    @property
+    def hash(self) -> str:
+        """
+        Returns the hash value.
+        :return: Hash value
+        """
+        return fileutils.hash_directory(self.path)
+
+    @property
+    def path(self) -> Path:
+        """
+        Returns the path to the input / output directory.
+        :return: Path
+        """
+        return self._path
+
+    @property
+    def basename(self) -> str:
+        """
+        Returns the basename of the input / output directory.
+        :return: Basename
+        """
+        return self.path.name
+
+    @property
+    def exists(self) -> bool:
+        """
+        Checks whether this directory exists.
+        :return: True if the directory exists, False otherwise
+        """
+        return self._path.is_dir()
+
+    @property
+    def type_name(self) -> str:
+        """
+        Returns the type of the IO object.
+        :return: Type value
+        """
+        return 'dir'

camel_core-0.1.0/camelcore/app/io/tooliofile.py

@@ -0,0 +1,98 @@
+from pathlib import Path
+
+import humanize
+
+from camelcore.app.utils import fileutils
+from camelcore.app.io.toolio import ToolIO
+
+
+class ToolIOFile(ToolIO):
+    """
+    Class that represents an input / output file of a tool.
+    """
+
+    def __init__(self, path: Path, logged: bool = True) -> None:
+        """
+        Initializes a tool input / output file.
+        :param path: Path to the file
+        :param logged: If True, the output can be logged
+        """
+        super().__init__(logged)
+        self._path = path.absolute()
+
+    def __str__(self) -> str:
+        """
+        String representation.
+        :return: String representation
+        """
+        return str(self._path)
+
+    def __repr__(self) -> str:
+        """
+        Internal representation.
+        :return: Internal representation
+        """
+        return f'ToolIOFile("{self.path}", {humanize.naturalsize(self.size)})'
+
+    def is_valid(self) -> bool:
+        """
+        Checks if the tool input / output file is valid.
+        :return: True if valid
+        """
+        return self.exists
+
+    @property
+    def path(self) -> Path:
+        """
+        Returns the path to the input / output file.
+        :return: Path
+        """
+        return self._path
+
+    @property
+    def basename(self) -> str:
+        """
+        Returns the basename of the input / output file.
+        :return: Basename
+        """
+        return self.path.name
+
+    @property
+    def file_extension(self) -> str:
+        """
+        Returns the file extension.
+        :return: File extension
+        """
+        return self.path.suffix
+
+    @property
+    def exists(self) -> bool:
+        """
+        Checks whether this file exists.
+        :return: True if the file exists, False otherwise
+        """
+        return self._path.is_file()
+
+    @property
+    def size(self) -> int:
+        """
+        Returns the size of this file.
+        :return: Size
+        """
+        return self.path.stat().st_size
+
+    @property
+    def hash(self) -> str:
+        """
+        Returns the hash value of this file.
+        :return: Hash
+        """
+        return fileutils.hash_file(self.path)
+
+    @property
+    def type_name(self) -> str:
+        """
+        Returns the type of the IO object.
+        :return: Type value
+        """
+        return 'file'

camel_core-0.1.0/camelcore/app/io/tooliovalue.py

@@ -0,0 +1,64 @@
+from typing import Any
+
+from camelcore.app.utils import fileutils
+from camelcore.app.io.toolio import ToolIO
+
+
+class ToolIOValue(ToolIO):
+    """
+    Class that represents an input / output value of a tool.
+    """
+
+    def __init__(self, value: Any, logged: bool = True) -> None:
+        """
+        Initializes a tool input / output value.
+        :param value: Value
+        :param logged: If True, the output can be logged
+        """
+        super().__init__(logged)
+        self._value = value
+
+    @property
+    def value(self) -> Any:
+        """
+        Returns the value.
+        :return: Value
+        """
+        return self._value
+
+    @property
+    def hash(self) -> str:
+        """
+        Returns the hash value.
+        :return: Hash value
+        """
+        return fileutils.hash_value(self.value)
+
+    @property
+    def type_name(self) -> str:
+        """
+        Returns the type of the IO object.
+        :return: Type value
+        """
+        return 'value'
+
+    def __str__(self) -> str:
+        """
+        String representation.
+        :return: String representation
+        """
+        return str(self.value)
+
+    def __repr__(self) -> str:
+        """
+        Internal representation.
+        :return: Internal representation representation
+        """
+        return f'ToolIOValue({repr(self.value)})'
+
+    def is_valid(self) -> bool:
+        """
+        Checks if the tool input / output value is valid.
+        :return: True if valid
+        """
+        return False if self._value is None else True

camel_core-0.1.0/camelcore/app/logger.py

@@ -0,0 +1,21 @@
+import logging
+
+logger = logging.getLogger('camel')
+DEFAULT_FMT = '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+
+
+def initialize_logging() -> None:
+    """
+    Initializes the logging.
+    :return: None
+    """
+    if logger.hasHandlers():
+        return
+
+    # General logging level
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+    logger.addHandler(logging.NullHandler())
+
+
+initialize_logging()