fluidattacks_success_indicators 2.0.0__tar.gz

fluidattacks_success_indicators-2.0.0/.envrc

@@ -0,0 +1,2 @@
+ln -f ../../common/mypy.ini ./mypy.ini
+use_flake ".#python311.devShell"

fluidattacks_success_indicators-2.0.0/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: fluidattacks_success_indicators
+Version: 2.0.0
+Summary: job last success reporter
+Author-email: Product Team <development@fluidattacks.com>
+Requires-Python: >=3.11
+Classifier: License :: OSI Approved :: MIT License
+Requires-Dist: click >=8.3.0, <9.0.0
+Requires-Dist: fa-purity >=2.5.2, <3.0.0
+Requires-Dist: fluidattacks-connection-manager >=1.0.0, <2.0.0
+Requires-Dist: fluidattacks-etl-utils >=1.0.0, <2.0.0
+Requires-Dist: fluidattacks-utils-logger >=1.0.0, <2.0.0

fluidattacks_success_indicators-2.0.0/build/default.nix

@@ -0,0 +1,17 @@
+{ nixpkgs, builders, scripts, src, }:
+let
+  build_bin = bundle:
+    nixpkgs.writeShellApplication {
+      name = "success-indicators";
+      runtimeInputs = [ bundle.env.runtime ];
+      text = ''
+        success-indicators "''${@}"
+      '';
+    };
+in {
+  inherit src;
+  root_path = "observes/job/success-indicators";
+  module_name = "fluidattacks_success_indicators";
+  pypi_token_var = "SUCCESS_INDICATORS_TOKEN";
+  override = bundle: bundle // { bin = build_bin bundle; };
+}

fluidattacks_success_indicators-2.0.0/build/filter.nix

@@ -0,0 +1,12 @@
+path_filter: src:
+path_filter {
+  root = src;
+  include = [
+    "fluidattacks_success_indicators"
+    "tests"
+    "pyproject.toml"
+    "ruff.toml"
+    "mypy.ini"
+    "uv.lock"
+  ];
+}

fluidattacks_success_indicators-2.0.0/flake.lock

@@ -0,0 +1,351 @@
+{
+  "nodes": {
+    "flake-parts": {
+      "inputs": {
+        "nixpkgs-lib": "nixpkgs-lib"
+      },
+      "locked": {
+        "lastModified": 1754487366,
+        "narHash": "sha256-pHYj8gUBapuUzKV/kN/tR3Zvqc7o6gdFB9XKXIp1SQ8=",
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "rev": "af66ad14b28a127c5c0f3bbb298218fc63528a18",
+        "type": "github"
+      },
+      "original": {
+        "owner": "hercules-ci",
+        "repo": "flake-parts",
+        "type": "github"
+      }
+    },
+    "nix_filter": {
+      "locked": {
+        "lastModified": 1731533336,
+        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nix_filter_2": {
+      "locked": {
+        "lastModified": 1731533336,
+        "narHash": "sha256-oRam5PS1vcrr5UPgALW0eo1m/5/pls27Z/pabHNy2Ms=",
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "rev": "f7653272fd234696ae94229839a99b73c9ab7de0",
+        "type": "github"
+      },
+      "original": {
+        "owner": "numtide",
+        "repo": "nix-filter",
+        "type": "github"
+      }
+    },
+    "nixpkgs": {
+      "locked": {
+        "lastModified": 1736441877,
+        "narHash": "sha256-m3+PhBFkDwqo9lBplG4AyMW8P4/KcioJRS1UG8N7okM=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "ce3899414dab3297cf025bfa356dc2da426feefd",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs-lib": {
+      "locked": {
+        "lastModified": 1753579242,
+        "narHash": "sha256-zvaMGVn14/Zz8hnp4VWT9xVnhc8vuL3TStRqwk22biA=",
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "rev": "0f36c44e01a6129be94e3ade315a5883f0228a6e",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "nixpkgs.lib",
+        "type": "github"
+      }
+    },
+    "nixpkgs_2": {
+      "locked": {
+        "lastModified": 1758690382,
+        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_3": {
+      "locked": {
+        "lastModified": 1758690382,
+        "narHash": "sha256-NY3kSorgqE5LMm1LqNwGne3ZLMF2/ILgLpFr1fS4X3o=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "e643668fd71b949c53f8626614b21ff71a07379d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_4": {
+      "locked": {
+        "lastModified": 1761373498,
+        "narHash": "sha256-Q/uhWNvd7V7k1H1ZPMy/vkx3F8C13ZcdrKjO7Jv7v0c=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "6a08e6bb4e46ff7fcbb53d409b253f6bad8a28ce",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "ref": "nixos-unstable",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "nixpkgs_flake": {
+      "locked": {
+        "lastModified": 1756313514,
+        "narHash": "sha256-3Xbak0pXR8ziNv1ghHyJ5a5Ti2kt/LWq6hKZVJTvjBs=",
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "rev": "181464235b2daff8725773fef43ffc9d6b02e1c2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nixos",
+        "repo": "nixpkgs",
+        "type": "github"
+      }
+    },
+    "observes_flake_builder": {
+      "inputs": {
+        "nix_filter": "nix_filter",
+        "nixpkgs_flake": "nixpkgs_flake",
+        "pynix_flake": "pynix_flake",
+        "pyproject-build-systems": "pyproject-build-systems",
+        "pyproject-nix": "pyproject-nix_2",
+        "shell-helpers": "shell-helpers",
+        "uv2nix": "uv2nix_2"
+      },
+      "locked": {
+        "dir": "observes/common/std_flake_2",
+        "lastModified": 1762278223,
+        "narHash": "sha256-MW3HitewaVFCSOpjv7+eu1xqA0rxJ6zeiQSWFl0oLJI=",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "41ea58333c8fbb68499a470444b6619023f74a2b",
+        "type": "github"
+      },
+      "original": {
+        "dir": "observes/common/std_flake_2",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "41ea58333c8fbb68499a470444b6619023f74a2b",
+        "type": "github"
+      }
+    },
+    "pynix_flake": {
+      "inputs": {
+        "nix_filter": "nix_filter_2",
+        "nixpkgs": "nixpkgs"
+      },
+      "locked": {
+        "lastModified": 1758642502,
+        "narHash": "sha256-PD/bQMz2dqZSkydHyvRh+jS/0qoV8SdcIVs6sassteQ=",
+        "owner": "dmurciaatfluid",
+        "repo": "python_nix_builder",
+        "rev": "809aafe2e1995e72c15378d099bf251b78f04a20",
+        "type": "gitlab"
+      },
+      "original": {
+        "owner": "dmurciaatfluid",
+        "repo": "python_nix_builder",
+        "type": "gitlab"
+      }
+    },
+    "pyproject-build-systems": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_2",
+        "pyproject-nix": "pyproject-nix",
+        "uv2nix": "uv2nix"
+      },
+      "locked": {
+        "lastModified": 1761781027,
+        "narHash": "sha256-YDvxPAm2WnxrznRqWwHLjryBGG5Ey1ATEJXrON+TWt8=",
+        "owner": "pyproject-nix",
+        "repo": "build-system-pkgs",
+        "rev": "795a980d25301e5133eca37adae37283ec3c8e66",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "build-system-pkgs",
+        "type": "github"
+      }
+    },
+    "pyproject-nix": {
+      "inputs": {
+        "nixpkgs": [
+          "observes_flake_builder",
+          "pyproject-build-systems",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1758265079,
+        "narHash": "sha256-amLaLNwKSZPShQHzfgmc/9o76dU8xzN0743dWgvYlr8=",
+        "owner": "nix-community",
+        "repo": "pyproject.nix",
+        "rev": "02e9418fd4af638447dca4b17b1280da95527fc9",
+        "type": "github"
+      },
+      "original": {
+        "owner": "nix-community",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "pyproject-nix_2": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_3"
+      },
+      "locked": {
+        "lastModified": 1760402624,
+        "narHash": "sha256-jF6UKLs2uGc2rtved8Vrt58oTWjTQoAssuYs/0578Z4=",
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "rev": "84c4ea102127c77058ea1ed7be7300261fafc7d2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "pyproject-nix_3": {
+      "inputs": {
+        "nixpkgs": [
+          "observes_flake_builder",
+          "uv2nix",
+          "nixpkgs"
+        ]
+      },
+      "locked": {
+        "lastModified": 1760402624,
+        "narHash": "sha256-jF6UKLs2uGc2rtved8Vrt58oTWjTQoAssuYs/0578Z4=",
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "rev": "84c4ea102127c77058ea1ed7be7300261fafc7d2",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "pyproject.nix",
+        "type": "github"
+      }
+    },
+    "root": {
+      "inputs": {
+        "observes_flake_builder": "observes_flake_builder"
+      }
+    },
+    "shell-helpers": {
+      "inputs": {
+        "flake-parts": "flake-parts",
+        "nixpkgs": [
+          "observes_flake_builder",
+          "nixpkgs_flake"
+        ]
+      },
+      "locked": {
+        "dir": "common/utils/shell-helpers",
+        "lastModified": 1752896460,
+        "narHash": "sha256-AsyTatXMx839cGsF6knwTrDZHk3Eue2QD3eSP7bkmpg=",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "27749d2c3a2b018eb010a322e5e1352f993c9e86",
+        "type": "github"
+      },
+      "original": {
+        "dir": "common/utils/shell-helpers",
+        "owner": "fluidattacks",
+        "repo": "universe",
+        "rev": "27749d2c3a2b018eb010a322e5e1352f993c9e86",
+        "type": "github"
+      }
+    },
+    "uv2nix": {
+      "inputs": {
+        "nixpkgs": [
+          "observes_flake_builder",
+          "pyproject-build-systems",
+          "nixpkgs"
+        ],
+        "pyproject-nix": [
+          "observes_flake_builder",
+          "pyproject-build-systems",
+          "pyproject-nix"
+        ]
+      },
+      "locked": {
+        "lastModified": 1758933732,
+        "narHash": "sha256-HAmm1GBS1myZCFuog0DC2ZLaynvZtiUI2Crmo+cdQI0=",
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "rev": "273ce18f913d8559e0d04f820d724308966d7c4d",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "type": "github"
+      }
+    },
+    "uv2nix_2": {
+      "inputs": {
+        "nixpkgs": "nixpkgs_4",
+        "pyproject-nix": "pyproject-nix_3"
+      },
+      "locked": {
+        "lastModified": 1761872265,
+        "narHash": "sha256-i25GRgp2vUOebY70L3NTAgkd+Pr1hnn5xM3qHxH0ONU=",
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "rev": "74dfb62871be152ad3673b143b0cc56105a4f3c5",
+        "type": "github"
+      },
+      "original": {
+        "owner": "pyproject-nix",
+        "repo": "uv2nix",
+        "type": "github"
+      }
+    }
+  },
+  "root": "root",
+  "version": 7
+}

fluidattacks_success_indicators-2.0.0/flake.nix

@@ -0,0 +1,19 @@
+{
+  description = "Fluidattacks ETLs success indicators";
+
+  inputs = {
+    observes_flake_builder = {
+      url =
+        "github:fluidattacks/universe/41ea58333c8fbb68499a470444b6619023f74a2b?shallow=1&dir=observes/common/std_flake_2";
+    };
+  };
+
+  outputs = { self, ... }@inputs:
+    let
+      build_args = { system, python_version, nixpkgs, builders, scripts }:
+        import ./build {
+          inherit nixpkgs builders scripts;
+          src = import ./build/filter.nix nixpkgs.nix-filter self;
+        };
+    in { packages = inputs.observes_flake_builder.outputs.build build_args; };
+}

fluidattacks_success_indicators-2.0.0/fluidattacks_success_indicators/__init__.py

@@ -0,0 +1,20 @@
+from fa_purity import (
+    Unsafe,
+)
+
+from ._core import CompoundJob, IndicatorsClient, SingleJob
+from ._factory import ClientFactory
+from ._logger import (
+    set_logger,
+)
+
+__version__ = "2.0.0"
+
+Unsafe.compute(set_logger(__name__, __version__))
+
+__all__ = [
+    "ClientFactory",
+    "CompoundJob",
+    "IndicatorsClient",
+    "SingleJob",
+]

fluidattacks_success_indicators-2.0.0/fluidattacks_success_indicators/_cli/__init__.py

@@ -0,0 +1,15 @@
+import click
+
+from . import (
+    _sub_cmds,
+)
+
+
+@click.group()
+def main() -> None:
+    # main entrypoint group
+    pass
+
+
+main.add_command(_sub_cmds.single_job)
+main.add_command(_sub_cmds.compound_job)

fluidattacks_success_indicators-2.0.0/fluidattacks_success_indicators/_cli/_sub_cmds.py

@@ -0,0 +1,115 @@
+import inspect
+
+import click
+from fa_purity import (
+    Cmd,
+    Maybe,
+    ResultE,
+    cast_exception,
+)
+from fa_purity._core.utils import raise_exception
+from fluidattacks_connection_manager import ConnectionConf, Databases, Roles, Warehouses
+from fluidattacks_etl_utils import smash
+from fluidattacks_etl_utils.bug import Bug
+from fluidattacks_etl_utils.typing import (
+    NoReturn,
+    Tuple,
+)
+from snowflake_client import SnowflakeCredentials
+
+from fluidattacks_success_indicators._core import CompoundJob, SingleJob
+from fluidattacks_success_indicators._db_client import (
+    JobName,
+)
+from fluidattacks_success_indicators._factory import ClientFactory
+
+
+def _decode_conf(
+    raw_warehouse: str | None,
+    raw_role: str | None,
+    raw_user: str | None,
+    raw_account: str | None,
+    raw_private_key: str | None,
+) -> ResultE[Tuple[ConnectionConf, SnowflakeCredentials]]:
+    warehouse = (
+        Maybe.from_optional(raw_warehouse)
+        .to_result()
+        .alt(lambda _: ValueError("missing warehouse"))
+        .alt(cast_exception)
+        .bind(Warehouses.from_raw)
+    )
+    role = (
+        Maybe.from_optional(raw_role)
+        .to_result()
+        .alt(lambda _: ValueError("missing role"))
+        .alt(cast_exception)
+        .bind(Roles.from_raw)
+    )
+    conf = smash.smash_result_2(
+        warehouse,
+        role,
+    ).map(
+        lambda t: ConnectionConf(*t, Databases.OBSERVES),
+    )
+    user = (
+        Maybe.from_optional(raw_user)
+        .to_result()
+        .alt(lambda _: ValueError("missing user"))
+        .alt(cast_exception)
+    )
+    key = (
+        Maybe.from_optional(raw_private_key)
+        .to_result()
+        .alt(lambda _: ValueError("missing private key"))
+        .alt(cast_exception)
+    )
+    account = (
+        Maybe.from_optional(raw_account)
+        .to_result()
+        .alt(lambda _: ValueError("missing account"))
+        .alt(cast_exception)
+    )
+    creds = smash.smash_result_3(user, key, account).map(lambda t: SnowflakeCredentials(*t))
+    return smash.smash_result_2(conf, creds)
+
+
+@click.command()
+@click.option("--job", type=str, required=True)
+@click.option("--warehouse", type=str, required=False, envvar="SNOWFLAKE_WAREHOUSE")
+@click.option("--role", type=str, required=False, envvar="SNOWFLAKE_ROLE")
+@click.option("--user", type=str, required=False, envvar="SNOWFLAKE_USER")
+@click.option("--account", type=str, required=False, envvar="SNOWFLAKE_ACCOUNT")
+@click.option("--private-key", type=str, required=False, envvar="SNOWFLAKE_PRIVATE_KEY")
+def single_job(  # noqa: PLR0913
+    job: str,
+    warehouse: str | None,
+    role: str | None,
+    user: str | None,
+    account: str | None,
+    private_key: str | None,
+) -> NoReturn:
+    decoded_job = SingleJob.decode(job).alt(raise_exception).to_union()
+    if private_key is None:
+        cmd: Cmd[None] = ClientFactory.observes_client().update_single_job(decoded_job)
+        cmd.compute()
+    else:
+        conf, creds = Bug.assume_success(
+            "_decode_conf",
+            inspect.currentframe(),
+            (str(warehouse), str(role), str(user), str(account)),
+            _decode_conf(warehouse, role, user, account, private_key),
+        )
+        cmd_2: Cmd[None] = ClientFactory.custom_client(conf, creds).update_single_job(decoded_job)
+        cmd_2.compute()
+
+
+@click.command()
+@click.option("--job", type=str, required=True)
+@click.option("--child", type=str, required=True)
+def compound_job(job: str, child: str) -> None:
+    decoded_job = CompoundJob.decode(job).alt(raise_exception).to_union()
+    cmd: Cmd[None] = ClientFactory.observes_client().update_compound_job(
+        decoded_job,
+        JobName(child),
+    )
+    cmd.compute()

fluidattacks_success_indicators-2.0.0/fluidattacks_success_indicators/_core.py

@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from collections.abc import Callable
+from dataclasses import dataclass
+from enum import Enum
+
+from fa_purity import (
+    Cmd,
+    Result,
+    ResultE,
+)
+
+from ._db_client import (
+    JobName,
+)
+
+ChildJob = JobName
+
+
+class SingleJob(Enum):
+    batch_etl = "batch_etl"
+    bugsnag = "bugsnag"
+    ce_etl = "ce_etl"
+    checkly = "checkly"
+    cloudwatch_etl = "cloudwatch_etl"
+    compute_bills = "compute_bills"
+    delighted = "delighted"
+    determine_dynamo_schema = "determine_dynamo_schema"
+    flow_etl = "flow_etl"
+    gitlab_datahub = "gitlab_datahub"
+    gitlab_universe = "gitlab_universe"
+    gitlab_dora = "gitlab_dora"
+    sorts_lead_scoring = "sorts_lead_scoring"
+    timedoctor_backup = "timedoctor_backup"
+    timedoctor_etl = "timedoctor_etl"
+    zoho_crm_etl = "zoho_crm_etl"
+    zoho_crm_prepare = "zoho_crm_prepare"
+
+    @staticmethod
+    def decode(raw: str) -> ResultE[SingleJob]:
+        try:
+            return Result.success(SingleJob(raw))
+        except ValueError as err:
+            return Result.failure(err)
+
+
+class CompoundJob(Enum):
+    code_upload = "code_upload"
+    code_upload_snowflake = "code_upload_snowflake"
+
+    @staticmethod
+    def decode(raw: str) -> ResultE[CompoundJob]:
+        try:
+            return Result.success(CompoundJob(raw))
+        except ValueError as err:
+            return Result.failure(err)
+
+
+@dataclass(frozen=True)
+class IndicatorsClient:
+    update_single_job: Callable[[SingleJob], Cmd[None]]
+    update_compound_job: Callable[[CompoundJob, ChildJob], Cmd[None]]

fluidattacks_success_indicators-2.0.0/fluidattacks_success_indicators/_db_client/__init__.py

@@ -0,0 +1,17 @@
+from ._client_1 import (
+    new_compound_job_client,
+    new_job_client,
+)
+from ._core import (
+    Client,
+    JobLastSuccess,
+    JobName,
+)
+
+__all__ = [
+    "Client",
+    "JobLastSuccess",
+    "JobName",
+    "new_compound_job_client",
+    "new_job_client",
+]