faas-gitops 0.2.1__py3-none-any.whl

faas_gitops/protocols/git_gateway.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+
+
+@dataclass(frozen=True)
+class PushResult:
+    pushed: bool
+    url: str | None = None
+
+
+@runtime_checkable
+class GitWriter(Protocol):
+
+    async def clone_repo(self, repo_slug: str) -> Path:
+        ...
+
+    async def prepare_branch(self, repo_path: Path, branch: str, force: bool = False) -> None:
+        ...
+
+    async def commit_and_push(
+        self,
+        repo_path: Path,
+        prefix: str,
+        msg: str,
+        branch: str,
+        *,
+        force: bool = False,
+        create_pr: bool = False,
+    ) -> PushResult:
+        ...
+
+    async def current_branch(self, repo_path: Path) -> str:
+        """Return the name of the current branch."""
+        ...
+
+    async def checkout(self, repo_path: Path, ref: str) -> None:
+        """Switch to the given branch or ref."""
+        ...

faas_gitops/usecases/apply_function_changes.py

@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from loguru import logger
+
+from faas_gitops.config import Settings
+from faas_gitops.models import ApplyResult
+from faas_gitops.protocols.faas_function import FaaSFunctionProvider
+from faas_gitops.usecases.detect_function_drift import DetectFunctionDrift
+from faas_gitops.usecases.sync_functions import read_function_from_dir
+
+
+class ApplyFunctionChanges:
+
+    def __init__(self, function_provider: FaaSFunctionProvider, settings: Settings) -> None:
+        self._provider = function_provider
+        self._settings = settings
+
+    async def run(self, repo_path: Path, base: str = "main", dry_run: bool = False, sync_branch: str = "sync/faas-functions", repo_slug: str = "") -> ApplyResult:
+        result = ApplyResult()
+        drift = await DetectFunctionDrift(self._settings).run(repo_path, base, sync_branch)
+        if not drift.drifted:
+            return result
+        proc = await asyncio.create_subprocess_exec("git", "checkout", base, cwd=repo_path, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL)
+        await proc.communicate()
+        proc = await asyncio.create_subprocess_exec("git", "pull", cwd=repo_path, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL)
+        await proc.communicate()
+        proc = await asyncio.create_subprocess_exec(
+            "git", "rev-parse", "--short", f"origin/{base}",
+            cwd=repo_path,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        stdout, _ = await proc.communicate()
+        short_hash = stdout.decode().strip()
+        comment = f"{repo_slug.rsplit('/', 1)[-1]}@{short_hash}" if short_hash else ""
+        for fid in drift.missing_in_git:
+            logger.warning(f"  ! {fid}: not found on {base}, skipping")
+        for fid in drift.drifted:
+            func_dir = repo_path / "functions" / fid
+            if not func_dir.exists():
+                logger.warning(f"  ! {fid}: not found on {base}, skipping")
+                result.skipped.append(fid)
+                continue
+            if dry_run:
+                result.skipped.append(fid)
+                continue
+            parts = await read_function_from_dir(func_dir)
+            if parts.definition is not None:
+                def_payload = parts.to_faas_definition(comment=comment)
+                if def_payload is not None:
+                    await self._provider.push_definition(fid, def_payload)
+            await self._provider.update_function_meta(fid, parts.to_faas_meta())
+            result.applied.append(fid)
+        return result

faas_gitops/usecases/apply_template_changes.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+from loguru import logger
+
+from faas_gitops.models import ApplyResult
+from faas_gitops.protocols.faas_template import FaaSTemplateProvider
+from faas_gitops.usecases.detect_template_drift import DetectTemplateDrift
+from faas_gitops.usecases.sync_templates import read_template_from_dir
+
+
+class ApplyTemplateChanges:
+
+    def __init__(self, template_provider: FaaSTemplateProvider) -> None:
+        self._provider = template_provider
+
+    async def run(self, repo_path: Path, base: str = "main", dry_run: bool = False, sync_branch: str = "sync/faas-templates") -> ApplyResult:
+        result = ApplyResult()
+        drift = await DetectTemplateDrift().run(repo_path, base, sync_branch)
+        if not drift.drifted:
+            return result
+        proc = await asyncio.create_subprocess_exec("git", "checkout", base, cwd=repo_path, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL)
+        await proc.communicate()
+        proc = await asyncio.create_subprocess_exec("git", "pull", cwd=repo_path, stdout=asyncio.subprocess.DEVNULL, stderr=asyncio.subprocess.DEVNULL)
+        await proc.communicate()
+        for item_id in drift.missing_in_git:
+            logger.warning(f"  ! {item_id}: not found on {base}, skipping")
+        for item_id in drift.drifted:
+            parts = item_id.split("/")
+            if len(parts) != 2:
+                continue
+            org_id, tpl_name = parts
+            tpl_dir = repo_path / "templates" / org_id / tpl_name
+            if not tpl_dir.exists():
+                logger.warning(f"  ! {item_id}: not found on {base}, skipping")
+                result.skipped.append(item_id)
+                continue
+            git_yaml = (await read_template_from_dir(tpl_dir)).to_faas_yaml()
+            faas_yaml = await self._provider.get_template_content(org_id, tpl_name)
+            if git_yaml == faas_yaml:
+                result.unchanged.append(item_id)
+            elif dry_run:
+                result.skipped.append(item_id)
+            else:
+                await self._provider.update_template(org_id, tpl_name, git_yaml)
+                result.applied.append(item_id)
+        return result

faas_gitops/usecases/detect_drift.py

@@ -0,0 +1,76 @@
+"""Shared git-diff based drift detection logic."""
+
+from __future__ import annotations
+from loguru import logger
+import asyncio
+import re
+from pathlib import Path
+
+from faas_gitops.models import DriftResult
+
+_DIFF_HEADER = re.compile(r"^diff --git a/.+ b/(.+)$")
+_NEW_FILE = re.compile(r"^new file mode")
+_DELETED_FILE = re.compile(r"^deleted file mode")
+
+
+async def run_git_diff(repo_path: Path, base: str, head: str, prefix: str) -> str:
+    cmd = ["git", "diff", f"origin/{head}..origin/{base}", "--", prefix]
+    logger.info("执行指令" + " ".join(cmd))
+    logger.info(f'TODo 实现打印在线预览')
+    proc = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=repo_path,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, _ = await proc.communicate()
+    return stdout.decode()
+
+
+def parse_git_diff(text: str, prefix: str, depth: int, *, exclude_suffixes: tuple[str, ...] = ()) -> DriftResult:
+    result = DriftResult(diff_text=text)
+    if not text:
+        return result
+
+    seen: dict[str, str] = {}
+    current_path: str | None = None
+    current_status: str | None = None
+    for line in text.splitlines():
+        m = _DIFF_HEADER.match(line)
+        if m:
+            if current_path and current_status:
+                seen[current_path] = current_status
+            current_path = m.group(1)
+            current_status = "modified"
+            continue
+        if current_path:
+            if _NEW_FILE.match(line):
+                current_status = "missing_in_faas"
+            elif _DELETED_FILE.match(line):
+                current_status = "missing_in_git"
+    if current_path and current_status:
+        seen[current_path] = current_status
+
+    items: dict[str, str] = {}
+    for path, status in seen.items():
+        if not path.startswith(prefix + "/"):
+            continue
+        if exclude_suffixes and any(path.endswith(s) for s in exclude_suffixes):
+            continue
+        rel = path[len(prefix) + 1:]
+        parts = rel.split("/")
+        if len(parts) <= depth:
+            continue
+        item_id = "/".join(parts[:depth])
+        if item_id in items:
+            continue
+        items[item_id] = status
+
+    for item_id, status in items.items():
+        if status == "missing_in_faas":
+            result.missing_in_faas.append(item_id)
+        elif status == "missing_in_git":
+            result.missing_in_git.append(item_id)
+        else:
+            result.drifted.append(item_id)
+    return result

faas_gitops/usecases/detect_function_drift.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import aiofiles
+import yaml
+
+from faas_gitops.config import Settings
+from faas_gitops.filtering import match_scope
+from faas_gitops.layout import FUNCTION_DIR, FUNCTION_META
+from faas_gitops.models import DriftResult
+from faas_gitops.usecases.detect_drift import parse_git_diff, run_git_diff
+
+
+class DetectFunctionDrift:
+
+    def __init__(self, settings: Settings) -> None:
+        self._settings = settings
+
+    async def run(self, repo_path: Path, base: str = "main", sync_branch: str = "sync/faas-functions") -> DriftResult:
+        text = await run_git_diff(repo_path, base, sync_branch, FUNCTION_DIR)
+        result = parse_git_diff(text, FUNCTION_DIR, depth=1, exclude_suffixes=())
+        if not any((result.drifted, result.missing_in_git, result.missing_in_faas)):
+            return result
+        await self._apply_scope(result, repo_path)
+        return result
+
+    async def _apply_scope(self, result: DriftResult, repo_path: Path) -> None:
+        scoped = self._settings.scoped_functions
+        tags = self._settings.scoped_function_tags
+        if scoped is None and tags is None:
+            return
+        result.drifted = [fid for fid in result.drifted if await self._in_scope(fid, repo_path)]
+        result.missing_in_git = [fid for fid in result.missing_in_git if await self._in_scope(fid, repo_path)]
+        result.missing_in_faas = [fid for fid in result.missing_in_faas if await self._in_scope(fid, repo_path)]
+
+    async def _in_scope(self, fid: str, repo_path: Path) -> bool:
+        meta_path = repo_path / FUNCTION_DIR / fid / FUNCTION_META
+        if not meta_path.exists():
+            return True
+        async with aiofiles.open(meta_path) as f:
+            meta = yaml.safe_load(await f.read()) or {}
+        func_tags = meta.get("tags") or []
+        return match_scope(fid, func_tags, self._settings.scoped_functions, self._settings.scoped_function_tags)

faas_gitops/usecases/detect_template_drift.py

@@ -0,0 +1,14 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from faas_gitops.layout import TEMPLATE_DIR
+from faas_gitops.models import DriftResult
+from faas_gitops.usecases.detect_drift import parse_git_diff, run_git_diff
+
+
+class DetectTemplateDrift:
+
+    async def run(self, repo_path: Path, base: str = "main", sync_branch: str = "sync/faas-templates") -> DriftResult:
+        text = await run_git_diff(repo_path, base, sync_branch, TEMPLATE_DIR)
+        return parse_git_diff(text, TEMPLATE_DIR, depth=2)

faas_gitops/usecases/render_definitions.py

@@ -0,0 +1,96 @@
+"""Render rendered.yaml for all functions in a local repo."""
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+
+import aiofiles
+import yaml
+from loguru import logger
+from tqdm.asyncio import tqdm_asyncio
+
+from faas_gitops.infra.yaml_utils import dump_faas_yaml, load_yaml
+from faas_gitops.layout import FUNCTION_BASE, FUNCTION_DEFINITION, FUNCTION_DIR, FUNCTION_RENDERED, TEMPLATE_DIR
+from faas_gitops.protocols.faas_template import FaaSTemplateProvider
+from faas_gitops.protocols.git_gateway import GitWriter
+from faas_gitops.usecases.sync_functions import read_function_from_dir
+from faas_gitops.usecases.sync_templates import _quiet_logger, read_template_from_dir
+
+_RENDERED_HEADER = "# rendered by faas-gitops, do not modify\n"
+
+
+def _function_dirs(func_dir: Path) -> list[Path]:
+    if not func_dir.is_dir():
+        return []
+    return sorted(
+        d for d in func_dir.iterdir()
+        if d.is_dir() and (d / FUNCTION_DEFINITION).exists() and (d / FUNCTION_BASE).exists()
+    )
+
+
+def _resolve_template_dir(repo_path: Path, base: dict) -> Path | None:
+    tpl_name: str = base.get("templateName", "")
+    if "/" not in tpl_name:
+        return None
+    org_id, tpl_id = tpl_name.split("/", 1)
+    return repo_path / TEMPLATE_DIR / org_id / tpl_id
+
+
+async def _render_one(
+    func_dir: Path, repo_path: Path, provider: FaaSTemplateProvider, sem: asyncio.Semaphore,
+) -> int:
+    async with sem:
+        try:
+            base = load_yaml((func_dir / FUNCTION_BASE).read_text())
+            tpl_dir = _resolve_template_dir(repo_path, base or {})
+            if tpl_dir is None:
+                return 0
+            if not tpl_dir.exists():
+                logger.warning(f"template not found: {tpl_dir}, skipping {func_dir.name}")
+                return 0
+
+            tpl_data = yaml.safe_load((await read_template_from_dir(tpl_dir)).to_faas_yaml())
+            parts = await read_function_from_dir(func_dir)
+            rendered = await parts.render_draft(provider, tpl_data)
+
+            content = _RENDERED_HEADER + dump_faas_yaml(rendered)
+            out = func_dir / FUNCTION_RENDERED
+            if out.exists() and out.read_text() == content:
+                return 0
+            async with aiofiles.open(out, "w") as f:
+                await f.write(content)
+            return 1
+
+        except Exception as e:
+            logger.warning(f"render failed for {func_dir.name}: {e}")
+            return 0
+
+
+async def render_definitions(
+    provider: FaaSTemplateProvider,
+    repo_path: Path,
+    *,
+    branch: str,
+    git: GitWriter,
+    max_workers: int = 16,
+) -> int:
+    assert branch is not None 
+    await git.prepare_branch(repo_path=repo_path, branch=branch, force=False)
+    logger.info(f"render-definitions: branch={branch}")
+
+    func_dir = repo_path / FUNCTION_DIR
+    dirs = _function_dirs(func_dir)
+    sem = asyncio.Semaphore(max_workers)
+
+    with _quiet_logger():
+        results = await tqdm_asyncio.gather(
+            *[_render_one(d, repo_path, provider, sem) for d in dirs],
+            desc=f"render-definitions [{branch}]",
+            unit="func",
+        )
+    written = sum(results)
+    await git.commit_and_push(
+        repo_path, FUNCTION_DIR, f"render-definitions[{written}]",
+        branch=branch, force=False, create_pr=False,
+    )
+    return written

faas_gitops/usecases/sync_functions.py

@@ -0,0 +1,102 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+import yaml
+from loguru import logger
+
+import aiofiles
+from tqdm.asyncio import tqdm_asyncio
+
+from faas_gitops.config import Settings
+from faas_gitops.usecases.sync_templates import _quiet_logger
+from faas_gitops.filtering import match_scope
+from faas_gitops.infra.yaml_utils import dump_faas_yaml, load_yaml
+from faas_gitops.layout import FUNCTION_BASE, FUNCTION_DEFINITION, FUNCTION_DIR, FUNCTION_META, FUNCTION_RENDERED, TEMPLATE_DIR
+from faas_gitops.models import FunctionParts
+from faas_gitops.protocols.faas_function import FaaSFunctionProvider
+from faas_gitops.protocols.faas_template import FaaSTemplateProvider
+from faas_gitops.protocols.git_gateway import GitWriter
+from faas_gitops.usecases.sync_templates import read_template_from_dir
+
+
+async def _write_function(parts: FunctionParts, dest: Path) -> None:
+    dest.mkdir(parents=True, exist_ok=True)
+    async with aiofiles.open(dest / FUNCTION_META, "w") as f:
+        await f.write(dump_faas_yaml(parts.meta))
+    if parts.base is not None:
+        async with aiofiles.open(dest / FUNCTION_BASE, "w") as f:
+            await f.write(dump_faas_yaml(parts.base))
+    if parts.definition is not None:
+        async with aiofiles.open(dest / FUNCTION_DEFINITION, "w") as f:
+            await f.write(dump_faas_yaml(parts.definition))
+
+async def read_function_from_dir(func_dir: Path) -> FunctionParts:
+    async with aiofiles.open(func_dir / FUNCTION_META) as f:
+        meta = load_yaml(await f.read()) or {}
+    base = None
+    base_path = func_dir / FUNCTION_BASE
+    if base_path.exists():
+        async with aiofiles.open(base_path) as f:
+            base = load_yaml(await f.read())
+    definition = None
+    def_path = func_dir / FUNCTION_DEFINITION
+    if def_path.exists():
+        async with aiofiles.open(def_path) as f:
+            definition = load_yaml(await f.read())
+    return FunctionParts(meta=meta, base=base, definition=definition)
+
+
+class SyncFunctions:
+    """FaaS→Git function sync orchestration.
+
+    Fetches functions from FaaS, writes meta + runtime + definition YAML files,
+    force-pushes to a sync branch.
+
+    File layout per function:
+        functions/{func_id}/meta.yaml        — function metadata (name, tags)
+        functions/{func_id}/base.yaml        — runtime base (templateName)
+        functions/{func_id}/definition.yaml  — spec.data
+    """
+
+    def __init__(
+        self,
+        provider: FaaSFunctionProvider,
+        git_writer: GitWriter,
+        settings: Settings,
+        tpl_provider: FaaSTemplateProvider | None = None,
+        branch: str = "sync/faas-functions",
+    ) -> None:
+        self._provider = provider
+        self._git_writer = git_writer
+        self._settings = settings
+        self._tpl_provider = tpl_provider
+        self._branch = branch
+
+    async def run(self, repo_path: Path):
+        functions = [
+            f for f in await self._provider.list_functions()
+            if match_scope(f["id"], f.get("tags", []), self._settings.scoped_functions, self._settings.scoped_function_tags)
+        ]
+        await self._git_writer.prepare_branch(repo_path, self._branch, force=True)
+        out_dir = repo_path / FUNCTION_DIR
+        sem = asyncio.Semaphore(self._settings.max_workers)
+
+        async def _sync_one(func: dict) -> None:
+            async with sem:
+                fid = func["id"]
+                raw = await self._provider.get_latest_definition(fid)
+                meta = {"functionName": func.get("name", ""), "tags": func.get("tags", [])}
+                base = None
+                definition = None
+                if raw is not None:
+                    base = {"templateName": raw.get("metadata", {}).get("templateName", "")}
+                    definition = raw.get("spec", {}).get("data")
+                await _write_function(FunctionParts(meta=meta, base=base, definition=definition), out_dir / fid)
+
+        with _quiet_logger():
+            await tqdm_asyncio.gather(*[_sync_one(f) for f in functions], desc="sync-functions")
+        return await self._git_writer.commit_and_push(
+            repo_path, FUNCTION_DIR, f"sync: {len(functions)} functions", self._branch,
+            force=True, create_pr=True,
+        )

faas_gitops/usecases/sync_templates.py

@@ -0,0 +1,106 @@
+from __future__ import annotations
+
+import asyncio
+from contextlib import contextmanager
+from pathlib import Path
+
+import aiofiles
+import yaml
+from loguru import logger
+from tqdm.asyncio import tqdm_asyncio
+
+from faas_gitops.config import Settings
+from faas_gitops.filtering import match_scope
+from faas_gitops.protocols.faas_template import FaaSTemplateProvider
+from faas_gitops.infra.yaml_utils import dump_faas_yaml, load_yaml
+from faas_gitops.layout import TEMPLATE_DIR, TEMPLATE_PRIMARY
+from faas_gitops.models import TemplateParts, _INFO_FIELDS
+from faas_gitops.protocols.git_gateway import GitWriter
+
+
+@contextmanager
+def _quiet_logger():
+    logger.disable("bizy_deploy")
+    try:
+        yield
+    finally:
+        logger.enable("bizy_deploy")
+
+
+def _split_template(content: str) -> TemplateParts:
+    data = yaml.safe_load(content)
+    meta, spec = data.get("metadata", {}), data.get("spec", {})
+    org_id, tpl_id = meta["name"].split("/")
+    info = {"subject": org_id, "id": tpl_id} | {
+        dst: meta[src] for src, dst in _INFO_FIELDS.items() if meta.get(src)
+    }
+    if v := meta.get("parentTemplateName"):
+        info["parent"] = v
+    return TemplateParts(info=info, jinja=spec.get("jinjaTemplate"), schema=spec.get("schema"))
+
+
+async def read_template_from_dir(template_dir: Path) -> TemplateParts:
+    async with aiofiles.open(template_dir / TEMPLATE_PRIMARY) as f:
+        info = load_yaml(await f.read()) or {}
+    jinja = None
+    jinja_path = template_dir / "template.jinja"
+    if jinja_path.exists():
+        async with aiofiles.open(jinja_path) as f:
+            jinja = await f.read()
+    schema = None
+    schema_path = template_dir / "schema.yaml"
+    if schema_path.exists():
+        async with aiofiles.open(schema_path) as f:
+            schema = load_yaml(await f.read())
+    return TemplateParts(info=info, jinja=jinja, schema=schema)
+
+
+async def _write_files(parts: TemplateParts, dest: Path) -> None:
+    dest.mkdir(parents=True, exist_ok=True)
+    async with aiofiles.open(dest / TEMPLATE_PRIMARY, "w") as f:
+        await f.write(dump_faas_yaml(parts.info))
+    if parts.jinja:
+        async with aiofiles.open(dest / "template.jinja", "w") as f:
+            await f.write(parts.jinja)
+    if parts.schema:
+        async with aiofiles.open(dest / "schema.yaml", "w") as f:
+            await f.write(dump_faas_yaml(parts.schema))
+
+
+class SyncTemplates:
+
+    def __init__(
+        self,
+        provider: FaaSTemplateProvider,
+        git_writer: GitWriter,
+        settings: Settings,
+        branch: str = "sync/faas-templates",
+    ) -> None:
+        self._provider = provider
+        self._git = git_writer
+        self._settings = settings
+        self._branch = branch
+
+    async def run(self, repo_path: Path):
+        templates = [
+            t for t in await self._provider.list_templates()
+            if match_scope(t["name"], t.get("tags", []), self._settings.scoped_templates, self._settings.scoped_template_tags)
+        ]
+        await self._git.prepare_branch(repo_path, self._branch, force=True)
+        out_dir = repo_path / TEMPLATE_DIR
+        sem = asyncio.Semaphore(self._settings.max_workers)
+
+        async def _sync_one(t: dict) -> None:
+            async with sem:
+                org_id, tpl_id = t["name"].split("/")
+                content = await self._provider.get_template_content(org_id, tpl_id)
+                parts = _split_template(content)
+                dest = out_dir / parts.info["subject"] / parts.info["id"]
+                await _write_files(parts, dest)
+
+        with _quiet_logger():
+            await tqdm_asyncio.gather(*[_sync_one(t) for t in templates], desc="sync-templates")
+        return await self._git.commit_and_push(
+            repo_path, TEMPLATE_DIR, f"sync: {len(templates)} templates", self._branch,
+            force=True, create_pr=True,
+        )

faas_gitops-0.2.1.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: faas-gitops
+Version: 0.2.1
+Summary: Declarative GitOps for FaaS
+Requires-Python: >=3.12
+Requires-Dist: aiofiles>=23.0
+Requires-Dist: bizy-deploy>=0.5.4
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tqdm>=4.66.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"

faas_gitops-0.2.1.dist-info/RECORD

@@ -0,0 +1,33 @@
+faas_gitops/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faas_gitops/config.py,sha256=1cIzgALAfBQG7o9PTgLcTXICnnr6_rS1utCnOiAbQRs,948
+faas_gitops/filtering.py,sha256=_fPG_vDVbA_mp8q-6Jx6Ovd4su350NstGrmbpwlXf4c,371
+faas_gitops/layout.py,sha256=RRggSifRkiEVW8LXZMdQoVUxhu7N3LFVmGda4JMgxOY,383
+faas_gitops/models.py,sha256=wp09GBqtIX3ineXgKzdXXBb5SlD7f7VGfWUGruFPZD4,3213
+faas_gitops/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faas_gitops/adapters/bizy_function_provider.py,sha256=C_cjPYYD-7GwnwLpo2dTwgPqLiOmph60GnKu3iH3TrA,1175
+faas_gitops/adapters/bizy_template_provider.py,sha256=Si18FYUH08F0UQmgwFdrRQ0U6Bi0z9Mq1vx79taH6KI,1360
+faas_gitops/adapters/git_cli_gateway.py,sha256=oIAsll39ox_EzoT_Zb8oVO37EFu4fNQrwA6KGeoOKlI,4255
+faas_gitops/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faas_gitops/cli/app.py,sha256=qZr7p-h1BOrFqR3mrdLMSeeA3gh8NAf-6m63sWoKmDs,4619
+faas_gitops/cli/parser.py,sha256=jP7BB-ZdPuuPKgf8RGA7XZNwVI4l_ZdyEbhuGQNWp4c,1134
+faas_gitops/cli/presenters.py,sha256=ky8l7fSHcR37uf74IiXTWt06fgtnpnfJ-zbUlRKWVLY,1156
+faas_gitops/infra/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faas_gitops/infra/yaml_utils.py,sha256=DzvjabEP2sKEUK4wv7XUzt0BowQroa1p-ZDeGsv5Iq8,442
+faas_gitops/protocols/__init__.py,sha256=Jhmfp9QQ2K_JdKm-98hASR9vqo2SBe8ea42pj1wIhcU,219
+faas_gitops/protocols/faas_function.py,sha256=Y8dMnML0UHDrOoX7Bv6_mSBc-GMHrxoTImjynYCYG9M,1468
+faas_gitops/protocols/faas_template.py,sha256=OaMLRIgtYuBNMaFq0Sbas-MMbtt3p842YVHfzsSvBm8,2148
+faas_gitops/protocols/git_gateway.py,sha256=ZJ2IbJd4KDWNNR8ayOKd8P5yRymW12CwULtj2YdnL7c,945
+faas_gitops/usecases/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+faas_gitops/usecases/apply_function_changes.py,sha256=tj7nRrELwMfo9HxUhtAUGxnnS-PVqUp-gv9M_SO8rqA,2653
+faas_gitops/usecases/apply_template_changes.py,sha256=D-TlvM0TkVs9Ua74vMOYPlNsyGBDNlJ1pnKIM3XQIDU,2234
+faas_gitops/usecases/detect_drift.py,sha256=aeAtg2ovIa1KOI9egB3TOpf8tgXeSwF3y7R-KkXX7Kk,2513
+faas_gitops/usecases/detect_function_drift.py,sha256=EhDxe9jMuCP1jk5_yYveECzK6sWRs9f3jVtFFaFqt7A,1969
+faas_gitops/usecases/detect_template_drift.py,sha256=zT53j9MbU50RVFVDePbdP6UN8mI9YK1C2ewmqr_RLU8,510
+faas_gitops/usecases/render_definitions.py,sha256=gELdUQY9KKAILhNEPNHGM303sCqT3FUOc7jc5X6HOP8,3333
+faas_gitops/usecases/sync_functions.py,sha256=S-0Uqt2NlE0z1JyTTWMZkLvIr2RiNsFCo0BzvXNC_Mg,4268
+faas_gitops/usecases/sync_templates.py,sha256=iF5rcPKr2sOxAk7ujL1HcIBmo_Rr-idLQoeOkhtRe7s,3857
+faas_gitops-0.2.1.dist-info/METADATA,sha256=nTiS8m6oa2ajNQ95L8rMxIXsjLuyXnHo66ve_RZSOT4,353
+faas_gitops-0.2.1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+faas_gitops-0.2.1.dist-info/entry_points.txt,sha256=caS7fkXkKLHfS5QE4-_0C13hYKDusf22xpgZ9d1GAPM,57
+faas_gitops-0.2.1.dist-info/top_level.txt,sha256=vFe6sgocS2gAPxbwBQtVR7Jm2ZaMMR-XCIDgAdVFVoU,12
+faas_gitops-0.2.1.dist-info/RECORD,,

faas_gitops-0.2.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

faas_gitops-0.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+faas-gitops = faas_gitops.cli.app:main

faas_gitops-0.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+faas_gitops