opentide 0.1.0__py3-none-any.whl

opentide/__init__.py

@@ -0,0 +1,8 @@
+"""OpenTide DetectionOps engine."""
+
+from __future__ import annotations
+
+from opentide._version import __version__
+from opentide.core.registry import OpenTide
+
+__all__ = ["__version__", "OpenTide"]

opentide/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

opentide/ci/__init__.py

@@ -0,0 +1,6 @@
+"""CI pipeline template renderers for GitHub, GitLab, and Azure DevOps."""
+
+from opentide.ci.models import CiRenderOptions
+from opentide.ci.render import render_ci
+
+__all__ = ["CiRenderOptions", "render_ci"]

opentide/ci/azure.py

@@ -0,0 +1,174 @@
+"""Azure DevOps pipeline renderer."""
+
+from __future__ import annotations
+
+import textwrap
+
+from opentide.ci.inflight import azure_inflight_job, azure_inflight_prune_job
+from opentide.ci.models import CiRenderOptions
+from opentide.ci.stages import (
+    document_steps,
+    header_comment,
+    pip_install,
+    production_deploy_steps,
+    promotion_steps,
+    staging_deploy_steps,
+)
+from opentide.cli.enums import QUERY_VALIDATION_PLATFORMS
+
+
+def _bash_script(commands: list[str], indent: int = 12) -> str:
+    joined = " && ".join(commands)
+    pad = " " * indent
+    return f"{pad}- script: |\n{pad}    {joined}"
+
+
+def _python_setup(options: CiRenderOptions, indent: int = 10) -> str:
+    pad = " " * indent
+    return textwrap.dedent(
+        f"""\
+        {pad}- task: UsePythonVersion@0
+        {pad}  inputs:
+        {pad}    versionSpec: '{options.python_version}'
+        {pad}- script: {pip_install(options)}
+        {pad}  displayName: Install OpenTide
+        """
+    )
+
+
+def render_azure(options: CiRenderOptions) -> str:
+    branch = options.default_branch
+    validate_steps = _python_setup(options) + "\n" + _bash_script(["opentide validate"])
+
+    query_jobs: list[str] = []
+    for platform in options.platforms:
+        if platform not in QUERY_VALIDATION_PLATFORMS:
+            continue
+        safe = platform.replace("_", "-")
+        query_jobs.append(
+            textwrap.dedent(
+                f"""\
+                  - job: validate_query_{safe}
+                    displayName: Validate query ({platform})
+                    steps:
+                {_python_setup(options)}
+                {_bash_script([f"opentide validate query --platform {platform}"])}
+                """
+            )
+        )
+
+    staging_job = ""
+    inflight_job = ""
+    inflight_prune_job = ""
+    if options.staging:
+        staging_job = textwrap.dedent(
+            f"""\
+              - job: deploy_staging
+                displayName: Deploy Staging
+                dependsOn: generate
+                condition: eq(variables['Build.Reason'], 'PullRequest')
+                steps:
+            {_python_setup(options)}
+            {_bash_script(staging_deploy_steps(options))}
+            """
+        )
+    if options.inflight:
+        inflight_job = azure_inflight_job(
+            python_version=options.python_version,
+            opentide_version=options.opentide_version,
+            default_branch=branch,
+        )
+        inflight_prune_job = azure_inflight_prune_job(
+            python_version=options.python_version,
+            opentide_version=options.opentide_version,
+            default_branch=branch,
+        )
+
+    promote_stage = ""
+    promote_cmds = promotion_steps(options)
+    if promote_cmds:
+        promote_stage = textwrap.dedent(
+            f"""\
+            - stage: Promote
+              displayName: Promote
+              dependsOn: Deploy
+              condition: >
+                and(succeeded(), eq(variables['Build.SourceBranch'], 'refs/heads/{branch}'))
+              jobs:
+                - job: promote
+                  displayName: Promote rules
+                  steps:
+            {_python_setup(options)}
+            {_bash_script(promotion_steps(options))}
+            """
+        )
+
+    query_jobs_block = "\n".join(query_jobs)
+    validate_jobs = textwrap.dedent(
+        f"""\
+          - job: validate
+            displayName: Validate objects
+            steps:
+        {validate_steps}
+        """
+    )
+    if query_jobs_block:
+        validate_jobs = validate_jobs + query_jobs_block
+
+    body = textwrap.dedent(
+        f"""\
+        trigger:
+          branches:
+            include:
+              - {branch}
+
+        pr:
+          branches:
+            include:
+              - {branch}
+
+        stages:
+          - stage: Validate
+            displayName: Validate
+            jobs:
+        {validate_jobs}
+
+          - stage: Generate
+            displayName: Generate
+            dependsOn: Validate
+            jobs:
+              - job: generate
+                displayName: Generate framework artifacts
+                steps:
+            {_python_setup(options)}
+            {_bash_script(["opentide generate"])}
+
+          - stage: Deploy
+            displayName: Deploy
+            dependsOn: Generate
+            jobs:
+        {staging_job}
+        {inflight_job}
+        {inflight_prune_job}
+              - job: deploy_production
+                displayName: Deploy Production
+                dependsOn: generate
+                condition: eq(variables['Build.SourceBranch'], 'refs/heads/{branch}')
+                steps:
+            {_python_setup(options)}
+            {_bash_script(production_deploy_steps(options))}
+
+          - stage: Document
+            displayName: Document
+            dependsOn: Generate
+            condition: eq(variables['Build.SourceBranch'], 'refs/heads/{branch}')
+            jobs:
+              - job: document
+                displayName: Generate documentation
+                steps:
+            {_python_setup(options)}
+            {_bash_script(document_steps(options))}
+        {promote_stage}
+        """
+    )
+    return header_comment(options) + body

opentide/ci/discovery.py

@@ -0,0 +1,31 @@
+"""Discover enabled platforms from repository configuration."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from opentide.registry.discovery import OPENTIDE_DIR
+
+_PLATFORM_SECTION = re.compile(r"^\[platform\]\s*$", re.MULTILINE)
+_ENABLED = re.compile(r"^enabled\s*=\s*true\s*$", re.MULTILINE | re.IGNORECASE)
+
+
+def platforms_config_dir(repo: Path) -> Path:
+    return repo / OPENTIDE_DIR / "configurations" / "platforms"
+
+
+def discover_enabled_platforms(repo: Path) -> list[str]:
+    """Return platform identifiers with ``enabled = true`` in platform TOML files."""
+    config_dir = platforms_config_dir(repo)
+    if not config_dir.is_dir():
+        return []
+    enabled: list[str] = []
+    for path in sorted(config_dir.glob("*.toml")):
+        text = path.read_text(encoding="utf-8")
+        if not _PLATFORM_SECTION.search(text):
+            continue
+        if not _ENABLED.search(text):
+            continue
+        enabled.append(path.stem)
+    return enabled

opentide/ci/github.py

@@ -0,0 +1,279 @@
+"""GitHub Actions workflow renderer."""
+
+from __future__ import annotations
+
+import textwrap
+
+from opentide.ci.inflight import github_inflight_job, github_inflight_prune_job
+from opentide.ci.models import CiRenderOptions
+from opentide.ci.stages import (
+    document_steps,
+    header_comment,
+    pip_install,
+    production_deploy_steps,
+    promotion_steps,
+    query_platforms,
+    staging_deploy_steps,
+)
+
+
+def _indent_yaml(text: str, spaces: int) -> str:
+    pad = " " * spaces
+    return "\n".join(pad + line if line else line for line in text.splitlines())
+
+
+def _run_steps(commands: list[str], indent: int = 10) -> str:
+    lines = []
+    for cmd in commands:
+        lines.append(f"- run: {cmd}")
+    return _indent_yaml("\n".join(lines), indent)
+
+
+def _explorer_jobs(branch: str, python_version: str) -> list[str]:
+    explorer_job = textwrap.dedent(
+        f"""\
+        explorer:
+          name: Build explorer
+          runs-on: ubuntu-latest
+          needs: document
+          env:
+            HAS_GITHUB_APP: ${{{{ secrets.GH_APP_ID && secrets.GH_APP_KEY && 'true' || 'false' }}}}
+          steps:
+            - name: Checkout repository
+              uses: actions/checkout@v4
+
+            - name: Generate GitHub App token
+              id: generate_token
+              if: ${{{{ env.HAS_GITHUB_APP == 'true' }}}}
+              uses: actions/create-github-app-token@v1
+              with:
+                app-id: ${{{{ secrets.GH_APP_ID }}}}
+                private-key: ${{{{ secrets.GH_APP_KEY }}}}
+                owner: OpenTideHQ
+                repositories: opentide
+
+            - name: Checkout opentide
+              uses: actions/checkout@v4
+              with:
+                repository: OpenTideHQ/opentide
+                ref: development
+                path: opentide
+                token: ${{{{ steps.generate_token.outputs.token || secrets.OPENTIDE_REPO_TOKEN }}}}
+
+            - name: Checkout explorer
+              uses: actions/checkout@v4
+              with:
+                repository: OpenTideHQ/explorer
+                ref: main
+                path: explorer
+
+            - uses: actions/setup-python@v5
+              with:
+                python-version: "{python_version}"
+
+            - uses: actions/setup-node@v4
+              with:
+                node-version: "22"
+
+            - name: Install opentide
+              run: pip install -e ./opentide
+
+            - name: Build explorer static site
+              run: |
+                opentide explorer build \
+                  --output ./out/explorer \
+                  --base-path /${{{{ github.event.repository.name }}}}
+              env:
+                OPENTIDE_REPO_ROOT: ${{{{ github.workspace }}}}
+                OPENTIDE_EXPLORER_PATH: ${{{{ github.workspace }}}}/explorer
+
+            - name: Upload Pages artifact
+              uses: actions/upload-pages-artifact@v3
+              with:
+                path: ./out/explorer
+        """
+    )
+    deploy_job = textwrap.dedent(
+        f"""\
+        deploy-explorer:
+          name: Deploy explorer to GitHub Pages
+          runs-on: ubuntu-latest
+          needs: explorer
+          if: github.event_name == 'push' && github.ref == format('refs/heads/{branch}')
+          permissions:
+            pages: write
+            id-token: write
+          environment:
+            name: github-pages
+            url: ${{{{ steps.deployment.outputs.page_url }}}}
+          steps:
+            - name: Deploy to GitHub Pages
+              id: deployment
+              uses: actions/deploy-pages@v4
+        """
+    )
+    return [explorer_job, deploy_job]
+
+
+def render_github(options: CiRenderOptions) -> str:
+    branch = options.default_branch
+    setup_steps = textwrap.dedent(
+        f"""\
+        - uses: actions/checkout@v4
+        - uses: actions/setup-python@v5
+          with:
+            python-version: "{options.python_version}"
+        - run: {pip_install(options)}
+        """
+    )
+
+    validate_body = setup_steps + _run_steps(
+        ["opentide validate"]
+        + [f"opentide validate query --platform {p}" for p in query_platforms(options)]
+    )
+
+    generate_body = setup_steps + _run_steps(["opentide generate"])
+
+    jobs: list[str] = []
+
+    jobs.append(
+        textwrap.dedent(
+            f"""\
+            validate:
+              name: Validate
+              runs-on: ubuntu-latest
+              steps:
+            {validate_body}
+            """
+        )
+    )
+
+    jobs.append(
+        textwrap.dedent(
+            f"""\
+            generate:
+              name: Generate
+              needs: validate
+              runs-on: ubuntu-latest
+              steps:
+            {generate_body}
+            """
+        )
+    )
+
+    if options.staging:
+        staging_cmds = staging_deploy_steps(options)
+        jobs.append(
+            textwrap.dedent(
+                f"""\
+                deploy_staging:
+                  name: Deploy Staging
+                  needs: generate
+                  if: github.event_name == 'pull_request'
+                  runs-on: ubuntu-latest
+                  steps:
+                {setup_steps}{_run_steps(staging_cmds)}
+                """
+            )
+        )
+
+    if options.inflight:
+        jobs.append(
+            github_inflight_job(
+                python_version=options.python_version,
+                opentide_version=options.opentide_version,
+                default_branch=branch,
+            )
+        )
+        jobs.append(
+            github_inflight_prune_job(
+                python_version=options.python_version,
+                opentide_version=options.opentide_version,
+                default_branch=branch,
+            )
+        )
+
+    prod_needs = "deploy_staging" if options.staging else "generate"
+    prod_if = f"github.event_name == 'push' && github.ref == format('refs/heads/{branch}')"
+    jobs.append(
+        textwrap.dedent(
+            f"""\
+            deploy_production:
+              name: Deploy Production
+              needs: {prod_needs}
+              if: {prod_if}
+              runs-on: ubuntu-latest
+              steps:
+            {setup_steps}{_run_steps(production_deploy_steps(options))}
+            """
+        )
+    )
+
+    if options.promotion and promotion_steps(options):
+        jobs.append(
+            textwrap.dedent(
+                f"""\
+                promote:
+                  name: Promote Rules
+                  needs: deploy_production
+                  if: {prod_if}
+                  runs-on: ubuntu-latest
+                  steps:
+                {setup_steps}{_run_steps(promotion_steps(options))}
+                """
+            )
+        )
+
+    jobs.append(
+        textwrap.dedent(
+            f"""\
+            document:
+              name: Document
+              needs: generate
+              if: {prod_if}
+              runs-on: ubuntu-latest
+              steps:
+            {setup_steps}{_run_steps(document_steps(options))}
+            """
+        )
+    )
+
+    if options.explorer_pages:
+        jobs.extend(_explorer_jobs(branch, options.python_version))
+
+    permissions = ""
+    concurrency = ""
+    if options.explorer_pages:
+        permissions = textwrap.dedent(
+            """\
+            permissions:
+              contents: read
+              pages: write
+              id-token: write
+
+            """
+        )
+        concurrency = textwrap.dedent(
+            """\
+            concurrency:
+              group: pages
+              cancel-in-progress: false
+
+            """
+        )
+
+    body = textwrap.dedent(
+        f"""\
+        name: OpenTide
+
+        on:
+          pull_request:
+          push:
+            branches:
+              - {branch}
+
+        {permissions}{concurrency}jobs:
+        """
+    )
+    job_yaml = "\n".join(_indent_yaml(job, 2) for job in jobs)
+    return header_comment(options) + body + job_yaml

opentide/ci/gitlab.py

@@ -0,0 +1,176 @@
+"""GitLab CI pipeline renderer."""
+
+from __future__ import annotations
+
+import textwrap
+
+from opentide.ci.inflight import gitlab_inflight_job, gitlab_inflight_prune_job
+from opentide.ci.models import CiRenderOptions
+from opentide.ci.stages import (
+    document_steps,
+    header_comment,
+    pip_install,
+    production_deploy_steps,
+    promotion_steps,
+    staging_deploy_steps,
+)
+from opentide.cli.enums import QUERY_VALIDATION_PLATFORMS
+
+
+def _script_block(commands: list[str], indent: int = 4) -> str:
+    pad = " " * indent
+    lines = [f"{pad}- {cmd}" for cmd in commands]
+    return "\n".join(lines)
+
+
+def _base_before_script(options: CiRenderOptions) -> str:
+    return _script_block([pip_install(options)])
+
+
+def render_gitlab(options: CiRenderOptions) -> str:
+    stages = ["validate", "generate", "deploy", "document"]
+    promote_cmds = promotion_steps(options)
+    if promote_cmds:
+        stages.insert(3, "promote")
+
+    validate_script = _script_block(["opentide validate"])
+    query_jobs: list[str] = []
+    for platform in options.platforms:
+        if platform not in QUERY_VALIDATION_PLATFORMS:
+            continue
+        job_name = platform.replace("_", "-")
+        query_jobs.append(
+            textwrap.dedent(
+                f"""\
+                validate_query_{job_name}:
+                  stage: validate
+                  image: python:{options.python_version}-slim
+                  before_script:
+                {_base_before_script(options)}
+                  script:
+                    - opentide validate query --platform {platform}
+                """
+            )
+        )
+
+    deploy_jobs: list[str] = []
+    if options.staging:
+        deploy_jobs.append(
+            textwrap.dedent(
+                f"""\
+                deploy_staging:
+                  stage: deploy
+                  image: python:{options.python_version}-slim
+                  rules:
+                    - if: $CI_PIPELINE_SOURCE == "merge_request_event"
+                  before_script:
+                {_base_before_script(options)}
+                  script:
+                {_script_block(staging_deploy_steps(options))}
+                  needs:
+                    - generate
+                """
+            )
+        )
+
+    deploy_jobs.append(
+        textwrap.dedent(
+            f"""\
+            deploy_production:
+              stage: deploy
+              image: python:{options.python_version}-slim
+              rules:
+                - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+              before_script:
+            {_base_before_script(options)}
+              script:
+            {_script_block(production_deploy_steps(options))}
+              needs:
+                - generate
+            """
+        )
+    )
+
+    if options.inflight:
+        deploy_jobs.append(
+            gitlab_inflight_job(
+                python_version=options.python_version,
+                opentide_version=options.opentide_version,
+            )
+        )
+        deploy_jobs.append(
+            gitlab_inflight_prune_job(
+                python_version=options.python_version,
+                opentide_version=options.opentide_version,
+            )
+        )
+
+    promote_job = ""
+    if promote_cmds:
+        promote_job = textwrap.dedent(
+            f"""\
+            promote:
+              stage: promote
+              image: python:{options.python_version}-slim
+              rules:
+                - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+              before_script:
+            {_base_before_script(options)}
+              script:
+            {_script_block(promotion_steps(options))}
+              needs:
+                - deploy_production
+            """
+        )
+
+    document_job = textwrap.dedent(
+        f"""\
+        document:
+          stage: document
+          image: python:{options.python_version}-slim
+          rules:
+            - if: $CI_COMMIT_BRANCH == $CI_DEFAULT_BRANCH
+          before_script:
+        {_base_before_script(options)}
+          script:
+        {_script_block(document_steps(options))}
+          needs:
+            - generate
+        """
+    )
+
+    stage_lines = "\n".join(f"  - {stage}" for stage in stages)
+
+    core = textwrap.dedent(
+        f"""\
+        stages:
+        {stage_lines}
+
+        default:
+          image: python:{options.python_version}-slim
+
+        validate:
+          stage: validate
+          before_script:
+        {_base_before_script(options)}
+          script:
+        {validate_script}
+
+        generate:
+          stage: generate
+          before_script:
+        {_base_before_script(options)}
+          script:
+            - opentide generate
+          needs:
+            - validate
+        """
+    )
+
+    parts = [header_comment(options), core]
+    parts.extend(query_jobs)
+    parts.extend(deploy_jobs)
+    if promote_job:
+        parts.append(promote_job)
+    parts.append(document_job)
+    return "\n".join(parts)