eirmos 0.4.0__tar.gz

eirmos-0.4.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.4
+Name: eirmos
+Version: 0.4.0
+Summary: eirmos — explore the mental graph of your CI/CD pipelines. Parse and visualise pipeline dependencies across 13 systems (GitLab CI, GitHub Actions, Jenkins, CircleCI, Azure Pipelines, Bitbucket, Drone/Woodpecker, Travis, AppVeyor, Buildkite, Codefresh, Semaphore).
+Requires-Python: >=3.9
+Requires-Dist: PyYAML>=6.0
+Provides-Extra: dev
+Requires-Dist: coverage>=7.0; extra == "dev"
+Requires-Dist: shiv>=1.0; extra == "dev"
+Requires-Dist: build>=1.0; extra == "dev"

eirmos-0.4.0/README.md

@@ -0,0 +1,288 @@
+# eirmos
+
+> **Explore the mental graph of your CI/CD pipelines.**
+
+*eirmos* (from Greek **ειρμός**, *coherent train of thought*) parses
+and visualises CI/CD pipeline dependencies across **13 systems** —
+GitHub Actions, GitLab CI, Jenkins, CircleCI, Azure Pipelines, Bitbucket
+Pipelines, Drone CI, Woodpecker CI, Travis CI, AppVeyor, Buildkite,
+Codefresh, and Semaphore.
+
+Point it at a repo and get a job-dependency graph rendered as a
+terminal tree, Mermaid diagram, Graphviz dot, or text summary.
+Everything runs on your machine — no telemetry, no remote upload, no
+cloud account.
+
+```
+┌─────────────────────────────────────────────────────────────────┐
+│  repo path  ─►  detect()  ─►  parse  ─►  DependencyGraph        │
+│                                                ▲                │
+│                                                │                │
+│                                       Tree / Mermaid / Dot      │
+│                                       Summary / Variables       │
+└─────────────────────────────────────────────────────────────────┘
+```
+
+## Supported systems
+
+| System | Detection | Dependency model |
+|---|---|---|
+| GitHub Actions | `.github/workflows/*.yml` | `jobs[].needs` |
+| GitLab CI | `.gitlab-ci.yml` (+ includes) | `needs:`, `extends:`, `rules:`, `trigger:` |
+| Jenkins | `Jenkinsfile` (declarative DSL) | sequential `stage(...)`, `parallel { ... }` |
+| CircleCI | `.circleci/config.yml` | workflow `jobs: requires:` |
+| Azure Pipelines | `azure-pipelines.yml`, `.azure-pipelines/*.yml` | `stages[].dependsOn`, `jobs[].dependsOn`, implicit prev-stage |
+| Bitbucket Pipelines | `bitbucket-pipelines.yml` | sequential steps; `parallel:` siblings |
+| Drone CI | `.drone.yml` | `depends_on` (string/list); sequential fallback |
+| Woodpecker CI | `.woodpecker.yml`, `.woodpecker/*.yml` | same model as Drone |
+| Travis CI | `.travis.yml` | `jobs.include[].stage`; stages sequential, jobs-within parallel |
+| AppVeyor | `appveyor.yml`, `.appveyor.yml` | phases × matrix (capped) |
+| Buildkite | `.buildkite/pipeline*.yml` | `key`/`depends_on`; `wait` barriers; `group:` flatten |
+| Codefresh | `codefresh.yml`, `.codefresh.yml` | `when.steps[]`; `type: parallel` flattening |
+| Semaphore | `.semaphore/semaphore.yml` | `blocks[].dependencies` |
+
+> Polyglot repos (e.g. mid-migration from Travis to GitHub Actions) are
+> auto-detected: `eirmos` will print a warning naming all
+> matched systems and use the first per registry order. Override with
+> `--ci "GitHub Actions"`.
+
+## Install
+
+Pick the path that matches your environment:
+
+```bash
+# Recommended: uv tool (isolated, fast, no virtualenv juggling)
+uv tool install eirmos
+
+# One-shot, no install (uv ≥0.5)
+uvx eirmos .
+
+# Classic pipx (also isolated)
+pipx install eirmos
+
+# Single-file zipapp — runs anywhere with Python ≥3.9, no install
+curl -L -o eirmos.pyz https://github.com/<you>/<repo>/releases/latest/download/eirmos.pyz
+chmod +x eirmos.pyz
+./eirmos.pyz .
+
+# Plain pip (last resort, pollutes site-packages)
+pip install eirmos
+
+# From source for development
+git clone https://github.com/<you>/<repo>
+cd <repo>
+pip install -e ".[dev]"
+make test          # 172 tests
+make coverage      # ≥90% gate
+make pyz           # build the single-file zipapp
+```
+
+## CLI
+
+```bash
+# Auto-detect and render as a terminal tree
+eirmos .
+
+# Explicit path
+eirmos /path/to/repo
+
+# Force a CI system instead of auto-detection
+eirmos --ci "Buildkite" .
+
+# Mermaid output (paste into GitHub / docs)
+eirmos --format mermaid . > pipeline.mmd
+
+# Graphviz dot for high-res rendering
+eirmos --format dot . | dot -Tsvg -o pipeline.svg
+
+# Filter to a single stage / job
+eirmos --stage test .
+eirmos --job deploy_prod .
+
+# Inventory views
+eirmos --list-stages .
+eirmos --list-jobs   .
+
+# Skip GitLab includes
+eirmos --no-includes .
+```
+
+## Library usage
+
+Every parser implements the same protocol; you can use them directly:
+
+```python
+from pathlib import Path
+from eirmos import (
+    BuildkiteParser, DependencyGraph, MermaidFormatter,
+)
+
+parser = BuildkiteParser(base_path="my-repo").parse(
+    Path("my-repo/.buildkite/pipeline.yml")
+)
+graph = DependencyGraph(parser)
+print(MermaidFormatter(parser, graph).render())
+```
+
+Auto-detect at runtime:
+
+```python
+from pathlib import Path
+from eirmos.parsers import detect
+from eirmos import DependencyGraph, TreeFormatter
+
+adapter, main_file = detect(Path("my-repo"))
+parser = adapter.parser_class(base_path="my-repo").parse(main_file)
+graph = DependencyGraph(parser)
+print(TreeFormatter(parser, graph).render())
+```
+
+## Output formats
+
+| `--format` | Use case |
+|---|---|
+| `tree` | Default. Coloured terminal tree grouped by stage. |
+| `mermaid` | GitHub / GitLab / docs (renders inline). |
+| `dot` | Graphviz; pipe into `dot -Tsvg` for high-res. |
+| `summary` | Statistics only (job counts, edge counts, roots). |
+| `variables` | Lists global + per-job variables (where supported). |
+
+## Non-obvious per-system semantics
+
+These are the bits that aren't immediately obvious from the YAML —
+worth knowing when you read a generated graph.
+
+### Buildkite — `wait` is a cross-product barrier
+
+```
+                wait
+   step_a ──┐  ┌──► step_d
+   step_b ──┤  ├──► step_e
+   step_c ──┘  └──► step_f
+```
+
+Every step *after* a `wait` implicitly depends on every step *before*
+the same `wait`. If a post-wait step already declares `depends_on`,
+the explicit list wins (no double-add).
+
+### Codefresh — `type: parallel` flattens to peers
+
+```
+   prev_step ──► [parallel block] ──► next_step
+                  ├── child_1
+                  ├── child_2     (peers, no edges between them)
+                  └── child_3
+```
+
+Children of a `type: parallel` block are exposed as peer jobs. Each
+inherits the parallel block's predecessor (computed from `when.steps`
+of the parent block, or sequential fallback).
+
+### Travis — stages sequential, jobs-in-stage parallel
+
+```
+   stage:  build           ── compile  ◄──┐
+                                            ├── (predecessor of every "test" job)
+   stage:  test            ── unit     ◄──┤
+                            ── integ    ◄──┘    (peers, no edge)
+   stage:  deploy          ── release  ◄── unit AND integ
+```
+
+### AppVeyor — phases × matrix, capped
+
+Phases run sequentially: `init → install → before_build → build →
+after_build → before_test → test → after_test → deploy → after_deploy`.
+For each combination in `environment.matrix` × `image`, every active
+phase produces one job. Combinations are capped at `matrix_limit`
+(default `200`) — passes that cap and the parser emits a warning.
+
+### Azure — implicit prev-stage default
+
+A stage without `dependsOn:` implicitly depends on the previous stage
+in declaration order. Stage-level `dependsOn` is mapped to the *last
+jobs* of the predecessor stage so cross-stage edges always connect to
+real nodes.
+
+### Polyglot detection
+
+`detect()` walks the entire registry. If two or more adapters match
+the same repo, a yellow warning is printed naming all matches and the
+first one (per registry order) is used. Override with `--ci`.
+
+## Architecture
+
+The codebase is organised in clear layers:
+
+```
+                   ┌───────────────────────────────────┐
+                   │   cli.py  (argparse + glue)       │
+                   └───────┬───────────────────────────┘
+                           │
+            ┌──────────────▼──────────────┐
+            │   parsers/registry.detect() │
+            │   first-match + multi warn  │
+            └──────────────┬──────────────┘
+                           │  ParserAdapter
+        ┌──────────────────▼─────────────────────┐
+        │  parsers/  (BasePipelineParser)        │
+        │  GitHub  GitLab  CircleCI  Jenkins     │
+        │  Azure   Bitbucket  Drone  Woodpecker  │
+        │  Travis  AppVeyor  Buildkite           │
+        │  Codefresh  Semaphore                  │
+        └──────────────────┬─────────────────────┘
+                           │  jobs / file_map / get_job_*
+                           ▼
+                ┌──────────────────────┐
+                │   graph.py           │
+                │   DependencyGraph    │
+                └──────────┬───────────┘
+                           │  edges / roots / has_cycle
+                           ▼
+        ┌──────────────────────────────────────┐
+        │  formatters/  (BaseFormatter)        │
+        │  Tree  Mermaid  Dot  Summary  Vars   │
+        └──────────────────────────────────────┘
+```
+
+A deeper write-up with class and sequence diagrams lives in
+[`docs/architecture.md`](docs/architecture.md).
+
+## Adding a new CI system
+
+1. Implement `BasePipelineParser` in `eirmos/parsers/<system>.py`.
+   Populate `self.jobs`, `self.file_map`, `self.parsed_files`, and
+   override `get_job_stage` / `get_job_needs`.
+2. Reuse the shared YAML loader: `content = self._load_yaml(path)`.
+3. Register a `ParserAdapter` in `parsers/__init__.py` with a `detect()`
+   helper that returns the main pipeline file (or `None`).
+4. Add a fixture in `tests/examples/` and a `tests/test_<system>_parser.py`
+   covering happy path, malformed YAML, missing file, cycle, empty, and
+   single-job cases.
+5. Add the parser to `eirmos/__init__.py` exports.
+
+The cross-cutting test in `tests/test_graph_integration.py` will
+automatically smoke-test the new parser through every formatter once
+it's added to the `PARSER_FIXTURES` list.
+
+## Development
+
+```bash
+# Run the full suite (172 tests)
+python -m unittest discover -s tests
+
+# Coverage gate (≥90%)
+python -m coverage run --source=eirmos -m unittest discover -s tests
+python -m coverage report -m --fail-under=90
+```
+
+## Project status
+
+- **172 tests, 91% coverage.**
+- 13 supported CI systems.
+- Deferred adapters (Spinnaker, TeamCity, Concourse, Argo, Tekton)
+  are tracked in [`TODOS.md`](TODOS.md) with per-system context and
+  start-here notes.
+
+## License
+
+See `LICENSE` (or repository root) for licensing terms.

eirmos-0.4.0/eirmos/__init__.py

@@ -0,0 +1,70 @@
+"""CI/CD pipeline visualiser.
+
+A small library + CLI for parsing CI/CD pipeline definitions and
+rendering them in various formats (tree, mermaid, dot, summary).
+
+Supported systems: GitLab CI, GitHub Actions, Jenkins, CircleCI,
+Azure Pipelines, Bitbucket Pipelines, Drone CI, Woodpecker CI,
+Travis CI, AppVeyor, Buildkite, Codefresh, Semaphore.
+
+The package is organised in clear architectural layers:
+
+    parsers/    - read pipeline definition files and produce a domain model
+    graph.py    - build a dependency graph from a parser
+    formatters/ - render graphs to text/diagram formats
+    cli.py      - thin command-line entry point
+    colors.py   - ANSI color helpers (presentation only)
+
+New CI systems can be supported by implementing
+:class:`eirmos.parsers.base.BasePipelineParser` and
+registering a :class:`eirmos.parsers.registry.ParserAdapter`.
+"""
+
+from .colors import Colors
+from .parsers.gitlab import GitLabCIParser
+from .parsers.github import GitHubActionsParser
+from .parsers.jenkins import JenkinsParser
+from .parsers.circleci import CircleCIParser
+from .parsers.azure import AzurePipelinesParser
+from .parsers.bitbucket import BitbucketPipelinesParser
+from .parsers.drone import DroneParser, WoodpeckerParser
+from .parsers.travis import TravisCIParser
+from .parsers.appveyor import AppVeyorParser
+from .parsers.buildkite import BuildkiteParser
+from .parsers.codefresh import CodefreshParser
+from .parsers.semaphore import SemaphoreParser
+from .parsers.base import BasePipelineParser
+from .parsers.registry import ParserAdapter, REGISTRY, register_adapter
+from .graph import DependencyGraph
+from .formatters.tree import TreeFormatter
+from .formatters.mermaid import MermaidFormatter
+from .formatters.dot import DotFormatter
+from .formatters.summary import SummaryFormatter
+from .formatters.variables import VariableFormatter
+
+__all__ = [
+    "Colors",
+    "BasePipelineParser",
+    "GitLabCIParser",
+    "GitHubActionsParser",
+    "JenkinsParser",
+    "CircleCIParser",
+    "AzurePipelinesParser",
+    "BitbucketPipelinesParser",
+    "DroneParser",
+    "WoodpeckerParser",
+    "TravisCIParser",
+    "AppVeyorParser",
+    "BuildkiteParser",
+    "CodefreshParser",
+    "SemaphoreParser",
+    "ParserAdapter",
+    "REGISTRY",
+    "register_adapter",
+    "DependencyGraph",
+    "TreeFormatter",
+    "MermaidFormatter",
+    "DotFormatter",
+    "SummaryFormatter",
+    "VariableFormatter",
+]

eirmos-0.4.0/eirmos/__main__.py

@@ -0,0 +1,7 @@
+"""Allow ``python -m eirmos``."""
+
+import sys
+from .cli import main
+
+if __name__ == '__main__':
+    sys.exit(main())

eirmos-0.4.0/eirmos/_yaml.py

@@ -0,0 +1,25 @@
+"""YAML loader configured for GitLab CI specifics.
+
+Importing this module has the side effect of registering the
+``!reference`` constructor on ``yaml.SafeLoader``.  Centralising
+the import means PyYAML is loaded exactly once and there's a
+single place to change the loader configuration.
+"""
+
+import sys
+
+try:
+    import yaml
+except ImportError:  # pragma: no cover - import-time guard
+    print("ERROR: PyYAML is required. Install with: pip install pyyaml")
+    sys.exit(1)
+
+
+def _reference_constructor(loader, node):
+    """Handle GitLab CI ``!reference`` tags by returning the sequence as-is."""
+    return loader.construct_sequence(node)
+
+
+yaml.add_constructor('!reference', _reference_constructor, Loader=yaml.SafeLoader)
+
+__all__ = ["yaml"]

eirmos-0.4.0/eirmos/cli.py

@@ -0,0 +1,181 @@
+"""Command-line entry point.
+
+Kept intentionally thin: argument parsing + parser/formatter
+selection. All real logic lives in the dedicated modules.
+
+Parser selection is driven by the
+:mod:`eirmos.parsers.registry`, so adding a new CI/CD
+system is a matter of registering a :class:`ParserAdapter`.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .colors import Colors
+from .graph import DependencyGraph
+from .parsers import detect as detect_adapter, REGISTRY
+from .parsers.gitlab import GitLabCIParser
+from .formatters.tree import TreeFormatter
+from .formatters.mermaid import MermaidFormatter
+from .formatters.dot import DotFormatter
+from .formatters.summary import SummaryFormatter
+from .formatters.variables import VariableFormatter
+
+
+FORMATTERS = {
+    'tree': TreeFormatter,
+    'mermaid': MermaidFormatter,
+    'dot': DotFormatter,
+    'summary': SummaryFormatter,
+    'variables': VariableFormatter,
+}
+
+
+def find_ci_files(base_path):
+    """Find all GitLab CI files in the repository.
+
+    Kept for backwards compatibility with previous releases of the
+    package; the CLI now relies on the parser registry.
+    """
+    patterns = ['**/*.gitlab-ci.yml', '**/*.gitlab-ci.yaml', '.gitlab-ci.yml']
+    files = set()
+    for pattern in patterns:
+        for f in Path(base_path).glob(pattern):
+            files.add(f)
+    return sorted(files)
+
+
+def build_arg_parser():
+    supported = ', '.join(a.name for a in REGISTRY) or 'none registered'
+    arg_parser = argparse.ArgumentParser(
+        prog='eirmos',
+        description=(
+            'CI/CD Pipeline Visualiser - Parse and visualise job dependencies. '
+            f'Supported systems: {supported}.'
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    arg_parser.add_argument('path', nargs='?', default='.',
+                            help='Path to repository root (default: current directory)')
+    arg_parser.add_argument('--format', '-f', choices=list(FORMATTERS.keys()),
+                            default='tree', help='Output format (default: tree)')
+    arg_parser.add_argument('--stage', '-s', default=None,
+                            help='Filter output to a specific stage')
+    arg_parser.add_argument('--job', '-j', default=None,
+                            help='Show detailed dependencies for a specific job')
+    arg_parser.add_argument('--no-includes', action='store_true',
+                            help='Do not follow local include directives (GitLab only)')
+    arg_parser.add_argument('--output', '-o', default=None,
+                            help='Output file path (default: stdout)')
+    arg_parser.add_argument('--no-color', action='store_true',
+                            help='Disable colored output')
+    arg_parser.add_argument('--list-stages', action='store_true',
+                            help='List all stages and exit')
+    arg_parser.add_argument('--list-jobs', action='store_true',
+                            help='List all jobs and exit')
+    arg_parser.add_argument('--ci', default=None,
+                            choices=[a.name for a in REGISTRY],
+                            help='Force a specific CI system instead of auto-detection')
+    return arg_parser
+
+
+def _select_ci_file(base_path, forced_name=None):
+    """Return ``(adapter, main_ci_file)`` for ``base_path``.
+
+    If ``forced_name`` is given, only that adapter is consulted.
+    Otherwise the registry is queried in registration order and the
+    first hit wins. As a last-resort fallback we still recognise
+    misplaced ``*.gitlab-ci.yml`` files so existing behaviour is
+    preserved.
+    """
+    if forced_name:
+        for adapter in REGISTRY:
+            if adapter.name == forced_name:
+                main = adapter.detect(base_path)
+                if main is not None:
+                    print(f"{Colors.DIM}Forced CI system: {adapter.name} "
+                          f"({main.name}){Colors.RESET}", file=sys.stderr)
+                    return adapter, main
+        return None, None
+
+    adapter, main_file = detect_adapter(base_path)
+    if adapter is not None:
+        print(f"{Colors.DIM}Detected {adapter.name}: {main_file.name}"
+              f"{Colors.RESET}", file=sys.stderr)
+        return adapter, main_file
+
+    # Legacy fallback: any stray *.gitlab-ci.yml
+    ci_files = find_ci_files(base_path)
+    if ci_files:
+        print(f"WARNING: No CI definition found at root. "
+              f"Found {len(ci_files)} GitLab CI files; using {ci_files[0].name}.",
+              file=sys.stderr)
+        # Build a synthetic adapter for legacy callers.
+        from .parsers.registry import ParserAdapter
+        legacy = ParserAdapter(
+            name="GitLab CI",
+            parser_class=GitLabCIParser,
+            detect=lambda _: ci_files[0],
+            parser_kwargs=lambda args: {
+                'follow_includes': not getattr(args, 'no_includes', False),
+            },
+        )
+        return legacy, ci_files[0]
+
+    return None, None
+
+
+def main(argv=None):
+    args = build_arg_parser().parse_args(argv)
+
+    if args.no_color or args.output or not sys.stdout.isatty():
+        Colors.disable()
+
+    base_path = Path(args.path).resolve()
+    if not base_path.exists():
+        print(f"ERROR: Path '{args.path}' does not exist.", file=sys.stderr)
+        return 1
+
+    adapter, main_ci_file = _select_ci_file(base_path, forced_name=args.ci)
+    if not main_ci_file or adapter is None:
+        supported = ', '.join(a.name for a in REGISTRY)
+        print(f"ERROR: No supported CI files found ({supported}).", file=sys.stderr)
+        return 1
+
+    print(f"{Colors.DIM}Parsing CI files from: {base_path}{Colors.RESET}", file=sys.stderr)
+
+    parser = adapter.parser_class(base_path=base_path, **adapter.parser_kwargs(args))
+    parser.parse(main_ci_file)
+
+    print(f"{Colors.DIM}Parsed {len(parser.parsed_files)} files, "
+          f"found {len(parser.jobs)} jobs.{Colors.RESET}\n", file=sys.stderr)
+
+    if args.list_stages:
+        graph = DependencyGraph(parser)
+        for stage in graph.get_ordered_stages():
+            count = len(graph.stage_jobs.get(stage, []))
+            print(f"{stage} ({count} jobs)")
+        return 0
+
+    if args.list_jobs:
+        for job_name in sorted(parser.jobs.keys()):
+            stage = parser.get_job_stage(job_name)
+            print(f"{job_name:<60} [{stage}]")
+        return 0
+
+    graph = DependencyGraph(parser)
+    formatter = FORMATTERS[args.format](parser, graph)
+    output = formatter.render(filter_stage=args.stage, filter_job=args.job)
+
+    if args.output:
+        with open(args.output, 'w') as f:
+            f.write(output)
+        print(f"Output written to: {args.output}", file=sys.stderr)
+    else:
+        print(output)
+    return 0
+
+
+if __name__ == '__main__':  # pragma: no cover
+    sys.exit(main())

eirmos-0.4.0/eirmos/colors.py

@@ -0,0 +1,32 @@
+"""ANSI color codes used by the text formatters.
+
+This module is purposely tiny — it is the only place that knows
+about terminal escape sequences.  Other layers should depend on
+``Colors`` rather than hard-coding escape codes so they can be
+disabled centrally (e.g. when writing to a file or a non-TTY).
+"""
+
+
+class Colors:
+    HEADER = '\033[95m'
+    BLUE = '\033[94m'
+    CYAN = '\033[96m'
+    GREEN = '\033[92m'
+    YELLOW = '\033[93m'
+    RED = '\033[91m'
+    BOLD = '\033[1m'
+    DIM = '\033[2m'
+    RESET = '\033[0m'
+
+    @classmethod
+    def disable(cls):
+        """Replace all color codes with empty strings (irreversible)."""
+        cls.HEADER = ''
+        cls.BLUE = ''
+        cls.CYAN = ''
+        cls.GREEN = ''
+        cls.YELLOW = ''
+        cls.RED = ''
+        cls.BOLD = ''
+        cls.DIM = ''
+        cls.RESET = ''

eirmos-0.4.0/eirmos/formatters/__init__.py

@@ -0,0 +1,22 @@
+"""Output formatters for ``DependencyGraph`` instances.
+
+All formatters share the same constructor signature
+``Formatter(parser, graph)`` and a ``render(filter_stage=None,
+filter_job=None) -> str`` method, making them interchangeable.
+"""
+
+from .base import BaseFormatter
+from .tree import TreeFormatter
+from .mermaid import MermaidFormatter
+from .dot import DotFormatter
+from .summary import SummaryFormatter
+from .variables import VariableFormatter
+
+__all__ = [
+    "BaseFormatter",
+    "TreeFormatter",
+    "MermaidFormatter",
+    "DotFormatter",
+    "SummaryFormatter",
+    "VariableFormatter",
+]

eirmos-0.4.0/eirmos/formatters/base.py

@@ -0,0 +1,19 @@
+"""Common base class for formatters."""
+
+import re
+
+
+class BaseFormatter:
+    """Tiny shared base — keeps formatter API uniform."""
+
+    def __init__(self, parser, graph):
+        self.parser = parser
+        self.graph = graph
+
+    def render(self, filter_stage=None, filter_job=None):  # pragma: no cover
+        raise NotImplementedError
+
+    @staticmethod
+    def sanitize_id(name):
+        """Sanitize a name for use as a Mermaid/DOT identifier."""
+        return re.sub(r'[^a-zA-Z0-9_]', '_', name)