pycodetags-issue-tracker 0.1.0__py2.py3-none-any.whl

pycodetags_issue_tracker/__about__.py

@@ -0,0 +1,7 @@
+"""Metadata for pycodetags_issue_tracker."""
+
+__all__ = ["__title__", "__version__", "__description__"]
+
+__title__ = "pycodetags-issue-tracker"
+__version__ = "0.1.0"
+__description__ = "Plugin for pycodetags to track issues, e.g. bugs, TODO, etc in your code"

pycodetags_issue_tracker/__init__.py

@@ -0,0 +1,29 @@
+__all__ = [
+    "TODO",
+    "FIXME",
+    "REQUIREMENT",
+    "STORY",
+    "IDEA",
+    "BUG",
+    "HACK",
+    "CLEVER",
+    "MAGIC",
+    "ALERT",
+    "PORT",
+    "DOCUMENT",
+]
+
+from pycodetags_issue_tracker.todo_tag_types import TODO
+from pycodetags_issue_tracker.todo_tag_types_aliases import (
+    ALERT,
+    BUG,
+    CLEVER,
+    DOCUMENT,
+    FIXME,
+    HACK,
+    IDEA,
+    MAGIC,
+    PORT,
+    REQUIREMENT,
+    STORY,
+)

pycodetags_issue_tracker/_tag_templates.txt.md

@@ -0,0 +1,21 @@
+# Templates
+
+Copy paste these on creation, update and close
+
+## TODO
+```python
+# TODO: ...
+#  <matth 2025-07-04 status:development category:parser priority:medium>
+```
+
+## PLANNING
+```python
+# TODO: ...
+#  <matth 2025-07-04 status:planned release:... iteration:1 due:...>
+```
+
+## DONE
+```python
+# TODO: ...
+#  <matth 2025-07-04 status:done release:... >
+```

pycodetags_issue_tracker/cli.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+
+import argparse
+from collections.abc import Sequence
+from typing import cast
+
+from pycodetags_issue_tracker import TODO, views, views_templated
+
+from pycodetags import DATA
+from pycodetags.config import CodeTagsConfig
+
+
+def handle_cli(subparsers: argparse._SubParsersAction):
+    report_parser = subparsers.add_parser(
+        "issues",
+        # parents=[base_parser],
+        help="Reports for TODOs and BUGs",
+    )
+    # report runs collectors, collected things can be validated
+    report_parser.add_argument("--module", action="append", help="Python module to inspect (e.g., 'my_project.main')")
+    report_parser.add_argument("--src", action="append", help="file or folder of source code")
+
+    report_parser.add_argument("--output", help="destination file or folder")
+
+    supported_formats = ["changelog", "validate", "html", "todomd", "donefile", "text"]
+
+    report_parser.add_argument(
+        "--format",
+        choices=supported_formats,
+        default="text",
+        help="Output format for the report.",
+    )
+
+    common_switches(report_parser)
+
+
+def common_switches(parser) -> None:
+    parser.add_argument("--config", help="Path to config file, defaults to current folder pyproject.toml")
+    parser.add_argument("--verbose", default=False, action="store_true", help="verbose level logging output")
+    parser.add_argument("--info", default=False, action="store_true", help="info level logging output")
+    parser.add_argument("--bug-trail", default=False, action="store_true", help="enable bug trail, local logging")
+
+
+def run_cli_command(
+    command_name: str,
+    args: argparse.Namespace,
+    found_data: Sequence[DATA | TODO],
+    # pylint: disable=unused-argument)
+    config: CodeTagsConfig,
+) -> bool:
+    format_name = args.format
+    # args.output
+    if command_name == "issues":
+        if format_name == "validate":
+            views.print_validate(cast(list[TODO], found_data))
+            return True
+        if format_name == "html":
+            views_templated.print_html(cast(list[TODO], found_data))
+            return True
+        if format_name == "todomd":
+            views.print_todo_md(cast(list[TODO], found_data))
+            return True
+        if format_name == "text":
+            views.print_text(cast(list[TODO], found_data))
+            return True
+        if format_name == "changelog":
+            views.print_changelog(cast(list[TODO], found_data))
+            return True
+        if format_name == "donefile":
+            views.print_done_file(cast(list[TODO], found_data))
+            return True
+        return False
+    return False

pycodetags_issue_tracker/converters.py

@@ -0,0 +1,161 @@
+"""
+Converters for FolkTag and PEP350Tag to TODO
+"""
+
+from __future__ import annotations
+
+import logging
+from collections.abc import Iterable
+from typing import Any
+
+from pycodetags_issue_tracker.todo_object_schema import TODO_KEYWORDS
+from pycodetags_issue_tracker.todo_tag_types import TODO
+
+from pycodetags import DATA
+from pycodetags.data_tags_schema import DataTag
+from pycodetags.folk_code_tags import FolkTag
+
+logger = logging.getLogger(__name__)
+
+
+def blank_to_null(value: str | None) -> str | None:
+    """
+    Convert a blank string to None.
+
+    Args:
+        value (str | None): The value to convert.
+
+    Returns:
+        str | None: The converted value.
+    """
+    if isinstance(value, list):
+        return [_.strip() for _ in value]
+    if value is None or value.strip() == "":
+        return None
+    return value.strip()
+
+
+def convert_datas_to_TODOs(tags: Iterable[DATA]) -> Iterable[TODO]:
+    """Syntactic sugar to convert many tags"""
+    return [convert_data_to_TODO(_) for _ in tags]
+
+
+def get_from_custom_or_data(name: str, tag: DATA) -> Any:
+    value = (tag.data_fields or {}).get(name)
+    if value:
+        return value
+    value = (tag.data_fields or {}).get(name)
+    if value:
+        return value
+    return None
+
+
+def convert_data_to_TODO(tag: DATA) -> TODO:
+    return TODO(
+        code_tag=tag.code_tag,
+        comment=tag.comment,
+        default_fields=tag.default_fields or {},
+        data_fields=tag.data_fields or {},
+        custom_fields=tag.custom_fields or {},
+        unprocessed_defaults=tag.unprocessed_defaults or [],
+        assignee=get_from_custom_or_data("assignee", tag),
+        originator=get_from_custom_or_data("originator", tag),
+        origination_date=get_from_custom_or_data("origination_date", tag),
+        due=get_from_custom_or_data("due", tag),
+        release_due=get_from_custom_or_data("release_due", tag),
+        release=get_from_custom_or_data("release", tag),
+        iteration=get_from_custom_or_data("iteration", tag),
+        change_type=get_from_custom_or_data("change_type", tag),
+        closed_date=get_from_custom_or_data("closed_date", tag),
+        closed_comment=get_from_custom_or_data("closed_comment", tag),
+        tracker=get_from_custom_or_data("tracker", tag),
+        file_path=tag.file_path,
+        line_number=tag.line_number,
+        original_text=tag.original_text,
+        original_schema=tag.original_schema,
+        offsets=tag.offsets,
+        priority=get_from_custom_or_data("priority", tag),
+        status=get_from_custom_or_data("status", tag),
+        category=get_from_custom_or_data("category", tag),
+    )
+
+
+def convert_folk_tag_to_TODO(folk_tag: FolkTag) -> TODO:
+    """
+    Convert a FolkTag to a TODO object.
+
+    Args:
+        folk_tag (FolkTag): The FolkTag to convert.
+    """
+    kwargs = {
+        "code_tag": folk_tag.get("code_tag"),
+        "file_path": folk_tag.get("file_path"),
+        "line_number": folk_tag.get("line_number"),
+        # folk_tag.get("default_field"),
+        "custom_fields": folk_tag.get("custom_fields"),
+        "comment": folk_tag["comment"],  # required
+        "tracker": folk_tag.get("tracker"),
+        "assignee": blank_to_null(folk_tag.get("assignee")),
+        "originator": blank_to_null(folk_tag.get("originator")),
+        # person=folk_tag.get("person")
+        "original_text": folk_tag.get("original_text"),
+        "original_schema": "folk",
+    }
+    custom_fields = folk_tag.get("custom_fields", {})
+    for keyword in TODO_KEYWORDS:
+        for field_key, field_value in custom_fields.items():
+            # Promote custom fields to kwargs if they match the keyword
+            # and the keyword is not already in kwargs
+            if keyword == field_key and keyword not in kwargs:
+                kwargs[keyword] = field_value
+            if keyword == field_key and keyword not in kwargs:
+                logger.warning("Duplicate keyword found in custom fields: %s", keyword)
+    return TODO(**kwargs)  # type: ignore[arg-type]
+
+
+def convert_pep350_tag_to_TODO(pep350_tag: DataTag) -> TODO:
+    """
+    Convert a PEP350Tag to a TODO object.
+
+    Args:
+        pep350_tag (PEP350Tag): The PEP350Tag to convert.
+    """
+    # default fields should have already been promoted to data_fields by now.
+    data_fields = pep350_tag["fields"]["data_fields"]
+    custom_fields = pep350_tag["fields"]["custom_fields"]
+    kwargs = {
+        "code_tag": pep350_tag["code_tag"],
+        "comment": pep350_tag["comment"],
+        "custom_fields": custom_fields,
+        # specific fields
+        "assignee": blank_to_null(data_fields.get("assignee")),
+        "originator": blank_to_null(data_fields.get("originator")),
+        # due dates
+        "due": data_fields.get("due"),
+        "iteration": data_fields.get("iteration"),
+        "release": data_fields.get("release"),
+        # integrations
+        "tracker": data_fields.get("tracker"),
+        # idiosyncratic
+        "priority": data_fields.get("priority"),
+        "status": data_fields.get("status"),
+        "category": data_fields.get("category"),
+        # Source Mapping
+        "file_path": data_fields.get("file_path"),
+        "line_number": data_fields.get("line_number"),
+        "original_text": pep350_tag.get("original_text"),
+        "original_schema": "pep350",
+        "offsets": pep350_tag.get("offsets"),
+    }
+
+    custom_fields = pep350_tag["fields"].get("custom_fields", {})
+    for keyword in TODO_KEYWORDS:
+        for field_key, field_value in custom_fields.items():
+            # Promote custom fields to kwargs if they match the keyword
+            # and the keyword is not already in kwargs
+            if keyword == field_key and keyword not in kwargs:
+                kwargs[keyword] = field_value
+            if keyword == field_key and keyword not in kwargs:
+                logger.warning("Duplicate keyword found in custom fields: %s", keyword)
+
+    return TODO(**kwargs)  # type: ignore[arg-type]

pycodetags_issue_tracker/health_o_meter.py

@@ -0,0 +1,233 @@
+"""
+A module for calculating health metrics based on TODO items.
+"""
+
+from __future__ import annotations
+
+from collections import defaultdict
+from typing import Any
+
+from pycodetags_issue_tracker.todo_tag_types import TODO
+
+
+class HealthOMeter:
+    """
+    Calculates various health metrics from a list of TODO items.
+
+    This class operates solely on the provided TODO objects and has no
+    dependencies on file systems or reporting mechanisms.
+    """
+
+    # Define sentiment scores for specific code tags
+    SENTIMENT_SCORES_PER_TAG = {
+        "CLEVER": 2,  # Very positive
+        "MAGIC": 1,  # Positive
+        "HACK": -1,  # Negative
+        "FIXME": -2,  # More negative
+        "BUG": -3,  # Most negative
+    }
+
+    def __init__(self, todos: list[TODO]) -> None:
+        """
+        Initializes the HealthOMeter with a list of TODO items.
+
+        Args:
+            todos: A list of TODO objects to analyze.
+        """
+        self.todos = todos
+        # Cache the total number of TODOs to avoid repeated recalculations
+        self.total_todos_count = len(todos)
+
+    def calculate_todos_per_file(self) -> dict[str, int]:
+        """
+        Calculates the count of TODOs for each file.
+
+        TODO: Consider a metric for average TODOs per file.
+        TODO: Add a metric for files with no TODOs, but high complexity.
+
+        Returns:
+            A dictionary mapping file paths to the count of TODOs in them.
+        """
+        todos_per_file: dict[str, int] = defaultdict(int)
+        for todo in self.todos:
+            if todo.file_path:
+                todos_per_file[todo.file_path] += 1
+        return dict(todos_per_file)
+
+    def calculate_total_dones(self) -> int:
+        """
+        Calculates the total count of TODOs marked as "done".
+
+        TODO: Add a metric for the rate of DONE items over time.
+
+        Returns:
+            The total count of TODOs marked as "done".
+        """
+        return sum(1 for todo in self.todos if todo.is_probably_done())
+
+    def calculate_total_todos(self) -> int:
+        """
+        Calculates the total count of all TODO items.
+
+        TODO: Add a metric for the trend of total TODOs over time (increasing/decreasing).
+
+        Returns:
+            The total count of all TODOs.
+        """
+        return self.total_todos_count
+
+    def calculate_sentiment_score(self) -> float:
+        """
+        Calculates a sentiment score based on the presence of specific tags
+        (CLEVER, MAGIC, HACK, FIXME, BUG). A higher score indicates better sentiment.
+
+        TODO: Allow configuration of which tags influence sentiment and their scores.
+
+        Returns:
+            A score normalized between 0.0 and 1.0. Returns 1.0 if no TODOs exist.
+        """
+        if self.total_todos_count == 0:
+            return 1.0
+
+        raw_sentiment_sum = 0
+        for todo in self.todos:
+            # Check if the code_tag exists and is in our sentiment mapping
+            if todo.code_tag and todo.code_tag.upper() in self.SENTIMENT_SCORES_PER_TAG:
+                raw_sentiment_sum += self.SENTIMENT_SCORES_PER_TAG[todo.code_tag.upper()]
+
+        # Determine the min and max possible sentiment sums for normalization
+        max_score_per_todo = max(self.SENTIMENT_SCORES_PER_TAG.values())
+        min_score_per_todo = min(self.SENTIMENT_SCORES_PER_TAG.values())
+
+        min_possible_total = self.total_todos_count * min_score_per_todo
+        max_possible_total = self.total_todos_count * max_score_per_todo
+
+        # Normalize the raw sum to a 0-1 scale: (actual - min_possible) / (max_possible - min_possible)
+        if max_possible_total == min_possible_total:
+            # Avoid division by zero if all scores are identical or there are no relevant tags
+            return 1.0  # Represents a neutral or ideal state in such cases
+
+        normalized_score = (raw_sentiment_sum - min_possible_total) / (max_possible_total - min_possible_total)
+
+        # Ensure the score stays within the [0, 1] range due to potential edge cases or non-linear distribution
+        return max(0.0, min(1.0, normalized_score))
+
+    def calculate_quality_score(self) -> float:
+        """
+        Calculates a quality score based on the presence of "BUG" tags.
+        A higher score indicates better quality (fewer BUGs).
+
+        Returns:
+            A score normalized between 0.0 and 1.0. Returns 1.0 if no TODOs exist.
+        """
+        if self.total_todos_count == 0:
+            return 1.0
+
+        total_bugs = sum(1 for todo in self.todos if todo.code_tag and todo.code_tag.upper() == "BUG")
+        # Quality decreases with more bugs. Scale from 1.0 (no bugs) to 0.0 (all todos are bugs, worst case).
+        return max(0.0, (self.total_todos_count - total_bugs) / self.total_todos_count)
+
+    def calculate_bug_density(self) -> float:
+        """
+        Calculates the density of BUG tags as the ratio of BUGs to total TODOs.
+        This serves as a proxy for 'bugs per line of code/function' given
+        the class's constraint of not accessing the file system directly.
+
+        TODO: Enhance this metric by allowing external provision of actual
+              Lines of Code (LoC) or function counts per file to get a true density.
+
+        Returns:
+            The ratio of BUGs to total TODOs (0.0 if no TODOs).
+        """
+        if self.total_todos_count == 0:
+            return 0.0  # No bugs if no todos
+
+        total_bugs = sum(1 for todo in self.todos if todo.code_tag and todo.code_tag.upper() == "BUG")
+        return total_bugs / self.total_todos_count
+
+    def get_total_todos_scale(self, total_todos_value: int) -> str:
+        """Provides a descriptive scale for the total number of TODOs."""
+        if total_todos_value == 0:
+            return "Immaculate Codebase"
+        if 1 <= total_todos_value <= 10:
+            return "Well-Maintained"
+        if 11 <= total_todos_value <= 50:
+            return "Active Development"
+        if 51 <= total_todos_value <= 100:
+            return "Busy Beaver"
+        # > 100
+        return "Technical Debt Accumulation"
+
+    def get_sentiment_scale(self, sentiment_score_value: float) -> str:
+        """Provides a descriptive scale for the sentiment score."""
+        if 0.8 <= sentiment_score_value <= 1.0:
+            return "Positive Outlook"
+        if 0.5 <= sentiment_score_value < 0.8:
+            return "Mixed Feelings"
+        if 0.2 <= sentiment_score_value < 0.5:
+            return "Caution Advised"
+        # 0.0 <= score < 0.2
+        return "Coding Horror"
+
+    def get_quality_scale(self, quality_score_value: float) -> str:
+        """Provides a descriptive scale for the code quality score."""
+        if 0.95 <= quality_score_value <= 1.0:
+            return "High Quality"
+        if 0.8 <= quality_score_value < 0.95:
+            return "Good Quality"
+        if 0.5 <= quality_score_value < 0.8:
+            return "Average Quality"
+        # 0.0 <= score < 0.5
+        return "Buggy Waters"
+
+    def get_bug_density_scale(self, bug_density_value: float) -> str:
+        """Provides a descriptive scale for the bug density."""
+        if 0.0 == bug_density_value:
+            return "Bug-Free Zone"
+        if 0.0 < bug_density_value <= 0.05:
+            return "Occasional Pests"
+        if 0.05 < bug_density_value <= 0.15:
+            return "Frequent Critters"
+        # > 0.15
+        return "Infestation"
+
+    def get_total_dones_scale(self, value: int) -> str:
+        if value == 0:
+            return "No Progress"
+        if value <= 5:
+            return "Initial Cleanup"
+        if value <= 20:
+            return "Steady Progress"
+        return "High Velocity"
+
+    def calculate_metrics(self) -> dict[str, Any]:
+        """
+        Calculates and returns a dictionary of all health metrics, including their
+        descriptive scales.
+
+        Returns:
+            A dictionary containing the calculated metrics and their associated scales.
+        """
+        total_todos = self.calculate_total_todos()
+        sentiment_score = self.calculate_sentiment_score()
+        quality_score = self.calculate_quality_score()
+        bug_density = self.calculate_bug_density()
+        total_dones = self.calculate_total_dones()
+
+        metrics = {
+            "todos_per_file": self.calculate_todos_per_file(),
+            "total_dones": total_dones,
+            "total_todos": total_todos,
+            "sentiment": sentiment_score,
+            "quality": quality_score,
+            "bug_density": bug_density,
+            "total_todos_scale": self.get_total_todos_scale(total_todos),
+            "sentiment_scale": self.get_sentiment_scale(sentiment_score),
+            "quality_scale": self.get_quality_scale(quality_score),
+            "bug_density_scale": self.get_bug_density_scale(bug_density),
+            "total_dones_scale": self.get_total_dones_scale(total_dones),
+        }
+
+        # Add scale descriptions to the metrics
+
+        return metrics

pycodetags_issue_tracker/issue_tracker_config.py

@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from pycodetags_issue_tracker.user import get_current_user
+from pycodetags_issue_tracker.users_from_authors import parse_authors_file_simple
+
+from pycodetags.config import CodeTagsConfig, careful_to_bool, get_code_tags_config
+
+
+class IssueTrackerConfig:
+    def __init__(self, parent_config: CodeTagsConfig, set_user: str | None = None):
+
+        self.parent_config = parent_config
+        self.user_override = set_user
+
+    def user_env_var(self) -> str:
+        """Environment variable with active user."""
+        return str(self.parent_config.config.get("user_env_var", ""))
+
+    def current_user(self) -> str:
+        if self.user_override:
+            return self.user_override
+        return get_current_user(self.user_identification_technique(), self.user_env_var())
+
+    def user_identification_technique(self) -> str:
+        """Technique for identifying current user. If not set, related features are disabled."""
+        field = "user_identification_technique"
+        result = self.parent_config.config.get(field, "")
+        accepted = ("os", "env", "git", "")
+        if result not in accepted:
+            raise TypeError(f"Invalid configuration: {field} must be in {accepted}")
+        return str(result)
+
+    def valid_authors_file(self) -> str:
+        """Author list, overrides valid authors if specified. File must exist."""
+        field = "valid_authors_file"
+        return str(self.parent_config.config.get(field, ""))
+
+    def valid_authors_schema(self) -> str:
+        """Author schema, must be specified if authors from file is set."""
+        field = "valid_authors_schema"
+        result = self.parent_config.config.get(field, "")
+        accepted = ("gnu_gnits", "single_column", "")
+        if result not in accepted:
+            raise TypeError(f"Invalid configuration: {field} must be in {accepted}")
+        if self.valid_authors_file() and result == "":
+            raise TypeError(
+                "Invalid configuration: if valid_authors_from_file is set, "
+                f"then must be valid_authors_schema must be set to one of {accepted}"
+            )
+        return str(self.parent_config.config.get("valid_authors_schema", ""))
+
+    # Property accessors
+    def valid_authors(self) -> list[str]:
+        """Author list, if empty or None, all are valid, unless file specified"""
+        author_file = self.valid_authors_file()
+        schema = self.valid_authors_schema()
+        if author_file and schema:
+            if schema == "single_column":
+                with open(author_file, encoding="utf-8") as file_handle:
+                    authors = [_ for _ in file_handle.readlines() if _]
+                return authors
+            if schema == "gnu_gnits":
+                authors = parse_authors_file_simple(author_file)
+                return authors
+
+        return [_.lower() for _ in self.parent_config.config.get("valid_authors", [])]
+
+    def valid_releases(self) -> list[str]:
+        """Releases (Version numbers), if empty or None, all are valid.
+        Past releases that do not match current schema are valid.
+        """
+        return [str(_).lower() for _ in self.parent_config.config.get("valid_releases", [])]
+
+    def valid_releases_file(self) -> str:
+        """File name of file with valid releases"""
+        valid_releases_from_file = self.parent_config.config.get("valid_releases_file", "")
+        return str(valid_releases_from_file).lower() if valid_releases_from_file else str(valid_releases_from_file)
+
+    def valid_releases_file_schema(self) -> str:
+        """Schema used to read from a known file type the valid versions."""
+        field = "valid_releases_file_schema"
+        result = self.parent_config.config.get(field, "")
+        accepted = ("keepachangelog",)
+        if result not in accepted:
+            raise TypeError(f"Invalid configuration: {field} must be in {accepted}")
+        if self.valid_releases_file() and not result:
+            raise TypeError(f"When valid_releases_from_file is set, {field} must be in {accepted}")
+        return str(result)
+
+    def releases_schema(self) -> str:
+        """Schema used to parse, sort release (version) numbers.
+        Not used to validate anything
+        """
+        field = "releases_schema"
+        result = self.parent_config.config.get(field, "")
+        accepted = ("semantic", "pep440", "")
+        if result not in accepted:
+            raise TypeError(f"Invalid configuration: {field} must be in {accepted}")
+        return str(result)
+
+    def valid_priorities(self) -> list[str]:
+        """Priority list, if empty or None, all are valid"""
+        return [_.lower() for _ in self.parent_config.config.get("valid_priorities", [])]
+
+    def valid_iterations(self) -> list[str]:
+        """Iteration list, if empty or None, all are valid."""
+        return [_.lower() for _ in self.parent_config.config.get("valid_iterations", [])]
+
+    def valid_custom_field_names(self) -> list[str]:
+        """Custom field names, if empty or None, all are valid."""
+        return [_.lower() for _ in self.parent_config.config.get("valid_custom_field_names", [])]
+
+    def mandatory_fields(self) -> list[str]:
+        """Mandatory fields, if empty or None, no mandatory fields."""
+        return [_.lower() for _ in self.parent_config.config.get("mandatory_fields", [])]
+
+    def tracker_domain(self) -> str:
+        """Domain of the tracker, used to make ticket links clickable."""
+        return str(self.parent_config.config.get("tracker_domain", ""))
+
+    def tracker_style(self) -> str:
+        """Style of the tracker, used to make ticket links clickable."""
+        field = "tracker_style"
+        result = self.parent_config.config.get(field, "")
+        accepted = ("url", "ticket", "")
+        if result not in accepted:
+            raise TypeError(f"Invalid configuration: {field} must be in {accepted}")
+        return str(result)
+
+    def valid_status(self) -> list[str]:
+        """Status list, if empty or None, all are valid"""
+        return [str(_).lower() for _ in self.parent_config.config.get("valid_status", [])]
+
+    def valid_categories(self) -> list[str]:
+        """Category list, if empty or None, all are valid"""
+        return [str(_).lower() for _ in self.parent_config.config.get("valid_categories", [])]
+
+    def closed_status(self) -> list[str]:
+        """If status equals this,then it is closed, needed for business rules"""
+        closed_status = self.parent_config.config.get("closed_status", [])
+        return [str(_).lower() for _ in closed_status]
+
+    def action_on_past_due(self) -> bool:
+        """Do actions do the default action"""
+        return careful_to_bool(self.parent_config.config.get("action_on_past_due", False), False)
+
+    def action_only_on_responsible_user(self) -> bool:
+        """Do actions do the default action when active user matches"""
+        return careful_to_bool(self.parent_config.config.get("action_only_on_responsible_user", False), False)
+
+
+def get_issue_tracker_config() -> IssueTrackerConfig:
+    return IssueTrackerConfig(get_code_tags_config())