From e703070c57a29a27f0cc4b449cafeacaa6977641 Mon Sep 17 00:00:00 2001 From: itvi-1234 Date: Mon, 16 Nov 2026 15:54:34 +0530 Subject: [PATCH] Remove the legacy paths and the validator that rc replaces The profiler makes a profile from installed generated bindings (profile generate), and verifies them (profile verify-bindings). Nothing imports this package: rc does not use the Python profiler, and the only console script is runtimeconditions-python-profiler. The older commands belonged to a separate mapping workflow and carried fixed shapes of particular extensions. - Remove the discover, generate, mappings, validate-extension and validate-extensions commands, and everything only they used: the SDK mapping code (sdk/), the handwritten manifest parser and mapping model (manifest/), the source-inspecting profile extractor, the typed profile validator that rc profile validate replaces, project discovery, the extension artifact and manifest validators, and the public API module (main.py) that re-exported them. - Remove the helpers of the live code that nothing called: the unused constants, util.py and models.py (ignored_path moves next to workload_source_files), expand_identifier, reference_object and resolve_reference. - Remove the tests of the removed code, the authoring fixtures under testdata, the testdata line of MANIFEST.in and the README sentence about the legacy commands. A vulture run on the package reports only the YAML loader's construct_mapping override. The 113 remaining tests pass. Both a wheel and an sdist build, and scripts/check_distributions.py accepts them; the wheel holds only the modules the two commands use and the two schema files. Compared with the code before, over 36 cases (a workload with smtp and cache declarations that is valid, one with an unknown enum value, a value computed at run time, a missing required field, no binding import, and an empty project, each with profile generate, --out, a missing name and verify-bindings, with and without --json), the output, error text and exit code of every case are identical, except the usage text of --help, no arguments and an unknown command, which now lists only profile. --- MANIFEST.in | 1 - README.md | 4 - runtimeconditions_profiler/cli.py | 192 +------ runtimeconditions_profiler/constants.py | 10 - .../extension/__init__.py | 14 - .../extension/artifact_validator.py | 166 ------ .../extension/definition.py | 96 ---- .../extension/identity.py | 25 - .../extension/manifest_validator.py | 238 -------- .../extension/vocabulary.py | 86 --- runtimeconditions_profiler/main.py | 46 -- .../manifest/__init__.py | 12 - .../manifest/mapping.py | 41 -- runtimeconditions_profiler/manifest/parser.py | 175 ------ runtimeconditions_profiler/models.py | 204 ------- .../profile/__init__.py | 5 +- runtimeconditions_profiler/profile/binding.py | 46 -- .../profile/extractor.py | 431 -------------- runtimeconditions_profiler/profile/imports.py | 79 --- .../profile/validator.py | 182 ------ .../project/__init__.py | 8 +- .../project/discovery.py | 170 ------ runtimeconditions_profiler/sdk/__init__.py | 9 - runtimeconditions_profiler/sdk/direct.py | 525 ------------------ runtimeconditions_profiler/sdk/resolver.py | 145 ----- runtimeconditions_profiler/source/__init__.py | 12 +- .../source/inspector.py | 32 -- runtimeconditions_profiler/source/python.py | 257 +-------- runtimeconditions_profiler/util.py | 121 ---- .../extension/runtimeconditions.bindings.yaml | 18 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 9 - .../fixture.yaml | 3 - .../extension/runtimeconditions.bindings.yaml | 19 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 9 - .../bad-string-arg-index-invalid/fixture.yaml | 3 - .../extension/runtimeconditions.bindings.yaml | 13 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 5 - testdata/authoring/base-valid/fixture.yaml | 2 - .../extension/runtimeconditions.bindings.yaml | 13 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 5 - .../fixture.yaml | 3 - .../extension/runtimeconditions.bindings.yaml | 13 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 5 - .../fixture.yaml | 3 - .../extension/runtimeconditions.bindings.yaml | 13 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 5 - .../binding-vocabulary-invalid/fixture.yaml | 3 - .../extension/runtimeconditions.bindings.yaml | 15 - .../runtimeconditions.extension.yaml | 22 - .../runtimeconditions_fixture/__init__.py | 7 - .../constant-mismatch-invalid/fixture.yaml | 3 - .../first/first_fixture/__init__.py | 5 - .../first/runtimeconditions.bindings.yaml | 13 - .../first/runtimeconditions.extension.yaml | 9 - .../fixture.yaml | 3 - .../second/runtimeconditions.bindings.yaml | 13 - .../second/runtimeconditions.extension.yaml | 9 - .../second/second_fixture/__init__.py | 5 - .../extension/runtimeconditions.bindings.yaml | 13 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 5 - .../missing-function-invalid/fixture.yaml | 3 - .../extension/runtimeconditions.bindings.yaml | 13 - .../runtimeconditions.extension.yaml | 9 - .../runtimeconditions_fixture/__init__.py | 5 - .../non-string-name-arg-invalid/fixture.yaml | 3 - .../app/app_fixture/__init__.py | 5 - .../app/runtimeconditions.bindings.yaml | 14 - .../app/runtimeconditions.extension.yaml | 11 - .../base/base_fixture/__init__.py | 5 - .../base/runtimeconditions.bindings.yaml | 14 - .../base/runtimeconditions.extension.yaml | 12 - .../field-a/field_a_fixture/__init__.py | 5 - .../field-a/runtimeconditions.bindings.yaml | 19 - .../field-a/runtimeconditions.extension.yaml | 19 - .../field-b/field_b_fixture/__init__.py | 5 - .../field-b/runtimeconditions.bindings.yaml | 19 - .../field-b/runtimeconditions.extension.yaml | 19 - .../overlapping-field-invalid/fixture.yaml | 3 - .../app/app_fixture/__init__.py | 5 - .../app/runtimeconditions.bindings.yaml | 14 - .../app/runtimeconditions.extension.yaml | 8 - .../base/base_fixture/__init__.py | 4 - .../base/runtimeconditions.bindings.yaml | 13 - .../base/runtimeconditions.extension.yaml | 11 - .../config/config_fixture/__init__.py | 5 - .../config/runtimeconditions.bindings.yaml | 19 - .../config/runtimeconditions.extension.yaml | 21 - .../transitive-dependency-valid/fixture.yaml | 2 - .../extension/runtimeconditions.bindings.yaml | 13 - .../runtimeconditions.extension.yaml | 11 - .../runtimeconditions_fixture/__init__.py | 5 - .../fixture.yaml | 3 - .../alpha/alpha_fixture/__init__.py | 5 - .../alpha/runtimeconditions.bindings.yaml | 13 - .../alpha/runtimeconditions.extension.yaml | 9 - .../app/app_fixture/__init__.py | 5 - .../app/runtimeconditions.bindings.yaml | 13 - .../app/runtimeconditions.extension.yaml | 12 - .../beta/beta_fixture/__init__.py | 5 - .../beta/runtimeconditions.bindings.yaml | 13 - .../beta/runtimeconditions.extension.yaml | 9 - .../vocabulary-conflict-invalid/fixture.yaml | 3 - tests/test_binding_profiler.py | 28 - tests/test_extension_identity.py | 84 --- tests/test_installed_binding_discovery.py | 2 +- 112 files changed, 26 insertions(+), 4153 deletions(-) delete mode 100644 runtimeconditions_profiler/extension/artifact_validator.py delete mode 100644 runtimeconditions_profiler/extension/definition.py delete mode 100644 runtimeconditions_profiler/extension/manifest_validator.py delete mode 100644 runtimeconditions_profiler/extension/vocabulary.py delete mode 100644 runtimeconditions_profiler/main.py delete mode 100644 runtimeconditions_profiler/manifest/__init__.py delete mode 100644 runtimeconditions_profiler/manifest/mapping.py delete mode 100644 runtimeconditions_profiler/manifest/parser.py delete mode 100644 runtimeconditions_profiler/models.py delete mode 100644 runtimeconditions_profiler/profile/binding.py delete mode 100644 runtimeconditions_profiler/profile/extractor.py delete mode 100644 runtimeconditions_profiler/profile/imports.py delete mode 100644 runtimeconditions_profiler/profile/validator.py delete mode 100644 runtimeconditions_profiler/project/discovery.py delete mode 100644 runtimeconditions_profiler/sdk/__init__.py delete mode 100644 runtimeconditions_profiler/sdk/direct.py delete mode 100644 runtimeconditions_profiler/sdk/resolver.py delete mode 100644 runtimeconditions_profiler/source/inspector.py delete mode 100644 runtimeconditions_profiler/util.py delete mode 100644 testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/bad-class-or-schema-arg-invalid/fixture.yaml delete mode 100644 testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/bad-string-arg-index-invalid/fixture.yaml delete mode 100644 testdata/authoring/base-valid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/base-valid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/base-valid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/base-valid/fixture.yaml delete mode 100644 testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/binding-kind-mismatch-invalid/fixture.yaml delete mode 100644 testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/binding-language-mismatch-invalid/fixture.yaml delete mode 100644 testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/binding-vocabulary-invalid/fixture.yaml delete mode 100644 testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/constant-mismatch-invalid/fixture.yaml delete mode 100644 testdata/authoring/duplicate-extension-id-invalid/first/first_fixture/__init__.py delete mode 100644 testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/duplicate-extension-id-invalid/fixture.yaml delete mode 100644 testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/duplicate-extension-id-invalid/second/second_fixture/__init__.py delete mode 100644 testdata/authoring/missing-function-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/missing-function-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/missing-function-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/missing-function-invalid/fixture.yaml delete mode 100644 testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/non-string-name-arg-invalid/fixture.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/app/app_fixture/__init__.py delete mode 100644 testdata/authoring/overlapping-field-invalid/app/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/app/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/base/base_fixture/__init__.py delete mode 100644 testdata/authoring/overlapping-field-invalid/base/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/base/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/field-a/field_a_fixture/__init__.py delete mode 100644 testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/field-b/field_b_fixture/__init__.py delete mode 100644 testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/overlapping-field-invalid/fixture.yaml delete mode 100644 testdata/authoring/transitive-dependency-valid/app/app_fixture/__init__.py delete mode 100644 testdata/authoring/transitive-dependency-valid/app/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/transitive-dependency-valid/app/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/transitive-dependency-valid/base/base_fixture/__init__.py delete mode 100644 testdata/authoring/transitive-dependency-valid/base/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/transitive-dependency-valid/base/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/transitive-dependency-valid/config/config_fixture/__init__.py delete mode 100644 testdata/authoring/transitive-dependency-valid/config/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/transitive-dependency-valid/config/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/transitive-dependency-valid/fixture.yaml delete mode 100644 testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions_fixture/__init__.py delete mode 100644 testdata/authoring/unresolved-dependency-invalid/fixture.yaml delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/alpha/alpha_fixture/__init__.py delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/app/app_fixture/__init__.py delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/beta/beta_fixture/__init__.py delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.bindings.yaml delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.extension.yaml delete mode 100644 testdata/authoring/vocabulary-conflict-invalid/fixture.yaml delete mode 100644 tests/test_binding_profiler.py diff --git a/MANIFEST.in b/MANIFEST.in index 4966c8c..55314e8 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -2,7 +2,6 @@ include README.md CONFORMANCE.md recursive-include scripts *.py recursive-include requirements *.txt recursive-include tests *.py -recursive-include testdata *.py *.yaml *.toml *.md py.typed exclude runtimeconditions_profiler/runtimeconditions.profile.v0.1.0.schema.yaml prune archive prune build diff --git a/README.md b/README.md index 5a7ca0d..e711342 100644 --- a/README.md +++ b/README.md @@ -86,10 +86,6 @@ validation-only dependencies remain in the checked closure. An error exits nonzero and leaves an existing output file untouched. Omit `--out` to print the profile to standard output. -Use the `profile` subcommands for generated bindings. The older top-level -`generate`, `discover`, and `mappings` commands belong to a separate legacy -mapping workflow. - ## Extension IDs and remote resolution Each Profile `extensions` item is a string containing the extension's required diff --git a/runtimeconditions_profiler/cli.py b/runtimeconditions_profiler/cli.py index edb7c4e..dc103f0 100644 --- a/runtimeconditions_profiler/cli.py +++ b/runtimeconditions_profiler/cli.py @@ -7,17 +7,8 @@ import tempfile from pathlib import Path -from .main import ( - DiscoveryOptions, - ProjectDiscovery, - ProfileExtractor, - ProfileOptions, - ProfileYamlWriter, - RuntimeConditionsError, - ArtifactDiscovery, - ArtifactValidator, -) -from .sdk.resolver import BUNDLE_INDEX, bundle_artifact_paths, resolve_mappings +from .errors import RuntimeConditionsError +from .profile.writer import ProfileYamlWriter from .project.installed import InstalledBindingDiscovery from .project.verify import InstalledBindingVerifier, VerifiedBindingSet from .profile.generated import GeneratedBindingExtractor @@ -28,17 +19,6 @@ def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(prog="runtimeconditions-python-profiler") subparsers = parser.add_subparsers(dest="command", required=True) - discover = subparsers.add_parser("discover") - add_project_flags(discover) - discover.add_argument("--json", action="store_true") - - generate = subparsers.add_parser("generate") - add_project_flags(generate) - generate.add_argument("--name", default="") - generate.add_argument("--workload-uri", default="") - generate.add_argument("--workload-version", default="dev") - generate.add_argument("--out") - profile = subparsers.add_parser("profile") profile_commands = profile.add_subparsers(dest="profile_command", required=True) profile_generate = profile_commands.add_parser("generate") @@ -54,168 +34,19 @@ def main(argv: list[str] | None = None) -> int: profile_verify.add_argument("--project", default=".") profile_verify.add_argument("--json", action="store_true") - mappings = subparsers.add_parser("mappings") - mapping_commands = mappings.add_subparsers(dest="mapping_command", required=True) - resolve = mapping_commands.add_parser("resolve") - resolve.add_argument("--project", default=".") - resolve.add_argument("--catalog", required=True) - resolve.add_argument("--out", default="") - - validate_one = subparsers.add_parser("validate-extension") - validate_one.add_argument("--root", default=".") - validate_one.add_argument("--catalog-root", action="append", default=[]) - - validate_many = subparsers.add_parser("validate-extensions") - validate_many.add_argument("--root", default=".") - validate_many.add_argument("--catalog-root", action="append", default=[]) - args = parser.parse_args(argv) command = args.command try: - if command == "discover": - return run_discover(args) - if command == "generate": - return run_generate(args) if command == "profile" and args.profile_command == "generate": return run_profile_generate(args) if command == "profile" and args.profile_command == "verify-bindings": return run_profile_verify_bindings(args) - if command == "mappings" and args.mapping_command == "resolve": - return run_resolve(args) - if command == "validate-extension": - return run_validate(args, plural=False) - if command == "validate-extensions": - return run_validate(args, plural=True) except RuntimeConditionsError as exc: print(f"runtimeconditions: {exc}", file=sys.stderr) return 1 return 0 -def add_project_flags(parser: argparse.ArgumentParser) -> None: - parser.add_argument("--project", default=".") - parser.add_argument("--package-path", action="append", default=[]) - parser.add_argument("--resolve-package-paths", action="store_true") - parser.add_argument("--mapping", action="append", default=[]) - parser.add_argument("--extension", action="append", default=[]) - parser.add_argument("--mappings", action="append", default=[]) - - -def discovery_options(args: argparse.Namespace) -> DiscoveryOptions: - package_paths: list[Path] = [] - for value in getattr(args, "package_path", []): - for item in value.split(os.pathsep): - if item.strip(): - package_paths.append(Path(item)) - project = Path(args.project).absolute().resolve() - bundle_paths = [Path(item) for item in getattr(args, "mappings", [])] - default_bundle = default_mapping_cache() - if args.command != "profile" and not bundle_paths and (default_bundle / BUNDLE_INDEX).is_file(): - bundle_paths.append(default_bundle) - bundle_mappings, bundle_extensions = bundle_artifact_paths(project, bundle_paths) - return DiscoveryOptions( - package_paths=package_paths, - resolve_package_paths=getattr(args, "resolve_package_paths", False), - mapping_paths=[Path(item) for item in getattr(args, "mapping", [])] + bundle_mappings, - extension_paths=[Path(item) for item in getattr(args, "extension", [])] + bundle_extensions, - ) - - -def default_mapping_cache() -> Path: - return Path.home() / ".cache" / "runtimeconditions" / "mappings" - - -def run_resolve(args: argparse.Namespace) -> int: - destination = Path(args.out).absolute() if args.out else default_mapping_cache() - resolved = resolve_mappings(Path(args.project), args.catalog, destination) - for entry in resolved: - print( - f"resolved {entry['package']} {entry['packageVersion']} " - f"to {entry['mapping']}" - ) - print(f"runtimeconditions: resolved {len(resolved)} mapping(s) into {destination}", file=sys.stderr) - return 0 - - -def run_discover(args: argparse.Namespace) -> int: - result = ProjectDiscovery().discover(Path(args.project), discovery_options(args)) - if args.json: - print(json.dumps(result.to_json(), indent=2)) - return 0 - print(f"project: {result.project_root}") - print(f"buildTool: {result.project_type}") - for path in result.package_paths: - print(f"packagePath: {path}") - for artifact in result.artifacts: - print( - "artifact: " - f"kind={artifact.kind} " - f"manifest={artifact.manifest_uri} " - f"extension={artifact.extension_uri or ''} " - f"origin={artifact.origin}" - ) - for artifact in result.validated_artifacts: - manifest = artifact.manifest - package = manifest.package if manifest is not None else "" - print( - "validatedArtifact: " - f"kind={artifact.artifact.kind} " - f"manifestExtensionId={artifact.manifest_extension_id or ''} " - f"extensionId={artifact.extension_id or ''} " - f"extensionDefinition={artifact.extension_definition_uri or ''} " - f"pythonPackage={package} " - f"declarations={len(manifest.declarations) if manifest else 0} " - f"options={len(manifest.options) if manifest else 0} " - f"constants={len(manifest.constants) if manifest else 0}" - ) - for artifact in result.sdk_mappings: - print( - "sdkMapping: " - f"distribution={artifact.distribution} " - f"version={artifact.distribution_version} " - f"name={artifact.name} " - f"mapping={artifact.mapping_path}" - ) - for artifact in result.sdk_extensions: - print( - "sdkExtension: " - f"id={artifact.id} " - f"version={artifact.version} " - f"semanticSha256={artifact.semantic_sha256} " - f"path={artifact.path}" - ) - for diagnostic in result.diagnostics: - print( - "diagnostic: " - f"severity={diagnostic.severity} " - f"code={diagnostic.code} " - f"source={diagnostic.source} " - f"message={diagnostic.message}" - ) - return 1 if result.has_errors else 0 - - -def run_generate(args: argparse.Namespace) -> int: - project = Path(args.project).absolute() - name = args.name or project.name - workload_uri = args.workload_uri or str(project) - profile = ProfileExtractor().extract( - project, - ProfileOptions( - name=name, - workload_uri=workload_uri, - workload_version=args.workload_version, - discovery_options=discovery_options(args), - ), - ) - yaml_text = ProfileYamlWriter.write(profile) - if args.out: - Path(args.out).write_text(yaml_text, encoding="utf-8") - else: - print(yaml_text, end="") - return 0 - - def run_profile_generate(args: argparse.Namespace) -> int: verified = verified_installed_bindings(Path(args.project)) extracted = GeneratedBindingExtractor(verified).extract(Path(args.project)) @@ -270,22 +101,3 @@ def run_profile_verify_bindings(args: argparse.Namespace) -> int: return 0 -def run_validate(args: argparse.Namespace, plural: bool) -> int: - discovery = ArtifactDiscovery() - artifacts = [item for item in discovery.discover_artifacts_under(Path(args.root)) if item.language in ("", "python")] - for root in args.catalog_root: - artifacts.extend( - item for item in discovery.discover_artifacts_under(Path(root)) if item.language in ("", "python") - ) - if not artifacts: - raise RuntimeConditionsError( - f"no Runtime Conditions Python artifacts discovered under {Path(args.root).absolute()}" - ) - validated = ArtifactValidator().validate(artifacts) - diagnostics = [diagnostic for artifact in validated for diagnostic in artifact.diagnostics] - if diagnostics: - lines = "\n".join(f"- {diagnostic.source}: {diagnostic.message}" for diagnostic in diagnostics) - raise RuntimeConditionsError(f"extension validation failed:\n{lines}") - suffix = "s" if plural else "" - print(f"runtimeconditions: extension{suffix} validation passed", file=sys.stderr) - return 0 diff --git a/runtimeconditions_profiler/constants.py b/runtimeconditions_profiler/constants.py index 197f3b0..fea5dd6 100644 --- a/runtimeconditions_profiler/constants.py +++ b/runtimeconditions_profiler/constants.py @@ -1,11 +1 @@ API_VERSION = "runtimeconditions.io/v1alpha1" -EXTENSION_KIND = "RuntimeConditionsExtensionDefinition" -BINDING_KIND = "RuntimeConditionsBinding" -PACKAGE_KIND = "RuntimeConditionsPackage" -LANGUAGE = "python" -BINDINGS_MANIFEST = "runtimeconditions.bindings.yaml" -PACKAGE_MANIFEST = "runtimeconditions.package.yaml" -EXTENSION_DEFINITION = "runtimeconditions.extension.yaml" -SDK_MAPPING_API_VERSION = "runtimeconditions.io/sdk-mapping/v1alpha1" -SDK_MAPPING_KIND = "RuntimeConditionsSDKMapping" -SDK_MAPPING_INDEX_KIND = "RuntimeConditionsSDKMappingIndex" diff --git a/runtimeconditions_profiler/extension/__init__.py b/runtimeconditions_profiler/extension/__init__.py index 53c05f7..e69de29 100644 --- a/runtimeconditions_profiler/extension/__init__.py +++ b/runtimeconditions_profiler/extension/__init__.py @@ -1,14 +0,0 @@ -from .artifact_validator import ArtifactValidator -from .definition import dependency_cycle_errors, parse_extension_definition, resolve_definitions -from .manifest_validator import ManifestVocabularyValidator -from .vocabulary import ExtensionVocabulary - -__all__ = [ - "ArtifactValidator", - "ExtensionVocabulary", - "ManifestVocabularyValidator", - "dependency_cycle_errors", - "parse_extension_definition", - "resolve_definitions", -] - diff --git a/runtimeconditions_profiler/extension/artifact_validator.py b/runtimeconditions_profiler/extension/artifact_validator.py deleted file mode 100644 index fc3bdc5..0000000 --- a/runtimeconditions_profiler/extension/artifact_validator.py +++ /dev/null @@ -1,166 +0,0 @@ -from __future__ import annotations - -import hashlib -import json -from typing import Any, Optional -from urllib.parse import urlparse - -from ..constants import API_VERSION, BINDING_KIND, EXTENSION_DEFINITION, EXTENSION_KIND, LANGUAGE, PACKAGE_KIND -from ..manifest.parser import ManifestParser, require_scalar -from ..models import ExtensionDefinition, RuntimeConditionsArtifact, ValidatedArtifact -from ..util import as_map, scalar, uri_to_path -from ..yamlio import Yaml -from .identity import parse_identifier -from .definition import dependency_cycle_errors, parse_extension_definition -from .identity import resolve_reference -from .manifest_validator import ManifestVocabularyValidator - - -class ArtifactValidator: - def validate(self, artifacts: list[RuntimeConditionsArtifact]) -> list[ValidatedArtifact]: - validated = [self._validate_one(artifact) for artifact in artifacts] - self._validate_set(validated) - return validated - - def _validate_one(self, artifact: RuntimeConditionsArtifact) -> ValidatedArtifact: - item = ValidatedArtifact(artifact=artifact) - manifest_doc: dict[str, Any] | None = None - manifest_extension_sha256: str | None = None - try: - manifest_doc = Yaml.load(uri_to_path(artifact.manifest_uri)) - except Exception as exc: - item.add("package-manifest", artifact.manifest_uri, f"failed to read manifest: {exc}") - - if manifest_doc is not None: - expected_kind = BINDING_KIND if artifact.kind == "binding" else PACKAGE_KIND - require_value(item, manifest_doc.get("apiVersion"), API_VERSION, artifact.manifest_uri, "apiVersion") - require_value(item, manifest_doc.get("kind"), expected_kind, artifact.manifest_uri, "kind") - metadata = as_map(manifest_doc.get("metadata")) - require_value(item, metadata.get("language"), LANGUAGE, artifact.manifest_uri, "metadata.language") - section = as_map(manifest_doc.get(LANGUAGE)) - if section is None: - item.add("package-language", artifact.manifest_uri, "python section is required") - else: - item.manifest = ManifestParser().parse(section, artifact.manifest_uri, item) - - if artifact.kind == "binding": - reference = metadata.get("extension") - manifest_extension_sha256 = scalar(metadata.get("extensionSha256")) - if section is not None: - require_scalar(item, section, artifact.manifest_uri, "python.package") - override = scalar(metadata.get("extensionDefinition")) - else: - extension = as_map(manifest_doc.get("extension")) - reference = extension - override = scalar(extension.get("definition")) - try: - item.manifest_extension_id, item.manifest_extension_version = parse_identifier(reference) - except Exception as exc: - item.add("extension-definition", artifact.manifest_uri, str(exc)) - item.extension_definition_uri = resolve_extension_definition(artifact, override, item) - - if item.extension_definition_uri is not None: - try: - extension_doc = Yaml.load(uri_to_path(item.extension_definition_uri)) - require_value(item, extension_doc.get("apiVersion"), API_VERSION, item.extension_definition_uri, "apiVersion") - require_value(item, extension_doc.get("kind"), EXTENSION_KIND, item.extension_definition_uri, "kind") - metadata = as_map(extension_doc.get("metadata")) - item.extension_id, item.extension_version = parse_identifier(metadata) - extension_digest = scalar(metadata.get("semanticSha256")) - if extension_digest: - actual_digest = hashlib.sha256( - json.dumps( - extension_doc.get("spec", {}), - sort_keys=True, - separators=(",", ":"), - ensure_ascii=False, - ).encode("utf-8") - ).hexdigest() - if extension_digest != actual_digest: - item.add( - "extension-definition", - item.extension_definition_uri, - f"metadata.semanticSha256 is {extension_digest}, expected {actual_digest}", - ) - if manifest_extension_sha256 and manifest_extension_sha256 != extension_digest: - item.add( - "extension-definition", - artifact.manifest_uri, - f"binding extensionSha256 {manifest_extension_sha256} does not match {extension_digest}", - ) - if item.extension_id: - item.extension_definition = parse_extension_definition( - extension_doc, - item.extension_id, - item.extension_definition_uri, - ) - item.dependencies = item.extension_definition.dependencies - except Exception as exc: - item.add("extension-definition", item.extension_definition_uri, f"failed to read extension definition: {exc}") - - if item.manifest_extension_id and item.extension_id and (item.manifest_extension_id, item.manifest_extension_version) != item.reference: - item.add( - "extension-definition", - artifact.manifest_uri, - f"manifest extension {(item.manifest_extension_id, item.manifest_extension_version)} does not match extension definition {item.reference}", - ) - return item - - def _validate_set(self, artifacts: list[ValidatedArtifact]) -> None: - definitions_by_id: dict[tuple[str, str], str] = {} - models_by_id: dict[tuple[str, str], ExtensionDefinition] = {} - for artifact in artifacts: - if not artifact.extension_id: - continue - previous = definitions_by_id.setdefault(artifact.reference, artifact.extension_definition_uri or "") - if previous != (artifact.extension_definition_uri or ""): - artifact.add( - "extension-definition", - artifact.extension_definition_uri or artifact.artifact.manifest_uri, - f"duplicate extension id {artifact.extension_id} already defined by {previous}", - ) - if artifact.extension_definition is not None: - models_by_id.setdefault(artifact.reference, artifact.extension_definition) - - for artifact in artifacts: - for dependency in artifact.dependencies: - if resolve_reference(dependency, definitions_by_id) not in definitions_by_id: - artifact.add( - "extension-dependency", - artifact.extension_definition_uri or artifact.artifact.manifest_uri, - f"dependency {dependency} cannot be resolved from discovered Runtime Conditions artifacts", - ) - - cycle_errors = dependency_cycle_errors(models_by_id) - for artifact in artifacts: - for message in cycle_errors: - artifact.add("extension-dependency", artifact.extension_definition_uri or artifact.artifact.manifest_uri, message) - - for artifact in artifacts: - ManifestVocabularyValidator().validate(artifact, models_by_id) - - -def resolve_extension_definition( - artifact: RuntimeConditionsArtifact, - override: Optional[str], - validated: ValidatedArtifact, -) -> Optional[str]: - if override: - path = (uri_to_path(artifact.manifest_uri).parent / override).resolve() - return path.as_uri() - if artifact.extension_uri is None: - validated.add( - "extension-definition", - artifact.manifest_uri, - f"{EXTENSION_DEFINITION} is required next to the manifest", - ) - return None - return artifact.extension_uri - - -def require_value(artifact: ValidatedArtifact, actual: Any, expected: str, source: str, field_name: str) -> None: - parsed = scalar(actual) - if not parsed: - artifact.add("package-manifest", source, f"{field_name} is required") - elif parsed != expected: - artifact.add("package-manifest", source, f"{field_name} must be {expected}") diff --git a/runtimeconditions_profiler/extension/definition.py b/runtimeconditions_profiler/extension/definition.py deleted file mode 100644 index 5e095b1..0000000 --- a/runtimeconditions_profiler/extension/definition.py +++ /dev/null @@ -1,96 +0,0 @@ -from __future__ import annotations - -from typing import Any - -from ..models import ExtensionDefinition -from .identity import parse_identifier, resolve_reference -from ..util import as_list, as_map, parse_plain_string_list, scalar - - -def parse_extension_definition(doc: dict[str, Any], extension_id: str, uri: str) -> ExtensionDefinition: - spec = as_map(doc.get("spec")) - kinds = [scalar(item.get("name")) or "" for item in as_list(spec.get("kinds")) if isinstance(item, dict)] - interface_types = [ - (scalar(item.get("targetKind")) or "", scalar(item.get("name")) or "") - for item in as_list(spec.get("interfaceTypes")) - if isinstance(item, dict) - ] - interface_fields = [ - (scalar(item.get("targetKind")) or "", scalar(item.get("targetType")) or "", scalar(item.get("name")) or "") - for item in as_list(spec.get("interfaceFields")) - if isinstance(item, dict) - ] - condition_fields = [ - ( - scalar(item.get("name")) or "", - tuple(parse_plain_string_list(item.get("appliesToKinds"))), - tuple(parse_plain_string_list(item.get("appliesToInterfaceTypes"))), - ) - for item in as_list(spec.get("conditionFields")) - if isinstance(item, dict) - ] - field_values = [ - ( - scalar(item.get("field")) or "", - scalar(item.get("targetKind")) or "", - scalar(item.get("targetType")) or "", - tuple(parse_plain_string_list(item.get("values"))), - ) - for item in as_list(spec.get("fieldValues")) - if isinstance(item, dict) - ] - return ExtensionDefinition( - id=extension_id, - version=parse_identifier(as_map(doc.get("metadata")))[1], - uri=uri, - dependencies=[parse_identifier(item) for item in as_list(spec.get("dependencies"))], - kinds=[item for item in kinds if item], - interface_types=[item for item in interface_types if item[0] and item[1]], - interface_fields=[item for item in interface_fields if item[0] and item[1] and item[2]], - condition_fields=[item for item in condition_fields if item[0]], - field_values=[item for item in field_values if item[0] and item[1] and item[2]], - ) - - -def resolve_definitions(extension_id: tuple[str, str], definitions_by_id: dict[tuple[str, str], ExtensionDefinition]) -> list[ExtensionDefinition]: - resolved: list[ExtensionDefinition] = [] - seen: set[tuple[str, str]] = set() - - def visit(current: tuple[str, str]) -> None: - if current in seen: - return - seen.add(current) - definition = definitions_by_id.get(current) - if definition is None: - return - for dependency in definition.dependencies: - visit(resolve_reference(dependency, definitions_by_id)) - resolved.append(definition) - - visit(extension_id) - return resolved - - -def dependency_cycle_errors(definitions_by_id: dict[tuple[str, str], ExtensionDefinition]) -> list[str]: - errors: list[str] = [] - visiting: set[tuple[str, str]] = set() - visited: set[tuple[str, str]] = set() - - def visit(extension_id: tuple[str, str]) -> None: - if extension_id in visited: - return - if extension_id in visiting: - errors.append(f"extension dependency cycle includes {extension_id}") - return - visiting.add(extension_id) - definition = definitions_by_id.get(extension_id) - if definition is not None: - for dependency in definition.dependencies: - visit(resolve_reference(dependency, definitions_by_id)) - visiting.remove(extension_id) - visited.add(extension_id) - - for extension_id in definitions_by_id: - visit(extension_id) - return errors - diff --git a/runtimeconditions_profiler/extension/identity.py b/runtimeconditions_profiler/extension/identity.py index e702f08..aab73a5 100644 --- a/runtimeconditions_profiler/extension/identity.py +++ b/runtimeconditions_profiler/extension/identity.py @@ -2,7 +2,6 @@ from __future__ import annotations -from collections.abc import Iterable from ..errors import RuntimeConditionsError @@ -25,10 +24,6 @@ def parse_identifier(reference: object) -> tuple[str, str]: return identifier, version or "" -def reference_object(reference: tuple[str, str]) -> dict[str, str]: - return {"id": reference[0], "version": reference[1]} - - EXTENSION_FILENAME = "runtimeconditions.extension.yaml" @@ -43,13 +38,6 @@ def short_identifier(identifier: str, version: str) -> str: return identifier -def expand_identifier(identifier: str, version: str) -> str: - """Rebuild the full extension id from a short https reference; anything else is returned as is.""" - if version and identifier.startswith("https://") and not identifier.endswith("/" + EXTENSION_FILENAME): - return f"{identifier}/{version}/{EXTENSION_FILENAME}" - return identifier - - def profile_reference(reference: tuple[str, str]) -> str: """Serialize an extension reference for a Runtime Conditions Profile as :.""" identifier, version = reference @@ -61,16 +49,3 @@ def definition_identifier(metadata: dict[str, object]) -> str: """Return the ID declared by valid extension metadata.""" return parse_identifier(metadata)[0] - -def resolve_reference(reference: tuple[str, str], known: Iterable[tuple[str, str]]) -> tuple[str, str]: - """Pair a dependency written as a bare id with its version. - - Extension dependencies name an extension by its full id string, which carries no - version suffix. When the id matches exactly one known (id, version), return that; - otherwise return the reference unchanged. - """ - keys = list(known) - if reference in keys or reference[1]: - return reference - matches = [key for key in keys if key[0] == reference[0]] - return matches[0] if len(matches) == 1 else reference diff --git a/runtimeconditions_profiler/extension/manifest_validator.py b/runtimeconditions_profiler/extension/manifest_validator.py deleted file mode 100644 index 56dae13..0000000 --- a/runtimeconditions_profiler/extension/manifest_validator.py +++ /dev/null @@ -1,238 +0,0 @@ -from __future__ import annotations - -from ..manifest.mapping import all_mappings -from ..models import ExtensionDefinition, SymbolMapping, ValidatedArtifact -from ..source.inspector import SourceInspector -from .definition import resolve_definitions -from .vocabulary import ExtensionVocabulary - - -class ManifestVocabularyValidator: - def validate(self, artifact: ValidatedArtifact, definitions_by_id: dict[tuple[str, str], ExtensionDefinition]) -> None: - if artifact.manifest is None or artifact.extension_id is None: - return - vocabulary = ExtensionVocabulary(resolve_definitions(artifact.reference, definitions_by_id)) - for key, count in vocabulary.counts().items(): - if count > 1: - artifact.add( - "extension-vocabulary", - artifact.extension_definition_uri or artifact.artifact.manifest_uri, - f"resolved extension set contains vocabulary conflict for {key}", - ) - for conflict in vocabulary.condition_field_conflicts(): - artifact.add( - "extension-vocabulary", - artifact.extension_definition_uri or artifact.artifact.manifest_uri, - f"resolved extension set contains vocabulary conflict for {conflict}", - ) - for constant, value in artifact.manifest.constants.items(): - if vocabulary.field_value_value_count(value) == 0: - artifact.add( - "package-manifest", - artifact.artifact.manifest_uri, - f'constant {constant} value "{value}" is not defined by resolved field values', - ) - for declaration in artifact.manifest.declarations: - self._validate_declaration(artifact, vocabulary, declaration) - for option in artifact.manifest.options: - self._validate_option(artifact, vocabulary, option, scopes_from_option(option, vocabulary)) - SourceInspector().validate(artifact) - - def _validate_declaration( - self, - artifact: ValidatedArtifact, - vocabulary: ExtensionVocabulary, - declaration: SymbolMapping, - ) -> None: - kind = declaration.kind or str(constant_write(declaration, "kind") or "") - expect_exactly_one(artifact, vocabulary.kind_count(kind), f"declaration kind {kind}") - interface_type = declaration.interface_type or str(constant_write(declaration, "interface.type") or "") - if interface_type: - expect_exactly_one( - artifact, - vocabulary.interface_type_count(kind, interface_type), - f"declaration interfaceType {kind}/{interface_type}", - ) - scopes = [(kind, interface_type)] - if declaration.writes: - scopes = self._validate_writes(artifact, vocabulary, declaration, scopes) - for option in declaration.options: - self._validate_option(artifact, vocabulary, option, scopes) - - def _validate_option( - self, - artifact: ValidatedArtifact, - vocabulary: ExtensionVocabulary, - option: SymbolMapping, - scopes: list[tuple[str, str]], - ) -> None: - nested_scopes = scopes - if option.writes: - nested_scopes = self._validate_writes(artifact, vocabulary, option, scopes) - elif option.target == "interface.spec": - for kind, interface_type in scopes: - expect_exactly_one( - artifact, - vocabulary.interface_field_count(kind, interface_type, "spec"), - f"binding option interface.spec for {kind}/{interface_type}", - ) - elif option.target == "interface.operations[]": - for kind, interface_type in scopes: - expect_exactly_one( - artifact, - vocabulary.interface_field_count(kind, interface_type, "operations"), - f"binding option interface.operations[] for {kind}/{interface_type}", - ) - expect_exactly_one( - artifact, - vocabulary.field_value_count( - "interface.operations[].method", - kind, - interface_type, - option.method, - ), - f"binding option method {option.method} for {kind}/{interface_type}", - ) - elif option.target == "interface.type": - updated: list[tuple[str, str]] = [] - for kind, _ in scopes: - expect_exactly_one( - artifact, - vocabulary.interface_type_count(kind, option.value), - f"binding option interface.type {kind}/{option.value}", - ) - if option.enum_arg is not None: - expect_exactly_one( - artifact, - vocabulary.interface_field_count(kind, option.value, "engine"), - f"binding option engine for {kind}/{option.value}", - ) - updated.append((kind, option.value)) - nested_scopes = updated - elif option.target == "configuration.env[]": - validate_configuration_option(artifact, vocabulary, scopes, "configuration.env[].property") - elif option.target == "configuration.alternatives[]": - validate_configuration_option( - artifact, - vocabulary, - scopes, - "configuration.alternatives[].env[].property", - ) - elif option.target in ("requestBodySchema", "responseSchema", "env.sensitive", "env.required"): - pass - elif not option.target: - artifact.add("package-manifest", artifact.artifact.manifest_uri, f"binding option {option.member_name} is missing target") - else: - artifact.add( - "package-manifest", - artifact.artifact.manifest_uri, - f"unsupported binding option target {option.target}", - ) - for nested in option.options: - self._validate_option(artifact, vocabulary, nested, nested_scopes) - - def _validate_writes( - self, - artifact: ValidatedArtifact, - vocabulary: ExtensionVocabulary, - mapping: SymbolMapping, - scopes: list[tuple[str, str]], - ) -> list[tuple[str, str]]: - current = scopes - for write in mapping.writes: - target = write.get("target") - value = write.get("value") - if target == "kind": - expect_exactly_one(artifact, vocabulary.kind_count(str(value)), f"binding write kind {value}") - current = [(str(value), interface_type) for _, interface_type in current] - continue - if target in ("name", "optional"): - continue - if target == "interface.type": - updated: list[tuple[str, str]] = [] - for kind, _ in current: - expect_exactly_one( - artifact, - vocabulary.interface_type_count(kind, str(value)), - f"binding write interface.type {kind}/{value}", - ) - updated.append((kind, str(value))) - current = updated - continue - if not isinstance(target, str) or not target.startswith("interface."): - artifact.add("package-manifest", artifact.artifact.manifest_uri, f"unsupported binding write target {target}") - continue - field = target.split(".")[1].removesuffix("[]") - candidates = write.get("values", [value]) - for kind, interface_type in current: - expect_exactly_one( - artifact, - vocabulary.interface_field_count(kind, interface_type, field), - f"binding write {target} for {kind}/{interface_type}", - ) - for candidate in candidates: - if not isinstance(candidate, dict): - continue - for child, child_value in candidate.items(): - if vocabulary.field_value_definition_count(f"{target}.{child}", kind, interface_type): - expect_exactly_one( - artifact, - vocabulary.field_value_count(f"{target}.{child}", kind, interface_type, str(child_value)), - f"binding write {target}.{child} value {child_value} for {kind}/{interface_type}", - ) - return current - - -def constant_write(mapping: SymbolMapping, target: str): - for write in mapping.writes: - if write.get("target") == target and "value" in write: - return write["value"] - return None - - -def validate_configuration_option( - artifact: ValidatedArtifact, - vocabulary: ExtensionVocabulary, - scopes: list[tuple[str, str]], - property_field: str, -) -> None: - if not scopes: - artifact.add( - "package-manifest", - artifact.artifact.manifest_uri, - "configuration binding option requires appliesToKinds/appliesToInterfaceTypes or a declaration scope", - ) - return - for kind, interface_type in scopes: - expect_exactly_one( - artifact, - vocabulary.condition_field_count(kind, interface_type, "configuration"), - f"binding option configuration for {kind}/{interface_type}", - ) - expect_exactly_one( - artifact, - vocabulary.field_value_definition_count(property_field, kind, interface_type), - f"binding option property field {property_field} for {kind}/{interface_type}", - ) - - -def scopes_from_option(option: SymbolMapping, vocabulary: ExtensionVocabulary) -> list[tuple[str, str]]: - if not option.applies_to_kinds: - return [] - if not option.applies_to_interface_types: - return [(kind, "") for kind in option.applies_to_kinds] - scopes: list[tuple[str, str]] = [] - for kind in option.applies_to_kinds: - for interface_type in option.applies_to_interface_types: - if vocabulary.interface_type_count(kind, interface_type) == 1: - scopes.append((kind, interface_type)) - return scopes - - -def expect_exactly_one(artifact: ValidatedArtifact, count: int, message: str) -> None: - if count != 1: - artifact.add( - "package-manifest", - artifact.artifact.manifest_uri, - f"{message}: expected exactly one definition, got {count}", - ) diff --git a/runtimeconditions_profiler/extension/vocabulary.py b/runtimeconditions_profiler/extension/vocabulary.py deleted file mode 100644 index f3f0fa9..0000000 --- a/runtimeconditions_profiler/extension/vocabulary.py +++ /dev/null @@ -1,86 +0,0 @@ -from __future__ import annotations - -from ..models import ExtensionDefinition -from ..util import condition_scopes_overlap, increment - - -class ExtensionVocabulary: - def __init__(self, definitions: list[ExtensionDefinition]) -> None: - self.definitions = definitions - - def kind_count(self, name: str) -> int: - return sum(1 for definition in self.definitions for item in definition.kinds if item == name) - - def interface_type_count(self, kind: str, name: str) -> int: - return sum( - 1 - for definition in self.definitions - for item_kind, item_name in definition.interface_types - if item_kind == kind and item_name == name - ) - - def interface_field_count(self, kind: str, interface_type: str, name: str) -> int: - return sum( - 1 - for definition in self.definitions - for item_kind, item_type, item_name in definition.interface_fields - if item_kind == kind and item_type == interface_type and item_name == name - ) - - def condition_field_count(self, kind: str, interface_type: str, name: str) -> int: - return sum( - 1 - for definition in self.definitions - for item_name, kinds, interface_types in definition.condition_fields - if item_name == name and kind in kinds and (not interface_types or interface_type in interface_types) - ) - - def field_value_count(self, field_name: str, kind: str, interface_type: str, value: str) -> int: - return sum( - 1 - for definition in self.definitions - for item_field, item_kind, item_type, values in definition.field_values - if item_field == field_name and item_kind == kind and item_type == interface_type and value in values - ) - - def field_value_definition_count(self, field_name: str, kind: str, interface_type: str) -> int: - return sum( - 1 - for definition in self.definitions - for item_field, item_kind, item_type, _ in definition.field_values - if item_field == field_name and item_kind == kind and item_type == interface_type - ) - - def field_value_value_count(self, value: str) -> int: - return sum( - 1 - for definition in self.definitions - for _, _, _, values in definition.field_values - if value in values - ) - - def counts(self) -> dict[str, int]: - counts: dict[str, int] = {} - for definition in self.definitions: - for kind in definition.kinds: - increment(counts, f"kind:{kind}") - for kind, name in definition.interface_types: - increment(counts, f"interfaceType:{kind}:{name}") - for kind, interface_type, name in definition.interface_fields: - increment(counts, f"interfaceField:{kind}:{interface_type}:{name}") - for field_name, kind, interface_type, _ in definition.field_values: - increment(counts, f"fieldValues:{kind}:{interface_type}:{field_name}") - return counts - - def condition_field_conflicts(self) -> list[str]: - fields: list[tuple[ExtensionDefinition, str, tuple[str, ...], tuple[str, ...]]] = [] - for definition in self.definitions: - for name, kinds, interface_types in definition.condition_fields: - fields.append((definition, name, kinds, interface_types)) - conflicts: list[str] = [] - for index, left in enumerate(fields): - for right in fields[index + 1 :]: - if left[1] == right[1] and condition_scopes_overlap(left[2], left[3], right[2], right[3]): - conflicts.append(f"conditionField:{left[1]} between {left[0].id} and {right[0].id}") - return conflicts - diff --git a/runtimeconditions_profiler/main.py b/runtimeconditions_profiler/main.py deleted file mode 100644 index ba896db..0000000 --- a/runtimeconditions_profiler/main.py +++ /dev/null @@ -1,46 +0,0 @@ -from .errors import RuntimeConditionsError -from .extension import ArtifactValidator, ExtensionVocabulary, ManifestVocabularyValidator -from .manifest import ManifestParser -from .models import ( - CallIdentity, - Diagnostic, - DiscoveryOptions, - DiscoveryResult, - ExtensionDefinition, - ManifestModel, - ProfileOptions, - RuntimeConditionsArtifact, - SymbolMapping, - ValidatedArtifact, -) -from .profile import ProfileExtractor, ProfileValidator, ProfileYamlWriter -from .project import ArtifactDiscovery, ProjectDiscovery -from .source import PythonSourceIndex, SourceInspector -from .yamlio import Yaml - -__all__ = [ - "ArtifactDiscovery", - "ArtifactValidator", - "CallIdentity", - "Diagnostic", - "DiscoveryOptions", - "DiscoveryResult", - "ExtensionDefinition", - "ExtensionVocabulary", - "ManifestModel", - "ManifestParser", - "ManifestVocabularyValidator", - "ProfileExtractor", - "ProfileOptions", - "ProfileValidator", - "ProfileYamlWriter", - "ProjectDiscovery", - "PythonSourceIndex", - "RuntimeConditionsArtifact", - "RuntimeConditionsError", - "SourceInspector", - "SymbolMapping", - "ValidatedArtifact", - "Yaml", -] - diff --git a/runtimeconditions_profiler/manifest/__init__.py b/runtimeconditions_profiler/manifest/__init__.py deleted file mode 100644 index 74135cf..0000000 --- a/runtimeconditions_profiler/manifest/__init__.py +++ /dev/null @@ -1,12 +0,0 @@ -from .mapping import all_mappings, class_matches, find_option, simple_name, strip_package_class -from .parser import ManifestParser - -__all__ = [ - "ManifestParser", - "all_mappings", - "class_matches", - "find_option", - "simple_name", - "strip_package_class", -] - diff --git a/runtimeconditions_profiler/manifest/mapping.py b/runtimeconditions_profiler/manifest/mapping.py deleted file mode 100644 index 11ead76..0000000 --- a/runtimeconditions_profiler/manifest/mapping.py +++ /dev/null @@ -1,41 +0,0 @@ -from __future__ import annotations - -from typing import Optional - -from ..models import ManifestModel, SymbolMapping - - -def all_mappings(manifest: ManifestModel) -> list[SymbolMapping]: - result: list[SymbolMapping] = [] - - def walk(mapping: SymbolMapping) -> None: - result.append(mapping) - for option in mapping.options: - walk(option) - - for mapping in manifest.declarations: - walk(mapping) - for mapping in manifest.options: - walk(mapping) - return result - - -def find_option(options: list[SymbolMapping], class_name: str, member_name: str) -> Optional[SymbolMapping]: - for option in options: - if class_matches(class_name, option.class_name) and option.member_name == member_name: - return option - return None - - -def class_matches(actual: str, expected: str) -> bool: - return actual == expected or simple_name(actual) == expected - - -def simple_name(value: str) -> str: - return value.rsplit(".", 1)[-1] - - -def strip_package_class(value: str, package: str) -> str: - prefix = f"{package}." - return value[len(prefix) :] if value.startswith(prefix) else value - diff --git a/runtimeconditions_profiler/manifest/parser.py b/runtimeconditions_profiler/manifest/parser.py deleted file mode 100644 index ff3403c..0000000 --- a/runtimeconditions_profiler/manifest/parser.py +++ /dev/null @@ -1,175 +0,0 @@ -from __future__ import annotations - -from typing import Any, Optional - -from ..models import ManifestModel, SymbolMapping, ValidatedArtifact -from ..util import scalar - - -class ManifestParser: - def parse(self, section: dict[str, Any], source: str, artifact: ValidatedArtifact) -> ManifestModel: - package = scalar(section.get("package")) or "" - if not package: - artifact.add("package-manifest", source, "python.package is required") - constants = parse_constants(section.get("constants"), source, artifact) - declarations = parse_mappings(section.get("declarations"), "python.declarations", True, source, artifact) - options = parse_mappings(section.get("options"), "python.options", False, source, artifact) - if not declarations and not options: - artifact.add( - "package-manifest", - source, - "at least one python.declarations or python.options entry is required", - ) - return ManifestModel(package=package, constants=constants, declarations=declarations, options=options) - - -def parse_mappings( - value: Any, - path: str, - declaration: bool, - source: str, - artifact: ValidatedArtifact, -) -> list[SymbolMapping]: - if value is None: - return [] - if not isinstance(value, list): - artifact.add("package-manifest", source, f"{path} must be a sequence") - return [] - mappings: list[SymbolMapping] = [] - for index, item in enumerate(value): - item_path = f"{path}[{index}]" - if not isinstance(item, dict): - artifact.add("package-manifest", source, f"{item_path} must be a mapping") - continue - class_name = require_scalar(artifact, item, source, f"{item_path}.class") or "" - member = scalar(item.get("function")) or scalar(item.get("method")) or "" - if not member: - artifact.add("package-manifest", source, f"{item_path} must define function or method") - target = scalar(item.get("target")) or "" - kind = scalar(item.get("kind")) or "" - writes = parse_writes(item.get("writes"), f"{item_path}.writes", source, artifact) - if declaration and not kind and not writes: - artifact.add("package-manifest", source, f"{item_path}.kind is required") - if not declaration and not target and not writes: - artifact.add("package-manifest", source, f"{item_path}.target is required") - mappings.append( - SymbolMapping( - class_name=class_name, - member_name=member, - target=target, - kind=kind, - interface_type=scalar(item.get("interfaceType")) or "", - value=scalar(item.get("value")) or "", - method=scalar(item.get("method")) or "", - name_arg=parse_int(item.get("nameArg"), f"{item_path}.nameArg", source, artifact), - class_arg=parse_int(item.get("classArg"), f"{item_path}.classArg", source, artifact), - enum_arg=parse_int(item.get("enumArg"), f"{item_path}.enumArg", source, artifact), - string_args=parse_int_map(item.get("stringArgs"), f"{item_path}.stringArgs", source, artifact), - applies_to_kinds=parse_string_list(item.get("appliesToKinds"), f"{item_path}.appliesToKinds", source, artifact), - applies_to_interface_types=parse_string_list( - item.get("appliesToInterfaceTypes"), - f"{item_path}.appliesToInterfaceTypes", - source, - artifact, - ), - writes=writes, - options=parse_mappings(item.get("options"), f"{item_path}.options", False, source, artifact), - ) - ) - return mappings - - -def parse_writes(value: Any, path: str, source: str, artifact: ValidatedArtifact) -> list[dict[str, Any]]: - if value is None: - return [] - if not isinstance(value, list) or not value: - artifact.add("package-manifest", source, f"{path} must be a non-empty sequence") - return [] - writes: list[dict[str, Any]] = [] - for index, item in enumerate(value): - if not isinstance(item, dict) or not isinstance(item.get("target"), str): - artifact.add("package-manifest", source, f"{path}[{index}] requires target") - continue - sources = [key for key in ("value", "values", "argument") if key in item] - if len(sources) != 1: - artifact.add("package-manifest", source, f"{path}[{index}] requires exactly one value, values, or argument") - continue - argument = item.get("argument") - if argument is not None and ( - not isinstance(argument, dict) - or not isinstance(argument.get("position"), int) - or argument["position"] < 0 - ): - artifact.add("package-manifest", source, f"{path}[{index}].argument.position must be zero or greater") - continue - writes.append(dict(item)) - return writes - - -def parse_constants(value: Any, source: str, artifact: ValidatedArtifact) -> dict[str, str]: - if value is None: - return {} - if not isinstance(value, dict): - artifact.add("package-manifest", source, "python.constants must be a mapping") - return {} - constants: dict[str, str] = {} - for key, item in value.items(): - parsed = scalar(item) - if parsed is None: - artifact.add("package-manifest", source, f"python.constants.{key} must be scalar") - else: - constants[str(key)] = parsed - return constants - - -def require_scalar( - artifact: ValidatedArtifact, - input_map: dict[str, Any], - source: str, - path: str, -) -> Optional[str]: - key = path.split(".")[-1] - value = scalar(input_map.get(key)) - if not value: - artifact.add("package-manifest", source, f"{path} is required") - return None - return value - - -def parse_int(value: Any, path: str, source: str, artifact: ValidatedArtifact) -> Optional[int]: - if value is None: - return None - if isinstance(value, int) and value >= 0: - return value - artifact.add("package-manifest", source, f"{path} must be an integer zero or greater") - return None - - -def parse_int_map(value: Any, path: str, source: str, artifact: ValidatedArtifact) -> dict[str, int]: - if value is None: - return {} - if not isinstance(value, dict): - artifact.add("package-manifest", source, f"{path} must be a mapping") - return {} - result: dict[str, int] = {} - for key, item in value.items(): - parsed = parse_int(item, f"{path}.{key}", source, artifact) - if parsed is not None: - result[str(key)] = parsed - return result - - -def parse_string_list(value: Any, path: str, source: str, artifact: ValidatedArtifact) -> list[str]: - if value is None: - return [] - if not isinstance(value, list): - artifact.add("package-manifest", source, f"{path} must be a sequence") - return [] - result: list[str] = [] - for index, item in enumerate(value): - parsed = scalar(item) - if parsed is None: - artifact.add("package-manifest", source, f"{path}[{index}] must be scalar") - else: - result.append(parsed) - return result diff --git a/runtimeconditions_profiler/models.py b/runtimeconditions_profiler/models.py deleted file mode 100644 index a693086..0000000 --- a/runtimeconditions_profiler/models.py +++ /dev/null @@ -1,204 +0,0 @@ -from __future__ import annotations - -from dataclasses import dataclass, field -from pathlib import Path -from typing import Any, Optional - - -@dataclass(frozen=True) -class Diagnostic: - severity: str - code: str - source: str - message: str - - -@dataclass(frozen=True) -class SymbolMapping: - class_name: str - member_name: str - target: str = "" - kind: str = "" - interface_type: str = "" - value: str = "" - method: str = "" - name_arg: Optional[int] = None - class_arg: Optional[int] = None - enum_arg: Optional[int] = None - string_args: dict[str, int] = field(default_factory=dict) - applies_to_kinds: list[str] = field(default_factory=list) - applies_to_interface_types: list[str] = field(default_factory=list) - writes: list[dict[str, Any]] = field(default_factory=list) - options: list["SymbolMapping"] = field(default_factory=list) - - -@dataclass(frozen=True) -class ManifestModel: - package: str - constants: dict[str, str] - declarations: list[SymbolMapping] - options: list[SymbolMapping] - - -@dataclass(frozen=True) -class ExtensionDefinition: - id: str - version: str - uri: str - dependencies: list[tuple[str, str]] - kinds: list[str] - interface_types: list[tuple[str, str]] - interface_fields: list[tuple[str, str, str]] - condition_fields: list[tuple[str, tuple[str, ...], tuple[str, ...]]] - field_values: list[tuple[str, str, str, tuple[str, ...]]] - - -@dataclass(frozen=True) -class RuntimeConditionsArtifact: - kind: str - manifest_uri: str - extension_uri: Optional[str] - origin: str - source_path: Optional[Path] - root: Path - language: str = "" - - -@dataclass -class ValidatedArtifact: - artifact: RuntimeConditionsArtifact - manifest_extension_id: Optional[str] = None - manifest_extension_version: Optional[str] = None - extension_id: Optional[str] = None - extension_version: Optional[str] = None - extension_definition_uri: Optional[str] = None - extension_definition: Optional[ExtensionDefinition] = None - manifest: Optional[ManifestModel] = None - dependencies: list[tuple[str, str]] = field(default_factory=list) - diagnostics: list[Diagnostic] = field(default_factory=list) - - @property - def reference(self) -> tuple[str, str]: - assert self.extension_id is not None and self.extension_version is not None - return self.extension_id, self.extension_version - - def add(self, code: str, source: str, message: str) -> None: - self.diagnostics.append(Diagnostic("error", code, source, message)) - - -@dataclass(frozen=True) -class DiscoveryOptions: - package_paths: list[Path] = field(default_factory=list) - resolve_package_paths: bool = False - mapping_paths: list[Path] = field(default_factory=list) - extension_paths: list[Path] = field(default_factory=list) - - -@dataclass(frozen=True) -class SDKMappingArtifact: - distribution: str - distribution_version: str - name: str - index_path: Path - mapping_path: Path - mapping_sha256: str - mapping: dict[str, Any] - - -@dataclass(frozen=True) -class SDKExtensionArtifact: - id: str - version: str - semantic_sha256: str - path: Path - definition: ExtensionDefinition - document: dict[str, Any] - - -@dataclass(frozen=True) -class DiscoveryResult: - project_root: Path - project_type: str - package_paths: list[Path] - artifacts: list[RuntimeConditionsArtifact] - validated_artifacts: list[ValidatedArtifact] - sdk_mappings: list[SDKMappingArtifact] = field(default_factory=list) - sdk_extensions: list[SDKExtensionArtifact] = field(default_factory=list) - sdk_diagnostics: list[Diagnostic] = field(default_factory=list) - - @property - def diagnostics(self) -> list[Diagnostic]: - return [diagnostic for artifact in self.validated_artifacts for diagnostic in artifact.diagnostics] + self.sdk_diagnostics - - @property - def has_errors(self) -> bool: - return any(diagnostic.severity == "error" for diagnostic in self.diagnostics) - - def to_json(self) -> dict[str, Any]: - return { - "project": str(self.project_root), - "projectType": self.project_type, - "packagePaths": [str(path) for path in self.package_paths], - "artifacts": [ - { - "kind": artifact.kind, - "manifest": artifact.manifest_uri, - "extension": artifact.extension_uri, - "origin": artifact.origin, - "manifestExtensionId": validated.manifest_extension_id, - "manifestExtensionVersion": validated.manifest_extension_version, - "extensionId": validated.extension_id, - "extensionVersion": validated.extension_version, - "extensionDefinition": validated.extension_definition_uri, - "dependencies": [{"id": ref[0], "version": ref[1]} for ref in validated.dependencies], - "pythonPackage": validated.manifest.package if validated.manifest else None, - "declarations": len(validated.manifest.declarations) if validated.manifest else 0, - "options": len(validated.manifest.options) if validated.manifest else 0, - "constants": len(validated.manifest.constants) if validated.manifest else 0, - } - for artifact, validated in zip(self.artifacts, self.validated_artifacts) - ], - "diagnostics": [ - { - "severity": diagnostic.severity, - "code": diagnostic.code, - "source": diagnostic.source, - "message": diagnostic.message, - } - for diagnostic in self.diagnostics - ], - "sdkMappings": [ - { - "distribution": artifact.distribution, - "distributionVersion": artifact.distribution_version, - "name": artifact.name, - "index": str(artifact.index_path), - "mapping": str(artifact.mapping_path), - "sha256": artifact.mapping_sha256, - } - for artifact in self.sdk_mappings - ], - "sdkExtensions": [ - { - "id": artifact.id, - "version": artifact.version, - "semanticSha256": artifact.semantic_sha256, - "path": str(artifact.path), - } - for artifact in self.sdk_extensions - ], - } - - -@dataclass(frozen=True) -class ProfileOptions: - name: str - workload_uri: str - workload_version: str - discovery_options: DiscoveryOptions - - -@dataclass(frozen=True) -class CallIdentity: - class_name: str - member_name: str diff --git a/runtimeconditions_profiler/profile/__init__.py b/runtimeconditions_profiler/profile/__init__.py index 93da306..a0b268e 100644 --- a/runtimeconditions_profiler/profile/__init__.py +++ b/runtimeconditions_profiler/profile/__init__.py @@ -1,6 +1,3 @@ -from .extractor import ProfileExtractor -from .validator import ProfileValidator from .writer import ProfileYamlWriter -__all__ = ["ProfileExtractor", "ProfileValidator", "ProfileYamlWriter"] - +__all__ = ["ProfileYamlWriter"] diff --git a/runtimeconditions_profiler/profile/binding.py b/runtimeconditions_profiler/profile/binding.py deleted file mode 100644 index 5b79b0b..0000000 --- a/runtimeconditions_profiler/profile/binding.py +++ /dev/null @@ -1,46 +0,0 @@ -from __future__ import annotations - -from dataclasses import dataclass -from typing import Any, Optional - -from ..manifest.mapping import all_mappings, class_matches -from ..models import ManifestModel, SymbolMapping, ValidatedArtifact -from ..util import as_map - - -@dataclass(frozen=True) -class BindingArtifact: - artifact: ValidatedArtifact - - @property - def manifest(self) -> ManifestModel: - assert self.artifact.manifest is not None - return self.artifact.manifest - - @property - def extension_id(self) -> tuple[str, str]: - assert self.artifact.extension_id is not None - return self.artifact.reference - - def all_mappings(self) -> list[SymbolMapping]: - return all_mappings(self.manifest) - - def find_declaration(self, class_name: str, member_name: str) -> Optional[SymbolMapping]: - for mapping in self.manifest.declarations: - if class_matches(class_name, mapping.class_name) and mapping.member_name == member_name: - return mapping - return None - - def find_root_option(self, class_name: str, member_name: str, condition: dict[str, Any]) -> Optional[SymbolMapping]: - kind = str(condition.get("kind", "")) - interface_type = str(as_map(condition.get("interface")).get("type", "")) - for option in self.manifest.options: - if not class_matches(class_name, option.class_name) or option.member_name != member_name: - continue - if option.applies_to_kinds and kind not in option.applies_to_kinds: - continue - if option.applies_to_interface_types and interface_type not in option.applies_to_interface_types: - continue - return option - return None - diff --git a/runtimeconditions_profiler/profile/extractor.py b/runtimeconditions_profiler/profile/extractor.py deleted file mode 100644 index 582ba58..0000000 --- a/runtimeconditions_profiler/profile/extractor.py +++ /dev/null @@ -1,431 +0,0 @@ -from __future__ import annotations - -import ast -from pathlib import Path -from typing import Any, Optional - -from ..constants import API_VERSION -from ..extension.identity import parse_identifier, profile_reference -from ..errors import RuntimeConditionsError -from ..manifest.mapping import find_option, simple_name, strip_package_class -from ..models import DiscoveryResult, ProfileOptions, SymbolMapping -from ..project import ProjectDiscovery -from ..sdk.direct import DirectSDKPythonExtractor -from ..source.python import PythonSourceIndex, expression_name, literal_string, workload_source_files -from ..util import add_extension_closure, add_unique, deep_copy, diagnostics_text -from .binding import BindingArtifact -from .imports import ImportIndex -from .validator import ProfileValidator - - -class ProfileExtractor: - def extract(self, project_root: Path, options: ProfileOptions) -> dict[str, Any]: - discovery = ProjectDiscovery().discover(project_root, options.discovery_options) - if discovery.has_errors: - raise RuntimeConditionsError("Runtime Conditions artifact validation failed: " + diagnostics_text(discovery.diagnostics)) - bindings = [ - BindingArtifact(artifact) - for artifact in discovery.validated_artifacts - if artifact.artifact.kind == "binding" and artifact.manifest is not None - ] - source_files = workload_source_files(discovery.project_root) - if not source_files: - raise RuntimeConditionsError(f"no Python source files found under {discovery.project_root}") - if bindings: - extractor = PythonExtractionScanner(bindings, discovery, options) - extractor.collect(source_files) - extractor.extract(source_files) - profile = extractor.profile() - else: - workload: dict[str, Any] = {} - if options.workload_uri: - workload["uri"] = options.workload_uri - if options.workload_version: - workload["version"] = options.workload_version - profile = {"apiVersion": API_VERSION, "kind": "RuntimeConditionsProfile", "metadata": {"name": options.name}, "workload": workload, "extensions": [], "conditions": []} - sdk_conditions: list[dict[str, Any]] = [] - sdk_extensions: list[tuple[str, str]] = [] - if discovery.sdk_mappings: - direct_conditions, direct_extensions = DirectSDKPythonExtractor( - discovery.sdk_mappings, discovery.sdk_extensions - ).extract(source_files, discovery.project_root) - sdk_conditions.extend(direct_conditions) - sdk_extensions.extend(direct_extensions) - for extension in sdk_extensions: - add_unique(profile["extensions"], profile_reference(extension)) - for condition in sdk_conditions: - if condition not in profile["conditions"]: - profile["conditions"].append(condition) - profile["extensions"].sort(key=parse_identifier) - profile_diagnostics = ProfileValidator().validate(profile, discovery) - if profile_diagnostics: - raise RuntimeConditionsError( - "generated Runtime Conditions Profile validation failed: " - + diagnostics_text(profile_diagnostics) - ) - return profile - - -class PythonExtractionScanner: - def __init__(self, bindings: list[BindingArtifact], discovery: DiscoveryResult, options: ProfileOptions) -> None: - self.bindings = bindings - self.discovery = discovery - self.options = options - self.binding_by_package: dict[str, BindingArtifact] = {} - self.binding_by_class: dict[str, BindingArtifact] = {} - for binding in bindings: - self.binding_by_package[binding.manifest.package] = binding - for mapping in binding.all_mappings(): - self.binding_by_class[mapping.class_name] = binding - self.binding_by_class[f"{binding.manifest.package}.{mapping.class_name}"] = binding - self.used_extensions: list[tuple[str, str]] = [] - self.conditions: list[dict[str, Any]] = [] - self.source_index = PythonSourceIndex() - - def collect(self, source_files: list[Path]) -> None: - self.source_index = PythonSourceIndex.from_paths(source_files) - - def extract(self, source_files: list[Path]) -> None: - for path in source_files: - tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path)) - imports = ImportIndex.from_module(tree, self.bindings) - for node in ast.walk(tree): - if not isinstance(node, ast.Call): - continue - identity = imports.call_identity(node.func) - if identity is None: - continue - binding = self.binding_for(identity.class_name) - if binding is None: - continue - declaration = binding.find_declaration(identity.class_name, identity.member_name) - if declaration is None: - continue - self.conditions.append(self.parse_condition(binding, declaration, node, imports)) - add_unique(self.used_extensions, binding.extension_id) - - def profile(self) -> dict[str, Any]: - workload: dict[str, Any] = {} - if self.options.workload_uri: - workload["uri"] = self.options.workload_uri - if self.options.workload_version: - workload["version"] = self.options.workload_version - return { - "apiVersion": API_VERSION, - "kind": "RuntimeConditionsProfile", - "metadata": {"name": self.options.name}, - "workload": workload, - "extensions": self.extension_closure(), - "conditions": self.conditions, - } - - def parse_condition( - self, - binding: BindingArtifact, - declaration: SymbolMapping, - call: ast.Call, - imports: ImportIndex, - ) -> dict[str, Any]: - if declaration.writes: - condition: dict[str, Any] = {} - self.apply_generic_writes(condition, binding, declaration, call, imports) - for argument in call.args: - if isinstance(argument, ast.Call): - self.apply_generic_option(condition, binding, declaration.options, argument, imports) - return condition - name = "" - if declaration.name_arg is not None: - name = self.string_arg(call.args, declaration.name_arg, declaration.member_name, "name", binding, imports) - condition: dict[str, Any] = { - "name": name, - "kind": declaration.kind, - "interface": {"type": declaration.interface_type or ""}, - } - for index, arg in enumerate(call.args): - if declaration.name_arg is not None and index == declaration.name_arg: - continue - if not isinstance(arg, ast.Call): - continue - match = self.condition_option_for_call(binding, declaration, condition, arg, imports) - if match is None: - continue - option_binding, option = match - self.apply_option(condition, option_binding, option, arg, imports) - add_unique(self.used_extensions, option_binding.extension_id) - remove_empty_configuration(condition) - return condition - - def apply_generic_option( - self, - condition: dict[str, Any], - binding: BindingArtifact, - options: list[SymbolMapping], - call: ast.Call, - imports: ImportIndex, - ) -> None: - identity = imports.call_identity(call.func) - if identity is None: - raise RuntimeConditionsError("generated binding option must be a directly imported call") - option = next( - ( - item - for item in options - if item.member_name == identity.member_name - and (identity.class_name == item.class_name or identity.class_name.endswith(f".{item.class_name}")) - ), - None, - ) - if option is None: - raise RuntimeConditionsError(f"{identity.class_name}.{identity.member_name} is not valid in this binding position") - self.apply_generic_writes(condition, binding, option, call, imports) - for argument in call.args: - if isinstance(argument, ast.Call): - self.apply_generic_option(condition, binding, option.options, argument, imports) - - def apply_generic_writes( - self, - condition: dict[str, Any], - binding: BindingArtifact, - mapping: SymbolMapping, - call: ast.Call, - imports: ImportIndex, - ) -> None: - for write in mapping.writes: - if "value" in write: - values = [deep_copy(write["value"])] - elif "values" in write and isinstance(write["values"], list): - values = [deep_copy(item) for item in write["values"]] - else: - argument = write.get("argument", {}) - position = argument.get("position") if isinstance(argument, dict) else None - if not isinstance(position, int) or position >= len(call.args): - raise RuntimeConditionsError(f"{mapping.member_name} requires argument {position}") - expression = call.args[position] - if isinstance(expression, ast.Constant): - values = [deep_copy(expression.value)] - else: - values = [self.binding_value(expression, binding, imports)] - for value in values: - self.write_generic_target(condition, write["target"], value) - - def write_generic_target(self, condition: dict[str, Any], target: str, value: Any) -> None: - current = condition - parts = target.split(".") - for part in parts[:-1]: - current = current.setdefault(part, {}) - leaf = parts[-1] - if leaf.endswith("[]"): - current.setdefault(leaf[:-2], []).append(value) - else: - current[leaf] = value - - def condition_option_for_call( - self, - declaration_binding: BindingArtifact, - declaration: SymbolMapping, - condition: dict[str, Any], - call: ast.Call, - imports: ImportIndex, - ) -> Optional[tuple[BindingArtifact, SymbolMapping]]: - identity = imports.call_identity(call.func) - if identity is None: - return None - binding = self.binding_for(identity.class_name) - if binding is None: - return None - if binding is declaration_binding: - option = find_option(declaration.options, identity.class_name, identity.member_name) - if option is not None: - return binding, option - option = binding.find_root_option(identity.class_name, identity.member_name, condition) - if option is None: - return None - return binding, option - - def apply_option( - self, - condition: dict[str, Any], - binding: BindingArtifact, - option: SymbolMapping, - call: ast.Call, - imports: ImportIndex, - ) -> None: - if option.target == "interface.spec": - spec = { - "format": self.string_arg(call.args, option.string_args.get("format"), option.member_name, "format", binding, imports), - "uri": self.string_arg(call.args, option.string_args.get("uri"), option.member_name, "uri", binding, imports), - } - version = self.string_arg(call.args, option.string_args.get("version"), option.member_name, "version", binding, imports) - if version: - spec["version"] = version - condition["interface"]["spec"] = spec - elif option.target == "interface.operations[]": - operation: dict[str, Any] = { - "method": option.method, - "path": self.string_arg(call.args, option.string_args.get("path"), option.member_name, "path", binding, imports), - } - for arg in call.args: - if not isinstance(arg, ast.Call): - continue - match = self.nested_option_for_call(binding, option.options, arg, imports) - if match is None: - continue - _, nested = match - if nested.class_arg is None or nested.class_arg >= len(arg.args): - raise RuntimeConditionsError(f"{nested.member_name} requires classArg in the binding manifest") - schema = self.schema_for_class_arg(arg.args[nested.class_arg], imports) - if nested.target == "requestBodySchema": - operation["requestBodySchema"] = schema - elif nested.target == "responseSchema": - operation["responseSchema"] = schema - else: - raise RuntimeConditionsError(f"unsupported operation option target {nested.target}") - condition["interface"].setdefault("operations", []).append(operation) - elif option.target == "interface.type": - condition["interface"]["type"] = option.value - if option.enum_arg is not None and option.enum_arg < len(call.args): - condition["interface"]["engine"] = self.binding_value(call.args[option.enum_arg], binding, imports) - elif option.target == "configuration.env[]": - configuration = condition.setdefault("configuration", {}) - if "alternatives" in configuration: - raise RuntimeConditionsError(f"{option.member_name} cannot be combined with configuration alternatives") - configuration.setdefault("env", []).append(self.env_input(binding, option, call, imports)) - elif option.target == "configuration.alternatives[]": - configuration = condition.setdefault("configuration", {}) - if "env" in configuration: - raise RuntimeConditionsError(f"{option.member_name} cannot be combined with configuration env") - env: list[dict[str, Any]] = [] - for arg in call.args: - if not isinstance(arg, ast.Call): - raise RuntimeConditionsError(f"{option.member_name} arguments must be nested env calls") - match = self.nested_option_for_call(binding, option.options, arg, imports) - if match is None: - raise RuntimeConditionsError(f"{option.member_name} arguments must match nested option calls") - nested_binding, nested = match - env.append(self.env_input(nested_binding, nested, arg, imports)) - configuration.setdefault("alternatives", []).append({"env": env}) - else: - raise RuntimeConditionsError(f"unsupported Python binding target {option.target}") - - def env_input( - self, - binding: BindingArtifact, - option: SymbolMapping, - call: ast.Call, - imports: ImportIndex, - ) -> dict[str, Any]: - env = { - "property": self.string_arg(call.args, option.string_args.get("property"), option.member_name, "property", binding, imports), - "name": self.string_arg(call.args, option.string_args.get("name"), option.member_name, "name", binding, imports), - } - for arg in call.args: - if not isinstance(arg, ast.Call): - continue - match = self.nested_option_for_call(binding, option.options, arg, imports) - if match is None: - continue - _, nested = match - value = nested.value.lower() == "true" - if nested.target == "env.sensitive": - if value: - env["sensitive"] = True - elif nested.target == "env.required": - env["required"] = value - else: - raise RuntimeConditionsError(f"unsupported env input option target {nested.target}") - return env - - def nested_option_for_call( - self, - expected_binding: BindingArtifact, - options: list[SymbolMapping], - call: ast.Call, - imports: ImportIndex, - ) -> Optional[tuple[BindingArtifact, SymbolMapping]]: - identity = imports.call_identity(call.func) - if identity is None: - return None - binding = self.binding_for(identity.class_name) - if binding is not expected_binding: - return None - option = find_option(options, identity.class_name, identity.member_name) - if option is None: - return None - return binding, option - - def binding_for(self, class_name: str) -> Optional[BindingArtifact]: - return self.binding_by_class.get(class_name) or self.binding_by_class.get(simple_name(class_name)) - - def string_arg( - self, - args: list[ast.expr], - index: Optional[int], - function: str, - name: str, - binding: BindingArtifact, - imports: ImportIndex, - ) -> str: - if index is None or index >= len(args): - raise RuntimeConditionsError(f"{function} requires {name} argument") - value = self.string_value(args[index], binding, imports) - if value is None: - raise RuntimeConditionsError(f"{function} {name} must be a string literal or string constant") - return value - - def string_value(self, expr: ast.expr, binding: BindingArtifact, imports: ImportIndex) -> Optional[str]: - value = literal_string(expr) - if value is not None: - return value - name = expression_name(expr) - if name is None: - return None - normalized = imports.normalize_name(name) - return ( - self.source_index.string_constants.get(normalized) - or self.source_index.string_constants.get(simple_name(normalized)) - or binding.manifest.constants.get(normalized) - or binding.manifest.constants.get(strip_package_class(normalized, binding.manifest.package)) - ) - - def binding_value(self, expr: ast.expr, binding: BindingArtifact, imports: ImportIndex) -> str: - value = self.string_value(expr, binding, imports) - if value is not None: - return value - name = expression_name(expr) - if name is not None: - normalized = imports.normalize_name(name) - value = binding.manifest.constants.get(normalized) or binding.manifest.constants.get( - strip_package_class(normalized, binding.manifest.package) - ) - if value is not None: - return value - raise RuntimeConditionsError("value must be a string literal, string constant, or binding constant") - - def schema_for_class_arg(self, expr: ast.expr, imports: ImportIndex) -> Any: - name = expression_name(expr) - if name is None: - raise RuntimeConditionsError("schema option requires a class/type argument") - normalized = imports.normalize_name(name) - schema = ( - self.source_index.schemas.get(normalized) - or self.source_index.schemas.get(simple_name(normalized)) - ) - if schema is None: - raise RuntimeConditionsError(f"unsupported schema class {normalized}") - return deep_copy(schema) - - def extension_closure(self) -> list[dict[str, str]]: - dependencies: dict[tuple[str, str], list[tuple[str, str]]] = {} - for artifact in self.discovery.validated_artifacts: - if artifact.extension_id: - dependencies[artifact.reference] = artifact.dependencies - resolved: set[tuple[str, str]] = set() - for extension in self.used_extensions: - add_extension_closure(extension, dependencies, resolved) - return [profile_reference(ref) for ref in sorted(resolved)] - - -def remove_empty_configuration(condition: dict[str, Any]) -> None: - configuration = condition.get("configuration") - if isinstance(configuration, dict) and not configuration: - condition.pop("configuration") diff --git a/runtimeconditions_profiler/profile/imports.py b/runtimeconditions_profiler/profile/imports.py deleted file mode 100644 index 206aa89..0000000 --- a/runtimeconditions_profiler/profile/imports.py +++ /dev/null @@ -1,79 +0,0 @@ -from __future__ import annotations - -import ast -from typing import Optional - -from ..models import CallIdentity -from ..source.python import expression_name -from .binding import BindingArtifact - - -class ImportIndex: - def __init__(self, bindings: list[BindingArtifact]) -> None: - self.bindings = bindings - self.package_aliases: dict[str, str] = {} - self.class_aliases: dict[str, str] = {} - self.wildcard_packages: set[str] = set() - - @staticmethod - def from_module(tree: ast.Module, bindings: list[BindingArtifact]) -> "ImportIndex": - index = ImportIndex(bindings) - packages = {binding.manifest.package for binding in bindings} - classes_by_package = { - binding.manifest.package: {mapping.class_name for mapping in binding.all_mappings()} - for binding in bindings - } - functions_by_package = { - binding.manifest.package: { - mapping.member_name - for mapping in binding.all_mappings() - if mapping.class_name == binding.manifest.package - } - for binding in bindings - } - for node in tree.body: - if isinstance(node, ast.Import): - for alias in node.names: - if alias.name in packages: - index.package_aliases[alias.asname or alias.name] = alias.name - if isinstance(node, ast.ImportFrom) and node.module: - if node.module not in packages: - continue - for alias in node.names: - if alias.name == "*": - index.wildcard_packages.add(node.module) - for class_name in classes_by_package[node.module]: - index.class_aliases[class_name] = f"{node.module}.{class_name}" - for function_name in functions_by_package[node.module]: - index.class_aliases[function_name] = f"{node.module}.{function_name}" - continue - if alias.name in classes_by_package[node.module]: - index.class_aliases[alias.asname or alias.name] = f"{node.module}.{alias.name}" - if alias.name in functions_by_package[node.module]: - index.class_aliases[alias.asname or alias.name] = f"{node.module}.{alias.name}" - return index - - def call_identity(self, expr: ast.expr) -> Optional[CallIdentity]: - name = expression_name(expr) - if not name: - return None - normalized = self.normalize_name(name) - if "." not in normalized: - return None - parts = normalized.split(".") - if len(parts) < 2: - return None - member = parts[-1] - class_name = ".".join(parts[:-1]) - return CallIdentity(class_name=class_name, member_name=member) - - def normalize_name(self, name: str) -> str: - parts = name.split(".") - if not parts: - return name - first = parts[0] - if first in self.class_aliases: - return ".".join([self.class_aliases[first], *parts[1:]]) - if first in self.package_aliases: - return ".".join([self.package_aliases[first], *parts[1:]]) - return name diff --git a/runtimeconditions_profiler/profile/validator.py b/runtimeconditions_profiler/profile/validator.py deleted file mode 100644 index 860d182..0000000 --- a/runtimeconditions_profiler/profile/validator.py +++ /dev/null @@ -1,182 +0,0 @@ -from __future__ import annotations - -from typing import Any - -from ..constants import API_VERSION -from ..extension.identity import expand_identifier, parse_identifier -from ..extension import ExtensionVocabulary -from ..models import Diagnostic, DiscoveryResult -from ..util import add_extension_closure, as_map - - -class ProfileValidator: - def validate(self, profile: dict[str, Any], discovery: DiscoveryResult) -> list[Diagnostic]: - diagnostics: list[Diagnostic] = [] - add = lambda msg: diagnostics.append(Diagnostic("error", "profile-validation", "profile", msg)) - if profile.get("apiVersion") != API_VERSION: - add(f"apiVersion must be {API_VERSION}") - if profile.get("kind") != "RuntimeConditionsProfile": - add("kind must be RuntimeConditionsProfile") - try: - extensions = [parse_identifier(ref) for ref in profile.get("extensions", [])] - except Exception as exc: - add(str(exc)) - extensions = [] - conditions = profile.get("conditions") if isinstance(profile.get("conditions"), list) else [] - if not extensions and conditions: - add("extensions must declare the extension dependency closure used by conditions") - - definitions = { - artifact.reference: artifact.extension_definition - for artifact in discovery.validated_artifacts - if artifact.extension_id and artifact.extension_definition - } - definitions.update({(artifact.id, artifact.version): artifact.definition for artifact in discovery.sdk_extensions}) - # A profile may name an extension by its short : reference. - extensions = [ - (expand_identifier(*ref), ref[1]) if ref not in definitions and (expand_identifier(*ref), ref[1]) in definitions else ref - for ref in extensions - ] - declared: set[tuple[str, str]] = set() - for extension in extensions: - if extension in declared: - add(f"duplicate extension id {extension}") - declared.add(extension) - if extension not in definitions: - add(f"missing extension definition for {extension}") - closure: set[tuple[str, str]] = set() - for extension in extensions: - add_extension_closure(extension, {key: value.dependencies for key, value in definitions.items()}, closure) - for extension in closure: - if extension not in declared: - add(f"extensions missing dependency {extension}") - vocabulary = ExtensionVocabulary([definitions[item] for item in closure if item in definitions]) - for key, count in vocabulary.counts().items(): - if count > 1: - add(f"resolved extension set contains vocabulary conflict for {key}") - for conflict in vocabulary.condition_field_conflicts(): - add(f"resolved extension set contains vocabulary conflict for {conflict}") - for index, condition in enumerate(conditions): - if isinstance(condition, dict): - validate_condition(index, vocabulary, condition, add) - else: - add(f"conditions[{index}] must be a mapping") - return diagnostics - - -def validate_condition( - index: int, - vocabulary: ExtensionVocabulary, - condition: dict[str, Any], - add: Any, -) -> None: - prefix = f"conditions[{index}]" - kind = str(condition.get("kind", "")) - interface = as_map(condition.get("interface")) - interface_type = str(interface.get("type", "")) - expect_profile_count(vocabulary.kind_count(kind), f"{prefix}.kind {kind}", add) - expect_profile_count( - vocabulary.interface_type_count(kind, interface_type), - f"{prefix}.interface.type {kind}/{interface_type}", - add, - ) - if "spec" in interface: - expect_profile_count( - vocabulary.interface_field_count(kind, interface_type, "spec"), - f"{prefix}.interface.spec for {kind}/{interface_type}", - add, - ) - spec = as_map(interface.get("spec")) - fmt = str(spec.get("format", "")) - expect_profile_count( - vocabulary.field_value_count("interface.spec.format", kind, interface_type, fmt), - f"{prefix}.interface.spec.format {fmt} for {kind}/{interface_type}", - add, - ) - operations = interface.get("operations") - if isinstance(operations, list) and operations: - expect_profile_count( - vocabulary.interface_field_count(kind, interface_type, "operations"), - f"{prefix}.interface.operations for {kind}/{interface_type}", - add, - ) - for op_index, operation in enumerate(operations): - if isinstance(operation, str): - # An operation named with a plain string, such as the smtp interface's "send". - expect_profile_count( - vocabulary.field_value_count("interface.operations[]", kind, interface_type, operation), - f"{prefix}.interface.operations[{op_index}] {operation} for {kind}/{interface_type}", - add, - ) - continue - if not isinstance(operation, dict): - continue - for field, value in operation.items(): - field_name = f"interface.operations[].{field}" - if vocabulary.field_value_definition_count(field_name, kind, interface_type): - expect_profile_count( - vocabulary.field_value_count(field_name, kind, interface_type, str(value)), - f"{prefix}.interface.operations[{op_index}].{field} {value} for {kind}/{interface_type}", - add, - ) - engine = str(interface.get("engine", "")) - if engine: - expect_profile_count( - vocabulary.interface_field_count(kind, interface_type, "engine"), - f"{prefix}.interface.engine for {kind}/{interface_type}", - add, - ) - expect_profile_count( - vocabulary.field_value_count("interface.engine", kind, interface_type, engine), - f"{prefix}.interface.engine {engine} for {kind}/{interface_type}", - add, - ) - for field in interface: - if field in {"type", "spec", "operations", "engine"}: - continue - expect_profile_count( - vocabulary.interface_field_count(kind, interface_type, field), - f"{prefix}.interface.{field} for {kind}/{interface_type}", - add, - ) - if "configuration" in condition: - expect_profile_count( - vocabulary.condition_field_count(kind, interface_type, "configuration"), - f"{prefix}.configuration for {kind}/{interface_type}", - add, - ) - configuration = as_map(condition.get("configuration")) - for env_index, env in enumerate(configuration.get("env", []) if isinstance(configuration.get("env"), list) else []): - if isinstance(env, dict): - prop = str(env.get("property", "")) - expect_profile_count( - vocabulary.field_value_count("configuration.env[].property", kind, interface_type, prop), - f"{prefix}.configuration.env[{env_index}].property {prop} for {kind}/{interface_type}", - add, - ) - alternatives = configuration.get("alternatives", []) - if isinstance(alternatives, list): - for alt_index, alternative in enumerate(alternatives): - if not isinstance(alternative, dict): - continue - env_items = alternative.get("env", []) - if not isinstance(env_items, list): - continue - for env_index, env in enumerate(env_items): - if isinstance(env, dict): - prop = str(env.get("property", "")) - expect_profile_count( - vocabulary.field_value_count( - "configuration.alternatives[].env[].property", - kind, - interface_type, - prop, - ), - f"{prefix}.configuration.alternatives[{alt_index}].env[{env_index}].property {prop} for {kind}/{interface_type}", - add, - ) - - -def expect_profile_count(count: int, message: str, add: Any) -> None: - if count != 1: - add(f"{message}: expected exactly one definition, got {count}") diff --git a/runtimeconditions_profiler/project/__init__.py b/runtimeconditions_profiler/project/__init__.py index 7a4dedd..a642393 100644 --- a/runtimeconditions_profiler/project/__init__.py +++ b/runtimeconditions_profiler/project/__init__.py @@ -1,9 +1,3 @@ -from .discovery import ArtifactDiscovery, ProjectDiscovery from .installed import InstalledBindingDiscovery, InstalledBindingDiscoveryResult -__all__ = [ - "ArtifactDiscovery", - "InstalledBindingDiscovery", - "InstalledBindingDiscoveryResult", - "ProjectDiscovery", -] +__all__ = ["InstalledBindingDiscovery", "InstalledBindingDiscoveryResult"] diff --git a/runtimeconditions_profiler/project/discovery.py b/runtimeconditions_profiler/project/discovery.py deleted file mode 100644 index 9089d12..0000000 --- a/runtimeconditions_profiler/project/discovery.py +++ /dev/null @@ -1,170 +0,0 @@ -from __future__ import annotations - -import re -import tomllib -from pathlib import Path -from typing import Optional - -from ..constants import BINDINGS_MANIFEST, EXTENSION_DEFINITION, PACKAGE_MANIFEST -from ..extension import ArtifactValidator -from ..models import DiscoveryOptions, DiscoveryResult, RuntimeConditionsArtifact -from ..sdk.direct import load_explicit_sdk_artifacts -from ..util import as_map, dedupe_artifacts, dedupe_paths, ignored_path, scalar -from ..yamlio import Yaml - - -class ArtifactDiscovery: - def discover_project_artifacts(self, project_root: Path) -> list[RuntimeConditionsArtifact]: - root = project_root.absolute().resolve() - candidates = [root] - src = root / "src" - if src.is_dir(): - candidates.append(src) - artifacts: list[RuntimeConditionsArtifact] = [] - seen: set[Path] = set() - for candidate in candidates: - for artifact in self._discover_directory_tree(candidate, f"project:{root}"): - if artifact.source_path and artifact.source_path in seen: - continue - if artifact.source_path: - seen.add(artifact.source_path) - artifacts.append(artifact) - return artifacts - - def discover_path_artifact(self, package_path: Path) -> list[RuntimeConditionsArtifact]: - root = package_path.absolute().resolve() - return self._discover_directory_tree(root, f"package:{root}") - - def discover_artifacts_under(self, root: Path) -> list[RuntimeConditionsArtifact]: - resolved = root.absolute().resolve() - if not resolved.is_dir(): - return [] - artifacts: list[RuntimeConditionsArtifact] = [] - for manifest in sorted(resolved.rglob("*")): - if manifest.name not in (BINDINGS_MANIFEST, PACKAGE_MANIFEST): - continue - if ignored_path(manifest): - continue - artifacts.extend(self._discover_manifest_dir(manifest.parent, f"root:{resolved}")) - return dedupe_artifacts(artifacts) - - def _discover_directory_tree(self, root: Path, origin: str) -> list[RuntimeConditionsArtifact]: - if not root.is_dir(): - return [] - artifacts: list[RuntimeConditionsArtifact] = [] - for manifest in sorted(root.rglob("*")): - if manifest.name not in (BINDINGS_MANIFEST, PACKAGE_MANIFEST): - continue - if ignored_path(manifest): - continue - artifacts.extend(self._discover_manifest_dir(manifest.parent, origin)) - return dedupe_artifacts(artifacts) - - def _discover_manifest_dir(self, directory: Path, origin: str) -> list[RuntimeConditionsArtifact]: - extension = directory / EXTENSION_DEFINITION - artifacts: list[RuntimeConditionsArtifact] = [] - for filename, kind in ((BINDINGS_MANIFEST, "binding"), (PACKAGE_MANIFEST, "package")): - manifest = directory / filename - if not manifest.is_file(): - continue - artifacts.append( - RuntimeConditionsArtifact( - kind=kind, - manifest_uri=manifest.absolute().resolve().as_uri(), - extension_uri=extension.absolute().resolve().as_uri() if extension.is_file() else None, - origin=origin, - source_path=manifest.absolute().resolve(), - root=directory.absolute().resolve(), - language=manifest_language(manifest), - ) - ) - return artifacts - - -class ProjectDiscovery: - def discover(self, project_root: Path, options: DiscoveryOptions) -> DiscoveryResult: - root = project_root.absolute().resolve() - project_type = detect_project_type(root) - package_paths = [path.absolute().resolve() for path in options.package_paths] - if options.resolve_package_paths: - package_paths.extend(resolve_pyproject_package_paths(root)) - package_paths = dedupe_paths(package_paths) - - discovery = ArtifactDiscovery() - artifacts = discovery.discover_project_artifacts(root) - for package_path in package_paths: - artifacts.extend(discovery.discover_path_artifact(package_path)) - artifacts = dedupe_artifacts(artifacts) - validated = ArtifactValidator().validate(artifacts) - sdk_mappings, sdk_extensions, sdk_diagnostics = load_explicit_sdk_artifacts( - options.mapping_paths, options.extension_paths - ) - return DiscoveryResult(root, project_type, package_paths, artifacts, validated, sdk_mappings, sdk_extensions, sdk_diagnostics) - - -def resolve_pyproject_package_paths(root: Path) -> list[Path]: - pyproject = root / "pyproject.toml" - if not pyproject.is_file(): - return [] - data = tomllib.loads(pyproject.read_text(encoding="utf-8")) - paths: list[Path] = [] - project = data.get("project", {}) - if isinstance(project, dict): - for dependency in project.get("dependencies", []) or []: - if isinstance(dependency, str): - parsed = path_from_dependency(dependency, root) - if parsed is not None: - paths.append(parsed) - tool = data.get("tool", {}) - if isinstance(tool, dict): - runtimeconditions = tool.get("runtimeconditions", {}) - if isinstance(runtimeconditions, dict): - for value in runtimeconditions.get("package-paths", []) or []: - if isinstance(value, str): - paths.append((root / value).resolve()) - uv = tool.get("uv", {}) - if isinstance(uv, dict): - sources = uv.get("sources", {}) - if isinstance(sources, dict): - for source in sources.values(): - if isinstance(source, dict) and isinstance(source.get("path"), str): - paths.append((root / source["path"]).resolve()) - workspace = uv.get("workspace", {}) - if isinstance(workspace, dict): - for member in workspace.get("members", []) or []: - if isinstance(member, str): - paths.append((root / member).resolve()) - poetry = tool.get("poetry", {}) - if isinstance(poetry, dict): - dependencies = poetry.get("dependencies", {}) - if isinstance(dependencies, dict): - for dependency in dependencies.values(): - if isinstance(dependency, dict) and isinstance(dependency.get("path"), str): - paths.append((root / dependency["path"]).resolve()) - return dedupe_paths(paths) - - -def path_from_dependency(dependency: str, root: Path) -> Optional[Path]: - match = re.search(r"@\s*file://([^ ;]+)", dependency) - if match: - return Path(match.group(1)).resolve() - match = re.search(r"@\s*(\.\.?/[^ ;]+)", dependency) - if match: - return (root / match.group(1)).resolve() - return None - - -def detect_project_type(root: Path) -> str: - if (root / "pyproject.toml").is_file(): - return "pyproject" - if (root / "setup.py").is_file(): - return "setuptools" - return "source_only" - - -def manifest_language(path: Path) -> str: - try: - data = Yaml.load(path) - except Exception: - return "" - return scalar(as_map(data.get("metadata")).get("language")) or "" diff --git a/runtimeconditions_profiler/sdk/__init__.py b/runtimeconditions_profiler/sdk/__init__.py deleted file mode 100644 index 5dfe03a..0000000 --- a/runtimeconditions_profiler/sdk/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -from .direct import DirectSDKPythonExtractor, load_explicit_sdk_artifacts -from .resolver import bundle_artifact_paths, resolve_mappings - -__all__ = [ - "DirectSDKPythonExtractor", - "bundle_artifact_paths", - "load_explicit_sdk_artifacts", - "resolve_mappings", -] diff --git a/runtimeconditions_profiler/sdk/direct.py b/runtimeconditions_profiler/sdk/direct.py deleted file mode 100644 index a4d540e..0000000 --- a/runtimeconditions_profiler/sdk/direct.py +++ /dev/null @@ -1,525 +0,0 @@ -from __future__ import annotations - -import ast -import copy -import hashlib -import json -from dataclasses import dataclass -from pathlib import Path -from typing import Any - -from jsonschema import Draft202012Validator - -from ..constants import EXTENSION_KIND, SDK_MAPPING_API_VERSION, SDK_MAPPING_KIND -from ..errors import RuntimeConditionsError -from ..extension.identity import definition_identifier, parse_identifier -from ..extension.definition import parse_extension_definition -from ..models import Diagnostic, SDKExtensionArtifact, SDKMappingArtifact -from ..source.python import expression_name -from ..yamlio import Yaml - - -def _semantic_sha256(value: Any) -> str: - encoded = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode() - return hashlib.sha256(encoded).hexdigest() - - -def load_explicit_sdk_artifacts( - mapping_paths: list[Path], extension_paths: list[Path] -) -> tuple[list[SDKMappingArtifact], list[SDKExtensionArtifact], list[Diagnostic]]: - mappings: list[SDKMappingArtifact] = [] - extensions: list[SDKExtensionArtifact] = [] - diagnostics: list[Diagnostic] = [] - for raw_path in mapping_paths: - path = raw_path.absolute().resolve() - try: - document = Yaml.load(path) - _validate_mapping_shape(document, path) - sdk = document["sdk"] - metadata = document["metadata"] - mappings.append( - SDKMappingArtifact( - distribution=sdk["package"], - distribution_version="", - name=metadata["name"], - index_path=path, - mapping_path=path, - mapping_sha256=hashlib.sha256(path.read_bytes()).hexdigest(), - mapping=document, - ) - ) - except Exception as exc: - diagnostics.append(Diagnostic("error", "sdk-mapping", str(path), str(exc))) - for raw_path in extension_paths: - path = raw_path.absolute().resolve() - try: - document = Yaml.load(path) - if document.get("kind") != EXTENSION_KIND: - raise RuntimeConditionsError(f"expected {EXTENSION_KIND}") - metadata = document.get("metadata", {}) - extension_id = definition_identifier(metadata) - version = metadata.get("version", "") - digest = metadata.get("semanticSha256") - if not isinstance(version, str) or ("version" in metadata and not version): - raise RuntimeConditionsError("extension metadata version, when present, must be a non-empty string") - if digest is not None and (not isinstance(digest, str) or not digest): - raise RuntimeConditionsError("extension metadata semanticSha256, when present, must be a non-empty string") - if not version and not digest: - raise RuntimeConditionsError("extension metadata requires either version or semanticSha256") - actual = _semantic_sha256(document.get("spec", {})) - if digest is not None and actual != digest: - raise RuntimeConditionsError(f"extension semantic digest is {actual}, not {digest}") - extensions.append( - SDKExtensionArtifact( - id=extension_id, - version=version, - semantic_sha256=actual, - path=path, - definition=parse_extension_definition(document, extension_id, path.as_uri()), - document=document, - ) - ) - except Exception as exc: - diagnostics.append(Diagnostic("error", "sdk-extension", str(path), str(exc))) - extension_ids = {(item.id, item.version) for item in extensions} - for mapping in mappings: - extension_id = parse_identifier(mapping.mapping["extension"]) - if extension_id not in extension_ids: - diagnostics.append( - Diagnostic( - "error", - "sdk-mapping", - str(mapping.mapping_path), - f"selected extension {extension_id} was not supplied explicitly", - ) - ) - return mappings, extensions, diagnostics - - -def _validate_mapping_shape(document: dict[str, Any], path: Path) -> None: - if document.get("apiVersion") != SDK_MAPPING_API_VERSION or document.get("kind") != SDK_MAPPING_KIND: - raise RuntimeConditionsError(f"{path}: unsupported SDK mapping contract") - metadata = document.get("metadata") - sdk = document.get("sdk") - extension = document.get("extension") - rules = document.get("rules") - if not isinstance(metadata, dict) or not all(isinstance(metadata.get(key), str) and metadata[key] for key in ("name", "version")): - raise RuntimeConditionsError("mapping metadata requires name and version") - if not isinstance(sdk, dict) or sdk.get("language") != "python" or not all(isinstance(sdk.get(key), str) and sdk[key] for key in ("ecosystem", "package")): - raise RuntimeConditionsError("mapping requires a Python SDK ecosystem and package") - parse_identifier(extension) - if not isinstance(rules, list) or not rules: - raise RuntimeConditionsError("mapping requires at least one rule") - rule_ids: set[str] = set() - surfaces: set[str] = set() - for rule in rules: - if not isinstance(rule, dict) or not isinstance(rule.get("id"), str): - raise RuntimeConditionsError("every mapping rule requires an id") - if rule["id"] in rule_ids: - raise RuntimeConditionsError(f"duplicate mapping rule {rule['id']}") - rule_ids.add(rule["id"]) - match = rule.get("match", {}) - if not isinstance(match, dict) or ("call" in match) == ("method" in match): - raise RuntimeConditionsError(f"{rule['id']}: match must contain exactly one call or method") - produced = rule.get("produces") - condition = rule.get("condition") - if (produced is None) == (condition is None): - raise RuntimeConditionsError(f"{rule['id']}: rule must produce a surface or a Condition") - if produced is not None: - if not isinstance(produced, dict) or not isinstance(produced.get("surface"), str): - raise RuntimeConditionsError(f"{rule['id']}: produced surface is required") - surfaces.add(produced["surface"]) - if "method" in match: - method = match["method"] - if not isinstance(method, dict) or method.get("receiverSurface") not in surfaces or not isinstance(method.get("name"), str): - raise RuntimeConditionsError(f"{rule['id']}: method must reference an earlier produced surface") - if condition is not None and (not isinstance(condition, dict) or not isinstance(condition.get("writes"), list) or not condition["writes"]): - raise RuntimeConditionsError(f"{rule['id']}: Condition writes are required") - - -@dataclass(frozen=True) -class Evidence: - key: str - value: Any = None - static: bool = False - - -@dataclass(frozen=True) -class Surface: - name: str - identity: Evidence | None = None - - -@dataclass(frozen=True) -class External: - symbol: str - - -UNKNOWN = Evidence("unknown") - - -@dataclass -class ConditionResult: - extension_id: tuple[str, str] - identity: str - document: dict[str, Any] - - -class DirectSDKPythonExtractor: - def __init__(self, mappings: list[SDKMappingArtifact], extensions: list[SDKExtensionArtifact]) -> None: - self.mappings = [item for item in mappings if isinstance(item.mapping.get("sdk"), dict)] - self.extensions = {(item.id, item.version): item for item in extensions} - self.call_rules: list[tuple[SDKMappingArtifact, dict[str, Any]]] = [] - self.method_rules: dict[tuple[str, str], tuple[SDKMappingArtifact, dict[str, Any]]] = {} - for artifact in self.mappings: - extension_id = parse_identifier(artifact.mapping["extension"]) - extension = self.extensions.get(extension_id) - if extension is None: - raise RuntimeConditionsError(f"{artifact.name}: extension {extension_id} is unavailable") - self._validate_writes(artifact, extension) - for rule in artifact.mapping["rules"]: - match = rule["match"] - if "call" in match: - self.call_rules.append((artifact, rule)) - else: - method = match["method"] - key = (method["receiverSurface"], method["name"]) - if key in self.method_rules: - raise RuntimeConditionsError(f"ambiguous SDK method rule for {key[0]}.{key[1]}") - self.method_rules[key] = (artifact, rule) - - def extract(self, source_files: list[Path], project_root: Path) -> tuple[list[dict[str, Any]], list[tuple[str, str]]]: - results: list[ConditionResult] = [] - for source in source_files: - tree = ast.parse(source.read_text(encoding="utf-8"), filename=str(source)) - interpreter = _PythonMappingInterpreter(self, source, tree) - results.extend(interpreter.run()) - grouped: dict[tuple[str, str, str, str], dict[str, Any]] = {} - for result in results: - interface = result.document.get("interface", {}) - key = ( - result.extension_id, - str(result.document.get("kind")), - str(interface.get("type")), - result.identity, - ) - existing = grouped.get(key) - if existing is None: - grouped[key] = copy.deepcopy(result.document) - else: - _merge_condition(existing, result.document) - for (extension_id, _, _, _), condition in grouped.items(): - self._validate_materialized(self.extensions[extension_id], condition) - extension_ids = sorted({key[0] for key in grouped}) - return list(grouped.values()), extension_ids - - def evaluate_call_rule(self, symbol: str, call: ast.Call, scope: str, values: dict[str, Any]) -> Surface | None: - candidates: list[tuple[SDKMappingArtifact, dict[str, Any]]] = [] - for artifact, rule in self.call_rules: - call_match = rule["match"]["call"] - if symbol not in call_match.get("symbols", []): - continue - if all(_selector_matches(call, selector, scope, values) for selector in call_match.get("arguments", {}).values()): - candidates.append((artifact, rule)) - if len(candidates) > 1: - raise RuntimeConditionsError(f"ambiguous SDK call rule for {symbol}") - if not candidates: - return None - produced = candidates[0][1]["produces"] - identity = _resolve_identity(produced.get("identity"), call, None, scope, values) - return Surface(produced["surface"], identity) - - def evaluate_method( - self, - receiver: Surface, - name: str, - call: ast.Call, - scope: str, - values: dict[str, Any], - location: str, - ) -> tuple[Surface | Evidence, list[ConditionResult]]: - match = self.method_rules.get((receiver.name, name)) - if match is None: - return UNKNOWN, [] - artifact, rule = match - produced = rule.get("produces") - if produced is not None: - identity = _resolve_identity(produced.get("identity"), call, receiver, scope, values) - return Surface(produced["surface"], identity), [] - condition = rule["condition"] - identity = _resolve_identity(condition.get("identity"), call, receiver, scope, values) - document: dict[str, Any] = {} - for write in condition["writes"]: - written = self._write_value(write, call, receiver, scope, values) - if written is None: - continue - if "values" in write: - for value in written: - _write_target(document, write["target"], value) - else: - _write_target(document, write["target"], written) - result_identity = identity.key if identity is not None else location - return UNKNOWN, [ConditionResult(parse_identifier(artifact.mapping["extension"]), result_identity, document)] - - def _write_value( - self, - write: dict[str, Any], - call: ast.Call, - receiver: Surface, - scope: str, - values: dict[str, Any], - ) -> Any: - if "value" in write: - return copy.deepcopy(write["value"]) - if "values" in write: - return copy.deepcopy(write["values"]) - if "argument" in write: - evidence = _argument_evidence(call, write["argument"], scope, values) - elif write.get("receiverIdentity") is True: - evidence = receiver.identity or UNKNOWN - else: - raise RuntimeConditionsError(f"unsupported write instruction {write}") - if not evidence.static: - if write.get("whenStaticallyKnown") is True: - return None - raise RuntimeConditionsError(f"write target {write.get('target')} requires a statically known value") - return copy.deepcopy(evidence.value) - - def _validate_writes(self, artifact: SDKMappingArtifact, extension: SDKExtensionArtifact) -> None: - definition = extension.definition - fields = set(definition.interface_fields) - values = { - (field, kind, interface_type): set(allowed) - for field, kind, interface_type, allowed in definition.field_values - } - for rule in artifact.mapping["rules"]: - condition = rule.get("condition") - if not condition: - continue - constants: dict[str, Any] = {} - for write in condition["writes"]: - if "value" in write: - _write_target(constants, write["target"], copy.deepcopy(write["value"])) - for value in write.get("values", []): - _write_target(constants, write["target"], copy.deepcopy(value)) - kind = constants.get("kind") - interface_type = constants.get("interface", {}).get("type") - if kind not in definition.kinds or (kind, interface_type) not in definition.interface_types: - raise RuntimeConditionsError(f"{rule['id']}: writes do not select extension-defined kind and interface type") - for write in condition["writes"]: - target = write["target"] - if target.startswith("interface.") and target != "interface.type": - field = target.split(".")[1].removesuffix("[]") - if (kind, interface_type, field) not in fields: - raise RuntimeConditionsError(f"{rule['id']}: target {target} is not extension vocabulary") - candidates = write.get("values", [write.get("value")]) - for candidate in candidates: - if not isinstance(candidate, dict): - continue - for child, child_value in candidate.items(): - allowed = values.get((f"{target}.{child}", kind, interface_type)) - if allowed is not None and str(child_value) not in allowed: - raise RuntimeConditionsError(f"{rule['id']}: value {child_value} is not allowed at {target}.{child}") - - def _validate_materialized(self, extension: SDKExtensionArtifact, condition: dict[str, Any]) -> None: - kind = condition.get("kind") - interface_type = condition.get("interface", {}).get("type") - matches = [ - item.get("schema") - for item in extension.document.get("spec", {}).get("schemas", []) - if isinstance(item, dict) - and item.get("appliesToKind") == kind - and item.get("appliesToInterfaceType") == interface_type - ] - if len(matches) != 1 or not isinstance(matches[0], dict): - raise RuntimeConditionsError(f"extension {extension.id} has no unique schema for {kind}/{interface_type}") - errors = list(Draft202012Validator(matches[0]).iter_errors(condition)) - if errors: - raise RuntimeConditionsError(f"mapped Condition violates extension {extension.id}: {errors[0].message}") - - -class _PythonMappingInterpreter: - def __init__(self, extractor: DirectSDKPythonExtractor, source: Path, tree: ast.Module) -> None: - self.extractor = extractor - self.source = source - self.tree = tree - self.aliases: dict[str, str] = {} - self.globals: dict[str, Any] = {} - self.results: list[ConditionResult] = [] - - def run(self) -> list[ConditionResult]: - for statement in self.tree.body: - if isinstance(statement, (ast.Import, ast.ImportFrom)): - self._import(statement) - elif isinstance(statement, (ast.Assign, ast.AnnAssign)): - self._assign(statement, self.globals, "module") - for statement in self.tree.body: - if isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef)): - scope = f"{self.source}:{statement.name}" - values = dict(self.globals) - for argument in [*statement.args.posonlyargs, *statement.args.args, *statement.args.kwonlyargs]: - values[argument.arg] = Evidence(f"{scope}:parameter:{argument.arg}") - for child in statement.body: - self._statement(child, values, scope) - elif not isinstance(statement, (ast.Import, ast.ImportFrom, ast.Assign, ast.AnnAssign, ast.ClassDef)): - self._statement(statement, self.globals, "module") - return self.results - - def _import(self, statement: ast.Import | ast.ImportFrom) -> None: - if isinstance(statement, ast.Import): - for alias in statement.names: - self.aliases[alias.asname or alias.name.split(".")[0]] = alias.name - elif statement.module: - for alias in statement.names: - if alias.name != "*": - self.aliases[alias.asname or alias.name] = f"{statement.module}.{alias.name}" - - def _statement(self, statement: ast.stmt, values: dict[str, Any], scope: str) -> None: - if isinstance(statement, (ast.Assign, ast.AnnAssign)): - self._assign(statement, values, scope) - return - if isinstance(statement, ast.Expr): - self._evaluate(statement.value, values, scope) - return - if isinstance(statement, ast.Return) and statement.value is not None: - self._evaluate(statement.value, values, scope) - return - for field in ("body", "orelse", "finalbody"): - children = getattr(statement, field, None) - if isinstance(children, list): - branch = dict(values) - for child in children: - if isinstance(child, ast.stmt): - self._statement(child, branch, scope) - - def _assign(self, statement: ast.Assign | ast.AnnAssign, values: dict[str, Any], scope: str) -> None: - expression = statement.value - if expression is None: - return - value = self._evaluate(expression, values, scope) - targets = statement.targets if isinstance(statement, ast.Assign) else [statement.target] - for target in targets: - if isinstance(target, ast.Name): - values[target.id] = value - - def _evaluate(self, expression: ast.expr, values: dict[str, Any], scope: str) -> Any: - if isinstance(expression, ast.Await): - return self._evaluate(expression.value, values, scope) - if isinstance(expression, ast.Constant): - return Evidence(f"literal:{expression.value!r}", expression.value, True) - if isinstance(expression, ast.Name): - return values.get(expression.id, Evidence(f"{scope}:name:{expression.id}")) - if not isinstance(expression, ast.Call): - return Evidence(f"{scope}:expression:{ast.dump(expression, include_attributes=False)}") - for argument in expression.args: - self._evaluate(argument, values, scope) - for keyword in expression.keywords: - self._evaluate(keyword.value, values, scope) - location = f"{self.source}:{getattr(expression, 'lineno', 0)}:{getattr(expression, 'col_offset', 0)}" - if isinstance(expression.func, ast.Attribute): - receiver = self._evaluate(expression.func.value, values, scope) - if isinstance(receiver, Surface): - value, results = self.extractor.evaluate_method( - receiver, expression.func.attr, expression, scope, values, location - ) - self.results.extend(results) - return value - symbol = self._callable_symbol(expression.func, values, scope) - if symbol: - produced = self.extractor.evaluate_call_rule(symbol, expression, scope, values) - if produced is not None: - return produced - return External(symbol) - return UNKNOWN - - def _callable_symbol(self, expression: ast.expr, values: dict[str, Any], scope: str) -> str | None: - if isinstance(expression, ast.Attribute) and isinstance(expression.value, ast.Name): - receiver = values.get(expression.value.id) - if isinstance(receiver, External): - return f"{receiver.symbol}.{expression.attr}" - name = expression_name(expression) - if name: - parts = name.split(".") - replacement = self.aliases.get(parts[0]) - return ".".join([replacement, *parts[1:]]) if replacement else name - if isinstance(expression, ast.Attribute) and isinstance(expression.value, ast.Call): - constructor = self._callable_symbol(expression.value.func, values, scope) - if constructor: - return f"{constructor}.{expression.attr}" - return None - - -def _binding_expression(call: ast.Call, binding: dict[str, Any]) -> ast.expr | None: - keyword = binding.get("keyword") - if isinstance(keyword, str): - for item in call.keywords: - if item.arg == keyword: - return item.value - position = binding.get("position") - if isinstance(position, int) and position < len(call.args): - return call.args[position] - return None - - -def _evidence(expression: ast.expr | None, scope: str, values: dict[str, Any]) -> Evidence: - if expression is None: - return Evidence(f"{scope}:missing") - if isinstance(expression, ast.Constant): - return Evidence(f"literal:{expression.value!r}", expression.value, True) - if isinstance(expression, ast.Name): - value = values.get(expression.id) - if isinstance(value, Evidence): - return value - return Evidence(f"{scope}:name:{expression.id}") - return Evidence(f"{scope}:expression:{ast.dump(expression, include_attributes=False)}") - - -def _argument_evidence(call: ast.Call, binding: dict[str, Any], scope: str, values: dict[str, Any]) -> Evidence: - return _evidence(_binding_expression(call, binding), scope, values) - - -def _selector_matches(call: ast.Call, selector: dict[str, Any], scope: str, values: dict[str, Any]) -> bool: - evidence = _argument_evidence(call, selector, scope, values) - return evidence.static and evidence.value == selector.get("equals") - - -def _resolve_identity( - identity: Any, - call: ast.Call, - receiver: Surface | None, - scope: str, - values: dict[str, Any], -) -> Evidence | None: - if not isinstance(identity, dict): - return None - if isinstance(identity.get("argument"), dict): - return _argument_evidence(call, identity["argument"], scope, values) - if identity.get("receiver") is True: - return receiver.identity if receiver else None - raise RuntimeConditionsError(f"unsupported Condition identity {identity}") - - -def _write_target(document: dict[str, Any], target: str, value: Any) -> None: - current: dict[str, Any] = document - parts = target.split(".") - for part in parts[:-1]: - current = current.setdefault(part, {}) - leaf = parts[-1] - if leaf.endswith("[]"): - current.setdefault(leaf[:-2], []).append(value) - else: - current[leaf] = value - - -def _merge_condition(target: dict[str, Any], incoming: dict[str, Any]) -> None: - for key, value in incoming.items(): - if key not in target: - target[key] = copy.deepcopy(value) - elif isinstance(target[key], dict) and isinstance(value, dict): - _merge_condition(target[key], value) - elif isinstance(target[key], list) and isinstance(value, list): - for item in value: - if item not in target[key]: - target[key].append(copy.deepcopy(item)) - elif target[key] != value: - raise RuntimeConditionsError(f"conflicting SDK mapping writes at {key}") diff --git a/runtimeconditions_profiler/sdk/resolver.py b/runtimeconditions_profiler/sdk/resolver.py deleted file mode 100644 index 2864dd2..0000000 --- a/runtimeconditions_profiler/sdk/resolver.py +++ /dev/null @@ -1,145 +0,0 @@ -from __future__ import annotations - -import ast -import hashlib -import importlib.metadata -import json -import urllib.parse -import urllib.request -from pathlib import Path -from typing import Any - -from ..errors import RuntimeConditionsError -from ..source.python import workload_source_files -from ..yamlio import Yaml, dump_yaml - - -BUNDLE_INDEX = "runtimeconditions-resolved.yaml" - - -def referenced_distributions(project_root: Path) -> dict[str, str]: - roots: set[str] = set() - for source in workload_source_files(project_root.absolute().resolve()): - tree = ast.parse(source.read_text(encoding="utf-8"), filename=str(source)) - for node in ast.walk(tree): - if isinstance(node, ast.Import): - roots.update(alias.name.split(".")[0] for alias in node.names) - elif isinstance(node, ast.ImportFrom) and node.level == 0 and node.module: - roots.add(node.module.split(".")[0]) - package_map = importlib.metadata.packages_distributions() - result: dict[str, str] = {} - for root in roots: - for distribution in package_map.get(root, []): - try: - result[distribution.lower().replace("_", "-")] = importlib.metadata.version(distribution) - except importlib.metadata.PackageNotFoundError: - continue - return result - - -def _read_location(location: str, base: str | None = None) -> tuple[bytes, str]: - parsed = urllib.parse.urlparse(location) - if base and not parsed.scheme: - location = urllib.parse.urljoin(base, location) - parsed = urllib.parse.urlparse(location) - if parsed.scheme in ("http", "https", "file"): - with urllib.request.urlopen(location) as response: - return response.read(), location - path = Path(location).absolute().resolve() - return path.read_bytes(), path.as_uri() - - -def _semantic_sha256(value: Any) -> str: - encoded = json.dumps(value, sort_keys=True, separators=(",", ":"), ensure_ascii=False).encode() - return hashlib.sha256(encoded).hexdigest() - - -def resolve_mappings(project_root: Path, catalog_location: str, destination: Path) -> list[dict[str, Any]]: - catalog_bytes, catalog_url = _read_location(catalog_location) - catalog = Yaml.load_text(catalog_bytes.decode("utf-8")) - if catalog.get("kind") != "RuntimeConditionsSDKMappingCatalog" or catalog.get("ecosystem") != "pypi": - raise RuntimeConditionsError("mapping resolver requires a pypi Runtime Conditions catalog") - referenced = referenced_distributions(project_root) - matches = [ - entry - for entry in catalog.get("entries", []) - if isinstance(entry, dict) - and referenced.get(str(entry.get("package", "")).lower().replace("_", "-")) == str(entry.get("version")) - ] - destination = destination.absolute().resolve() - destination.mkdir(parents=True, exist_ok=True) - resolved: list[dict[str, Any]] = [] - for entry in matches: - mapping_record = entry.get("mapping", {}) - extension_record = entry.get("extension", {}) - if not isinstance(mapping_record, dict) or not isinstance(extension_record, dict): - raise RuntimeConditionsError("catalog entry has invalid mapping or extension metadata") - mapping_bytes, _ = _read_location(str(mapping_record.get("url", "")), catalog_url) - mapping_digest = hashlib.sha256(mapping_bytes).hexdigest() - if mapping_digest != mapping_record.get("sha256"): - raise RuntimeConditionsError(f"mapping {mapping_record.get('name')} failed integrity validation") - mapping_doc = Yaml.load_text(mapping_bytes.decode("utf-8")) - extension_bytes, _ = _read_location(str(extension_record.get("url", "")), catalog_url) - extension_doc = Yaml.load_text(extension_bytes.decode("utf-8")) - extension_digest = _semantic_sha256(extension_doc.get("spec", {})) - if extension_digest != extension_record.get("semanticSha256"): - raise RuntimeConditionsError(f"extension {extension_record.get('id')} failed semantic integrity validation") - if mapping_doc.get("extension", {}).get("id") != extension_record.get("id"): - raise RuntimeConditionsError(f"mapping {mapping_record.get('name')} selects a different extension") - safe_package = str(entry["package"]).replace("/", "-") - safe_name = str(mapping_record["name"]).replace("/", "-") - root = destination / "artifacts" / safe_package / str(entry["version"]) / safe_name - root.mkdir(parents=True, exist_ok=True) - mapping_path = root / "runtimeconditions.sdk-mapping.yaml" - extension_path = root / "runtimeconditions.extension.yaml" - mapping_path.write_bytes(mapping_bytes) - extension_path.write_bytes(extension_bytes) - resolved.append( - { - "ecosystem": "pypi", - "package": entry["package"], - "packageVersion": str(entry["version"]), - "mapping": str(mapping_path.relative_to(destination)), - "extension": str(extension_path.relative_to(destination)), - "mappingSha256": mapping_digest, - "extensionSemanticSha256": extension_digest, - } - ) - index = { - "apiVersion": "runtimeconditions.io/resolved-sdk-mappings/v1alpha1", - "kind": "RuntimeConditionsResolvedSDKMappings", - "entries": resolved, - } - (destination / BUNDLE_INDEX).write_text(dump_yaml(index), encoding="utf-8") - return resolved - - -def bundle_artifact_paths( - project_root: Path, bundle_paths: list[Path] -) -> tuple[list[Path], list[Path]]: - referenced = referenced_distributions(project_root) - mappings: list[Path] = [] - extensions: list[Path] = [] - for raw_path in bundle_paths: - root = raw_path.absolute().resolve() - index_path = root / BUNDLE_INDEX if root.is_dir() else root - index = Yaml.load(index_path) - if index.get("kind") != "RuntimeConditionsResolvedSDKMappings": - raise RuntimeConditionsError(f"{index_path}: expected a resolved SDK mapping bundle") - base = index_path.parent - for entry in index.get("entries", []): - if not isinstance(entry, dict): - continue - package = str(entry.get("package", "")).lower().replace("_", "-") - if referenced.get(package) != str(entry.get("packageVersion")): - continue - mapping = (base / str(entry.get("mapping", ""))).resolve() - extension = (base / str(entry.get("extension", ""))).resolve() - if hashlib.sha256(mapping.read_bytes()).hexdigest() != entry.get("mappingSha256"): - raise RuntimeConditionsError(f"{mapping}: cached mapping failed integrity validation") - extension_document = Yaml.load(extension) - if _semantic_sha256(extension_document.get("spec", {})) != entry.get("extensionSemanticSha256"): - raise RuntimeConditionsError(f"{extension}: cached extension failed semantic integrity validation") - mappings.append(mapping) - extensions.append(extension) - return mappings, extensions diff --git a/runtimeconditions_profiler/source/__init__.py b/runtimeconditions_profiler/source/__init__.py index 6b7fa8b..e947c0d 100644 --- a/runtimeconditions_profiler/source/__init__.py +++ b/runtimeconditions_profiler/source/__init__.py @@ -1,11 +1,5 @@ -from .inspector import SourceInspector -from .python import PythonSourceIndex, expression_name, literal_string, workload_source_files +"""Where the profiler looks for the workload's source files.""" -__all__ = [ - "PythonSourceIndex", - "SourceInspector", - "expression_name", - "literal_string", - "workload_source_files", -] +from .python import workload_source_files +__all__ = ["workload_source_files"] diff --git a/runtimeconditions_profiler/source/inspector.py b/runtimeconditions_profiler/source/inspector.py deleted file mode 100644 index 69da0ea..0000000 --- a/runtimeconditions_profiler/source/inspector.py +++ /dev/null @@ -1,32 +0,0 @@ -from __future__ import annotations - -from .python import PythonSourceIndex, python_files, resolve_package_source_root -from ..manifest.mapping import all_mappings -from ..models import ValidatedArtifact - - -class SourceInspector: - def validate(self, artifact: ValidatedArtifact) -> None: - manifest = artifact.manifest - if manifest is None: - return - package_root = resolve_package_source_root(artifact.artifact.root, manifest.package) - if package_root is None: - artifact.add( - "package-source", - artifact.artifact.manifest_uri, - f"python package {manifest.package} is not declared in the artifact source", - ) - return - source = PythonSourceIndex.from_paths(python_files(package_root)) - for mapping in all_mappings(manifest): - source.validate_mapping(artifact, mapping) - for constant, value in manifest.constants.items(): - actual = source.constants.get(constant) - if actual is not None and actual != value: - artifact.add( - "package-source", - artifact.artifact.manifest_uri, - f"constant {constant} value {value} does not match Python value {actual}", - ) - diff --git a/runtimeconditions_profiler/source/python.py b/runtimeconditions_profiler/source/python.py index ad44ada..d4fe75e 100644 --- a/runtimeconditions_profiler/source/python.py +++ b/runtimeconditions_profiler/source/python.py @@ -1,170 +1,26 @@ +"""Which Python files of a workload the profiler reads.""" + from __future__ import annotations -import ast -from dataclasses import dataclass from pathlib import Path -from typing import Any, Optional - -from ..models import SymbolMapping, ValidatedArtifact -from ..util import ignored_path - - -@dataclass -class PythonClass: - name: str - functions: dict[str, list[str]] - annotations: dict[str, dict[str, str]] - - -class PythonSourceIndex: - def __init__(self) -> None: - self.classes: dict[str, PythonClass] = {} - self.constants: dict[str, str] = {} - self.schemas: dict[str, dict[str, Any]] = {} - self.string_constants: dict[str, str] = {} - - @staticmethod - def from_paths(paths: list[Path]) -> "PythonSourceIndex": - index = PythonSourceIndex() - for path in paths: - module = module_name_from_path(path) - tree = ast.parse(path.read_text(encoding="utf-8"), filename=str(path)) - index._visit_module(tree, module) - return index - - def validate_mapping(self, artifact: ValidatedArtifact, mapping: SymbolMapping) -> None: - class_info = self.classes.get(mapping.class_name) - if class_info is None: - artifact.add( - "package-source", - artifact.artifact.manifest_uri, - f"{mapping.class_name}.{mapping.member_name} is not declared in Python package", - ) - return - params = class_info.functions.get(mapping.member_name) - if params is None: - artifact.add( - "package-source", - artifact.artifact.manifest_uri, - f"{mapping.class_name}.{mapping.member_name} is not declared in Python package", - ) - return - annotations = class_info.annotations.get(mapping.member_name, {}) - for label, index in arg_indexes(mapping): - if index >= len(params): - artifact.add( - "package-source", - artifact.artifact.manifest_uri, - f"{mapping.class_name}.{mapping.member_name} {label} index {index} is out of range", - ) - continue - name = params[index] - annotation = annotations.get(name, "") - if label in ("nameArg", "stringArg") and annotation and annotation not in ("str", "typing.Optional[str]", "Optional[str]"): - artifact.add( - "package-source", - artifact.artifact.manifest_uri, - f"{mapping.class_name}.{mapping.member_name} {label} index {index} must point to a string parameter", - ) - if label == "classArg" and annotation and annotation not in ("type", "object", "Any", "typing.Any"): - artifact.add( - "package-source", - artifact.artifact.manifest_uri, - f"{mapping.class_name}.{mapping.member_name} classArg index {index} must point to a class/type parameter", - ) - - def _visit_module(self, tree: ast.Module, module: str) -> None: - functions: dict[str, list[str]] = {} - annotations: dict[str, dict[str, str]] = {} - for node in tree.body: - if isinstance(node, (ast.Assign, ast.AnnAssign)): - self._collect_assignment(node, "") - if isinstance(node, ast.ClassDef): - self._collect_class(node, module) - if isinstance(node, ast.FunctionDef): - functions[node.name] = [arg.arg for arg in node.args.args] - annotations[node.name] = { - arg.arg: annotation_name(arg.annotation) - for arg in node.args.args - if arg.annotation is not None - } - if functions: - self.classes[module] = PythonClass(module, functions, annotations) - - def _collect_class(self, node: ast.ClassDef, module: str) -> None: - functions: dict[str, list[str]] = {} - annotations: dict[str, dict[str, str]] = {} - fields: dict[str, Any] = {} - for child in node.body: - if isinstance(child, (ast.Assign, ast.AnnAssign)): - self._collect_assignment(child, node.name) - field_name, field_type = class_field_annotation(child) - if field_name and field_type: - fields[field_name] = schema_for_annotation(field_type, self.schemas) - if isinstance(child, ast.FunctionDef): - params = [arg.arg for arg in child.args.args] - if params and params[0] in ("self", "cls"): - params = params[1:] - functions[child.name] = params - annotations[child.name] = { - arg.arg: annotation_name(arg.annotation) - for arg in child.args.args - if arg.annotation is not None - } - if isinstance(child, ast.ClassDef): - self._collect_nested_class(child, node.name) - self.classes[node.name] = PythonClass(node.name, functions, annotations) - if fields: - self.schemas[node.name] = fields - if module: - self.schemas[f"{module}.{node.name}"] = fields - - def _collect_nested_class(self, node: ast.ClassDef, parent: str) -> None: - prefix = f"{parent}.{node.name}" - for child in node.body: - if isinstance(child, (ast.Assign, ast.AnnAssign)): - self._collect_assignment(child, prefix) - def _collect_assignment(self, node: ast.Assign | ast.AnnAssign, prefix: str) -> None: - value_node = node.value - if value_node is None: - return - value = literal_string(value_node) - if value is None: - return - targets: list[ast.expr] - if isinstance(node, ast.Assign): - targets = list(node.targets) - else: - targets = [node.target] - for target in targets: - name = target_name(target) - if name: - key = f"{prefix}.{name}" if prefix else name - self.constants[key] = value - self.string_constants[key] = value - self.string_constants[name] = value - -def resolve_package_source_root(artifact_root: Path, package: str) -> Optional[Path]: - package_path = Path(*package.split(".")) - candidates = [ - artifact_root / package_path, - artifact_root / "src" / package_path, - artifact_root / "src" / "main" / "python" / package_path, - ] - for candidate in candidates: - if (candidate / "__init__.py").is_file(): - return candidate - if candidate.with_suffix(".py").is_file(): - return candidate.with_suffix(".py") - return None - - -def python_files(root: Path) -> list[Path]: - if root.is_file(): - return [root] - return [path for path in sorted(root.rglob("*.py")) if not ignored_path(path)] +def ignored_path(path: Path) -> bool: + ignored = { + "__pycache__", + ".pytest_cache", + ".mypy_cache", + ".ruff_cache", + ".venv", + "venv", + "build", + "dist", + "*.egg-info", + } + parts = set(path.parts) + if parts & (ignored - {"*.egg-info"}): + return True + return any(part.endswith(".egg-info") for part in path.parts) def workload_source_files(root: Path) -> list[Path]: @@ -183,80 +39,3 @@ def workload_source_files(root: Path) -> list[Path]: seen.add(resolved) files.append(resolved) return files - - -def literal_string(expr: ast.expr) -> Optional[str]: - if isinstance(expr, ast.Constant) and isinstance(expr.value, str): - return expr.value - return None - - -def target_name(expr: ast.expr) -> Optional[str]: - if isinstance(expr, ast.Name): - return expr.id - if isinstance(expr, ast.Attribute): - base = target_name(expr.value) - return f"{base}.{expr.attr}" if base else expr.attr - return None - - -def expression_name(expr: ast.expr) -> Optional[str]: - if isinstance(expr, ast.Name): - return expr.id - if isinstance(expr, ast.Attribute): - base = expression_name(expr.value) - return f"{base}.{expr.attr}" if base else expr.attr - return None - - -def annotation_name(annotation: ast.expr | None) -> str: - if annotation is None: - return "" - if isinstance(annotation, ast.Name): - return annotation.id - if isinstance(annotation, ast.Attribute): - return expression_name(annotation) or "" - if isinstance(annotation, ast.Subscript): - return annotation_name(annotation.value) - if isinstance(annotation, ast.Constant): - return str(annotation.value) - return "" - - -def class_field_annotation(node: ast.Assign | ast.AnnAssign) -> tuple[str, str]: - if isinstance(node, ast.AnnAssign): - name = target_name(node.target) - return name or "", annotation_name(node.annotation) - return "", "" - - -def schema_for_annotation(name: str, schemas: dict[str, dict[str, Any]]) -> Any: - return { - "str": "string", - "int": "integer", - "bool": "boolean", - "float": "number", - }.get(name, schemas.get(name, {})) - - -def module_name_from_path(path: Path) -> str: - if path.name == "__init__.py": - return path.parent.name - return path.stem - - -def arg_indexes(mapping: SymbolMapping) -> list[tuple[str, int]]: - result: list[tuple[str, int]] = [] - if mapping.name_arg is not None: - result.append(("nameArg", mapping.name_arg)) - if mapping.class_arg is not None: - result.append(("classArg", mapping.class_arg)) - if mapping.enum_arg is not None: - result.append(("enumArg", mapping.enum_arg)) - for _, index in mapping.string_args.items(): - result.append(("stringArg", index)) - for write in mapping.writes: - argument = write.get("argument") - if isinstance(argument, dict) and isinstance(argument.get("position"), int): - result.append(("stringArg", argument["position"])) - return result diff --git a/runtimeconditions_profiler/util.py b/runtimeconditions_profiler/util.py deleted file mode 100644 index ddfdbec..0000000 --- a/runtimeconditions_profiler/util.py +++ /dev/null @@ -1,121 +0,0 @@ -from __future__ import annotations - -from pathlib import Path -from typing import Any, Optional -from urllib.parse import urlparse - -from .errors import RuntimeConditionsError -from .extension.identity import resolve_reference -from .models import Diagnostic, RuntimeConditionsArtifact - - -def as_map(value: Any) -> dict[str, Any]: - return value if isinstance(value, dict) else {} - - -def as_list(value: Any) -> list[Any]: - return value if isinstance(value, list) else [] - - -def scalar(value: Any) -> Optional[str]: - if isinstance(value, (str, int, bool, float)): - return str(value) - return None - - -def string_list(value: Any) -> list[str]: - return [str(item) for item in value] if isinstance(value, list) else [] - - -def parse_plain_string_list(value: Any) -> list[str]: - if not isinstance(value, list): - return [] - return [str(item) for item in value if isinstance(item, (str, int, bool))] - - -def ignored_path(path: Path) -> bool: - ignored = { - "__pycache__", - ".pytest_cache", - ".mypy_cache", - ".ruff_cache", - ".venv", - "venv", - "build", - "dist", - "*.egg-info", - } - parts = set(path.parts) - if parts & (ignored - {"*.egg-info"}): - return True - return any(part.endswith(".egg-info") for part in path.parts) - - -def uri_to_path(uri: str) -> Path: - parsed = urlparse(uri) - if parsed.scheme != "file": - raise RuntimeConditionsError(f"unsupported artifact URI scheme: {parsed.scheme}") - return Path(parsed.path) - - -def dedupe_paths(paths: list[Path]) -> list[Path]: - result: list[Path] = [] - seen: set[Path] = set() - for path in paths: - resolved = path.resolve() - if resolved in seen: - continue - seen.add(resolved) - result.append(resolved) - return result - - -def dedupe_artifacts(artifacts: list[RuntimeConditionsArtifact]) -> list[RuntimeConditionsArtifact]: - result: list[RuntimeConditionsArtifact] = [] - seen: set[str] = set() - for artifact in artifacts: - key = artifact.manifest_uri - if key in seen: - continue - seen.add(key) - result.append(artifact) - return result - - -def diagnostics_text(diagnostics: list[Diagnostic]) -> str: - return "; ".join(diagnostic.message for diagnostic in diagnostics) - - -def deep_copy(value: Any) -> Any: - if isinstance(value, dict): - return {str(key): deep_copy(item) for key, item in value.items()} - if isinstance(value, list): - return [deep_copy(item) for item in value] - return value - - -def add_unique(items: list[str], value: str) -> None: - if value not in items: - items.append(value) - - -def add_extension_closure(extension: tuple[str, str], dependencies: dict[tuple[str, str], list[tuple[str, str]]], resolved: set[tuple[str, str]]) -> None: - for dependency in dependencies.get(extension, []): - add_extension_closure(resolve_reference(dependency, dependencies), dependencies, resolved) - resolved.add(extension) - - -def condition_scopes_overlap( - left_kinds: tuple[str, ...], - left_types: tuple[str, ...], - right_kinds: tuple[str, ...], - right_types: tuple[str, ...], -) -> bool: - if not set(left_kinds).intersection(right_kinds): - return False - return not left_types or not right_types or bool(set(left_types).intersection(right_types)) - - -def increment(counts: dict[str, int], key: str) -> None: - counts[key] = counts.get(key, 0) + 1 - diff --git a/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index 1a05534..0000000 --- a/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,18 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/bad-class, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - options: - - class: Fixture - function: schema - target: responseSchema - classArg: 0 - diff --git a/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index 4d0d57e..0000000 --- a/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/bad-class - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index a32dc7b..0000000 --- a/testdata/authoring/bad-class-or-schema-arg-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str, option: object) -> object: - return object() - - @staticmethod - def schema(value: str) -> object: - return object() - diff --git a/testdata/authoring/bad-class-or-schema-arg-invalid/fixture.yaml b/testdata/authoring/bad-class-or-schema-arg-invalid/fixture.yaml deleted file mode 100644 index 8bdd331..0000000 --- a/testdata/authoring/bad-class-or-schema-arg-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: classArg index 0 must point to a class/type parameter - diff --git a/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index 3803539..0000000 --- a/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,19 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/bad-string, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - options: - - class: Fixture - function: option - target: env.sensitive - stringArgs: - path: 2 - diff --git a/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index 8323310..0000000 --- a/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/bad-string - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index d9f9504..0000000 --- a/testdata/authoring/bad-string-arg-index-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,9 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str, option: object) -> object: - return object() - - @staticmethod - def option(path: str) -> object: - return object() - diff --git a/testdata/authoring/bad-string-arg-index-invalid/fixture.yaml b/testdata/authoring/bad-string-arg-index-invalid/fixture.yaml deleted file mode 100644 index 7eeade8..0000000 --- a/testdata/authoring/bad-string-arg-index-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: Fixture.option stringArg index 2 is out of range - diff --git a/testdata/authoring/base-valid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/base-valid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index 516cc05..0000000 --- a/testdata/authoring/base-valid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/base, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - diff --git a/testdata/authoring/base-valid/extension/runtimeconditions.extension.yaml b/testdata/authoring/base-valid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index cc4b532..0000000 --- a/testdata/authoring/base-valid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/base - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/base-valid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/base-valid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index 5b7d7c9..0000000 --- a/testdata/authoring/base-valid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/base-valid/fixture.yaml b/testdata/authoring/base-valid/fixture.yaml deleted file mode 100644 index 61d61aa..0000000 --- a/testdata/authoring/base-valid/fixture.yaml +++ /dev/null @@ -1,2 +0,0 @@ -valid: true - diff --git a/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index 5a26609..0000000 --- a/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsGoBinding -metadata: - extension: {id: https://example.com/python-fixtures/kind, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - diff --git a/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index 1a96138..0000000 --- a/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/kind - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index 5b7d7c9..0000000 --- a/testdata/authoring/binding-kind-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/binding-kind-mismatch-invalid/fixture.yaml b/testdata/authoring/binding-kind-mismatch-invalid/fixture.yaml deleted file mode 100644 index 96315f1..0000000 --- a/testdata/authoring/binding-kind-mismatch-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: kind must be RuntimeConditionsBinding - diff --git a/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index c25da4b..0000000 --- a/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/language, version: v1alpha1} - language: java -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - diff --git a/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index 2e04001..0000000 --- a/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/language - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index 5b7d7c9..0000000 --- a/testdata/authoring/binding-language-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/binding-language-mismatch-invalid/fixture.yaml b/testdata/authoring/binding-language-mismatch-invalid/fixture.yaml deleted file mode 100644 index 1783f05..0000000 --- a/testdata/authoring/binding-language-mismatch-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: metadata.language must be python - diff --git a/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index e33b4cf..0000000 --- a/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/vocabulary, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.unknown - diff --git a/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index a22c72f..0000000 --- a/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/vocabulary - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index 5b7d7c9..0000000 --- a/testdata/authoring/binding-vocabulary-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/binding-vocabulary-invalid/fixture.yaml b/testdata/authoring/binding-vocabulary-invalid/fixture.yaml deleted file mode 100644 index a47206e..0000000 --- a/testdata/authoring/binding-vocabulary-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: declaration kind python.unknown - diff --git a/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index e05229e..0000000 --- a/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,15 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/constant, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - constants: - Fixture.VALUE: expected - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - diff --git a/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index 765258f..0000000 --- a/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,22 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/constant - version: v1alpha1 -spec: - kinds: - - name: python.fixture - interfaceTypes: - - name: python - targetKind: python.fixture - interfaceFields: - - name: mode - targetKind: python.fixture - targetType: python - fieldValues: - - field: interface.mode - targetKind: python.fixture - targetType: python - values: - - expected - diff --git a/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index 0c34c66..0000000 --- a/testdata/authoring/constant-mismatch-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,7 +0,0 @@ -class Fixture: - VALUE = "actual" - - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/constant-mismatch-invalid/fixture.yaml b/testdata/authoring/constant-mismatch-invalid/fixture.yaml deleted file mode 100644 index 7d4c054..0000000 --- a/testdata/authoring/constant-mismatch-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: does not match Python value - diff --git a/testdata/authoring/duplicate-extension-id-invalid/first/first_fixture/__init__.py b/testdata/authoring/duplicate-extension-id-invalid/first/first_fixture/__init__.py deleted file mode 100644 index 5b7d7c9..0000000 --- a/testdata/authoring/duplicate-extension-id-invalid/first/first_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.bindings.yaml b/testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.bindings.yaml deleted file mode 100644 index 99d0ecd..0000000 --- a/testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/duplicate, version: v1alpha1} - language: python -python: - package: first_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: first.fixture - diff --git a/testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.extension.yaml b/testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.extension.yaml deleted file mode 100644 index f944cc4..0000000 --- a/testdata/authoring/duplicate-extension-id-invalid/first/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/duplicate - version: v1alpha1 -spec: - kinds: - - name: first.fixture - diff --git a/testdata/authoring/duplicate-extension-id-invalid/fixture.yaml b/testdata/authoring/duplicate-extension-id-invalid/fixture.yaml deleted file mode 100644 index 360a9a7..0000000 --- a/testdata/authoring/duplicate-extension-id-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: duplicate extension id - diff --git a/testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.bindings.yaml b/testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.bindings.yaml deleted file mode 100644 index 3488112..0000000 --- a/testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/duplicate, version: v1alpha1} - language: python -python: - package: second_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: second.fixture - diff --git a/testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.extension.yaml b/testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.extension.yaml deleted file mode 100644 index bea3156..0000000 --- a/testdata/authoring/duplicate-extension-id-invalid/second/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/duplicate - version: v1alpha1 -spec: - kinds: - - name: second.fixture - diff --git a/testdata/authoring/duplicate-extension-id-invalid/second/second_fixture/__init__.py b/testdata/authoring/duplicate-extension-id-invalid/second/second_fixture/__init__.py deleted file mode 100644 index 5b7d7c9..0000000 --- a/testdata/authoring/duplicate-extension-id-invalid/second/second_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/missing-function-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/missing-function-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index 413eac9..0000000 --- a/testdata/authoring/missing-function-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/missing-function, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - diff --git a/testdata/authoring/missing-function-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/missing-function-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index 8b44c6c..0000000 --- a/testdata/authoring/missing-function-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/missing-function - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/missing-function-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/missing-function-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index ce46cf7..0000000 --- a/testdata/authoring/missing-function-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def other(name: str) -> object: - return object() - diff --git a/testdata/authoring/missing-function-invalid/fixture.yaml b/testdata/authoring/missing-function-invalid/fixture.yaml deleted file mode 100644 index d2d78df..0000000 --- a/testdata/authoring/missing-function-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: Fixture.declare is not declared in Python package - diff --git a/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index b9ab816..0000000 --- a/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/non-string, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - diff --git a/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index b00d61f..0000000 --- a/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/non-string - version: v1alpha1 -spec: - kinds: - - name: python.fixture - diff --git a/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index 9f5f5a7..0000000 --- a/testdata/authoring/non-string-name-arg-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: int) -> object: - return object() - diff --git a/testdata/authoring/non-string-name-arg-invalid/fixture.yaml b/testdata/authoring/non-string-name-arg-invalid/fixture.yaml deleted file mode 100644 index 0c5e794..0000000 --- a/testdata/authoring/non-string-name-arg-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: nameArg index 0 must point to a string parameter - diff --git a/testdata/authoring/overlapping-field-invalid/app/app_fixture/__init__.py b/testdata/authoring/overlapping-field-invalid/app/app_fixture/__init__.py deleted file mode 100644 index 4a6464a..0000000 --- a/testdata/authoring/overlapping-field-invalid/app/app_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class App: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/overlapping-field-invalid/app/runtimeconditions.bindings.yaml b/testdata/authoring/overlapping-field-invalid/app/runtimeconditions.bindings.yaml deleted file mode 100644 index 0b88f8a..0000000 --- a/testdata/authoring/overlapping-field-invalid/app/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,14 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/overlap-app, version: v1alpha1} - language: python -python: - package: app_fixture - declarations: - - class: App - function: declare - nameArg: 0 - kind: app.fixture - interfaceType: app - diff --git a/testdata/authoring/overlapping-field-invalid/app/runtimeconditions.extension.yaml b/testdata/authoring/overlapping-field-invalid/app/runtimeconditions.extension.yaml deleted file mode 100644 index 331c4ee..0000000 --- a/testdata/authoring/overlapping-field-invalid/app/runtimeconditions.extension.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/overlap-app - version: v1alpha1 -spec: - dependencies: - - {id: https://example.com/python-fixtures/overlap-base, version: v1alpha1} - - {id: https://example.com/python-fixtures/overlap-field-a, version: v1alpha1} - - {id: https://example.com/python-fixtures/overlap-field-b, version: v1alpha1} - diff --git a/testdata/authoring/overlapping-field-invalid/base/base_fixture/__init__.py b/testdata/authoring/overlapping-field-invalid/base/base_fixture/__init__.py deleted file mode 100644 index b7f34e2..0000000 --- a/testdata/authoring/overlapping-field-invalid/base/base_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Base: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/overlapping-field-invalid/base/runtimeconditions.bindings.yaml b/testdata/authoring/overlapping-field-invalid/base/runtimeconditions.bindings.yaml deleted file mode 100644 index a2354f2..0000000 --- a/testdata/authoring/overlapping-field-invalid/base/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,14 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/overlap-base, version: v1alpha1} - language: python -python: - package: base_fixture - declarations: - - class: Base - function: declare - nameArg: 0 - kind: app.fixture - interfaceType: app - diff --git a/testdata/authoring/overlapping-field-invalid/base/runtimeconditions.extension.yaml b/testdata/authoring/overlapping-field-invalid/base/runtimeconditions.extension.yaml deleted file mode 100644 index bc190ed..0000000 --- a/testdata/authoring/overlapping-field-invalid/base/runtimeconditions.extension.yaml +++ /dev/null @@ -1,12 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/overlap-base - version: v1alpha1 -spec: - kinds: - - name: app.fixture - interfaceTypes: - - name: app - targetKind: app.fixture - diff --git a/testdata/authoring/overlapping-field-invalid/field-a/field_a_fixture/__init__.py b/testdata/authoring/overlapping-field-invalid/field-a/field_a_fixture/__init__.py deleted file mode 100644 index bf4fa26..0000000 --- a/testdata/authoring/overlapping-field-invalid/field-a/field_a_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class FieldA: - @staticmethod - def env(property: str, name: str) -> object: - return object() - diff --git a/testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.bindings.yaml b/testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.bindings.yaml deleted file mode 100644 index 6cb208e..0000000 --- a/testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,19 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/overlap-field-a, version: v1alpha1} - language: python -python: - package: field_a_fixture - options: - - class: FieldA - function: env - target: configuration.env[] - appliesToKinds: - - app.fixture - appliesToInterfaceTypes: - - app - stringArgs: - property: 0 - name: 1 - diff --git a/testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.extension.yaml b/testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.extension.yaml deleted file mode 100644 index 9544ddd..0000000 --- a/testdata/authoring/overlapping-field-invalid/field-a/runtimeconditions.extension.yaml +++ /dev/null @@ -1,19 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/overlap-field-a - version: v1alpha1 -spec: - conditionFields: - - name: configuration - appliesToKinds: - - app.fixture - appliesToInterfaceTypes: - - app - fieldValues: - - field: configuration.env[].property - targetKind: app.fixture - targetType: app - values: - - url - diff --git a/testdata/authoring/overlapping-field-invalid/field-b/field_b_fixture/__init__.py b/testdata/authoring/overlapping-field-invalid/field-b/field_b_fixture/__init__.py deleted file mode 100644 index 3ba229f..0000000 --- a/testdata/authoring/overlapping-field-invalid/field-b/field_b_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class FieldB: - @staticmethod - def env(property: str, name: str) -> object: - return object() - diff --git a/testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.bindings.yaml b/testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.bindings.yaml deleted file mode 100644 index 489e26b..0000000 --- a/testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,19 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/overlap-field-b, version: v1alpha1} - language: python -python: - package: field_b_fixture - options: - - class: FieldB - function: env - target: configuration.env[] - appliesToKinds: - - app.fixture - appliesToInterfaceTypes: - - app - stringArgs: - property: 0 - name: 1 - diff --git a/testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.extension.yaml b/testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.extension.yaml deleted file mode 100644 index 4c55cba..0000000 --- a/testdata/authoring/overlapping-field-invalid/field-b/runtimeconditions.extension.yaml +++ /dev/null @@ -1,19 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/overlap-field-b - version: v1alpha1 -spec: - conditionFields: - - name: configuration - appliesToKinds: - - app.fixture - appliesToInterfaceTypes: - - app - fieldValues: - - field: configuration.env[].property - targetKind: app.fixture - targetType: app - values: - - url - diff --git a/testdata/authoring/overlapping-field-invalid/fixture.yaml b/testdata/authoring/overlapping-field-invalid/fixture.yaml deleted file mode 100644 index 634fb1a..0000000 --- a/testdata/authoring/overlapping-field-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: vocabulary conflict for conditionField:configuration - diff --git a/testdata/authoring/transitive-dependency-valid/app/app_fixture/__init__.py b/testdata/authoring/transitive-dependency-valid/app/app_fixture/__init__.py deleted file mode 100644 index 4a6464a..0000000 --- a/testdata/authoring/transitive-dependency-valid/app/app_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class App: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/transitive-dependency-valid/app/runtimeconditions.bindings.yaml b/testdata/authoring/transitive-dependency-valid/app/runtimeconditions.bindings.yaml deleted file mode 100644 index 6bbdbca..0000000 --- a/testdata/authoring/transitive-dependency-valid/app/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,14 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/transitive-app, version: v1alpha1} - language: python -python: - package: app_fixture - declarations: - - class: App - function: declare - nameArg: 0 - kind: app.fixture - interfaceType: app - diff --git a/testdata/authoring/transitive-dependency-valid/app/runtimeconditions.extension.yaml b/testdata/authoring/transitive-dependency-valid/app/runtimeconditions.extension.yaml deleted file mode 100644 index c11fa2e..0000000 --- a/testdata/authoring/transitive-dependency-valid/app/runtimeconditions.extension.yaml +++ /dev/null @@ -1,8 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/transitive-app - version: v1alpha1 -spec: - dependencies: - - {id: https://example.com/python-fixtures/transitive-config, version: v1alpha1} diff --git a/testdata/authoring/transitive-dependency-valid/base/base_fixture/__init__.py b/testdata/authoring/transitive-dependency-valid/base/base_fixture/__init__.py deleted file mode 100644 index 5b2bc23..0000000 --- a/testdata/authoring/transitive-dependency-valid/base/base_fixture/__init__.py +++ /dev/null @@ -1,4 +0,0 @@ -class Base: - @staticmethod - def declare(name: str) -> object: - return object() diff --git a/testdata/authoring/transitive-dependency-valid/base/runtimeconditions.bindings.yaml b/testdata/authoring/transitive-dependency-valid/base/runtimeconditions.bindings.yaml deleted file mode 100644 index c157ac0..0000000 --- a/testdata/authoring/transitive-dependency-valid/base/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/transitive-base, version: v1alpha1} - language: python -python: - package: base_fixture - declarations: - - class: Base - function: declare - nameArg: 0 - kind: app.fixture - interfaceType: app diff --git a/testdata/authoring/transitive-dependency-valid/base/runtimeconditions.extension.yaml b/testdata/authoring/transitive-dependency-valid/base/runtimeconditions.extension.yaml deleted file mode 100644 index 1da84f8..0000000 --- a/testdata/authoring/transitive-dependency-valid/base/runtimeconditions.extension.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/transitive-base - version: v1alpha1 -spec: - kinds: - - name: app.fixture - interfaceTypes: - - name: app - targetKind: app.fixture diff --git a/testdata/authoring/transitive-dependency-valid/config/config_fixture/__init__.py b/testdata/authoring/transitive-dependency-valid/config/config_fixture/__init__.py deleted file mode 100644 index e9a46cf..0000000 --- a/testdata/authoring/transitive-dependency-valid/config/config_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Config: - @staticmethod - def env(property: str, name: str) -> object: - return object() - diff --git a/testdata/authoring/transitive-dependency-valid/config/runtimeconditions.bindings.yaml b/testdata/authoring/transitive-dependency-valid/config/runtimeconditions.bindings.yaml deleted file mode 100644 index 298622f..0000000 --- a/testdata/authoring/transitive-dependency-valid/config/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,19 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/transitive-config, version: v1alpha1} - language: python -python: - package: config_fixture - options: - - class: Config - function: env - target: configuration.env[] - appliesToKinds: - - app.fixture - appliesToInterfaceTypes: - - app - stringArgs: - property: 0 - name: 1 - diff --git a/testdata/authoring/transitive-dependency-valid/config/runtimeconditions.extension.yaml b/testdata/authoring/transitive-dependency-valid/config/runtimeconditions.extension.yaml deleted file mode 100644 index 8e7d0e4..0000000 --- a/testdata/authoring/transitive-dependency-valid/config/runtimeconditions.extension.yaml +++ /dev/null @@ -1,21 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/transitive-config - version: v1alpha1 -spec: - dependencies: - - {id: https://example.com/python-fixtures/transitive-base, version: v1alpha1} - conditionFields: - - name: configuration - appliesToKinds: - - app.fixture - appliesToInterfaceTypes: - - app - fieldValues: - - field: configuration.env[].property - targetKind: app.fixture - targetType: app - values: - - url - diff --git a/testdata/authoring/transitive-dependency-valid/fixture.yaml b/testdata/authoring/transitive-dependency-valid/fixture.yaml deleted file mode 100644 index 61d61aa..0000000 --- a/testdata/authoring/transitive-dependency-valid/fixture.yaml +++ /dev/null @@ -1,2 +0,0 @@ -valid: true - diff --git a/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.bindings.yaml b/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.bindings.yaml deleted file mode 100644 index d0098b3..0000000 --- a/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/unresolved, version: v1alpha1} - language: python -python: - package: runtimeconditions_fixture - declarations: - - class: Fixture - function: declare - nameArg: 0 - kind: python.fixture - diff --git a/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.extension.yaml b/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.extension.yaml deleted file mode 100644 index 2d9b975..0000000 --- a/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions.extension.yaml +++ /dev/null @@ -1,11 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/unresolved - version: v1alpha1 -spec: - dependencies: - - {id: https://example.com/python-fixtures/missing/v1alpha1/runtimeconditions.extension.yaml, version: v1alpha1} - kinds: - - name: python.fixture - diff --git a/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions_fixture/__init__.py b/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions_fixture/__init__.py deleted file mode 100644 index 5b7d7c9..0000000 --- a/testdata/authoring/unresolved-dependency-invalid/extension/runtimeconditions_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Fixture: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/unresolved-dependency-invalid/fixture.yaml b/testdata/authoring/unresolved-dependency-invalid/fixture.yaml deleted file mode 100644 index 348d725..0000000 --- a/testdata/authoring/unresolved-dependency-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: cannot be resolved from discovered Runtime Conditions artifacts - diff --git a/testdata/authoring/vocabulary-conflict-invalid/alpha/alpha_fixture/__init__.py b/testdata/authoring/vocabulary-conflict-invalid/alpha/alpha_fixture/__init__.py deleted file mode 100644 index 10345e4..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/alpha/alpha_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Alpha: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.bindings.yaml b/testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.bindings.yaml deleted file mode 100644 index 19865a7..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/conflict-alpha, version: v1alpha1} - language: python -python: - package: alpha_fixture - declarations: - - class: Alpha - function: declare - nameArg: 0 - kind: shared.fixture - diff --git a/testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.extension.yaml b/testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.extension.yaml deleted file mode 100644 index c892ba4..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/alpha/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/conflict-alpha - version: v1alpha1 -spec: - kinds: - - name: shared.fixture - diff --git a/testdata/authoring/vocabulary-conflict-invalid/app/app_fixture/__init__.py b/testdata/authoring/vocabulary-conflict-invalid/app/app_fixture/__init__.py deleted file mode 100644 index 4a6464a..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/app/app_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class App: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.bindings.yaml b/testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.bindings.yaml deleted file mode 100644 index 68ea995..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/conflict-app, version: v1alpha1} - language: python -python: - package: app_fixture - declarations: - - class: App - function: declare - nameArg: 0 - kind: app.fixture - diff --git a/testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.extension.yaml b/testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.extension.yaml deleted file mode 100644 index de2cf10..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/app/runtimeconditions.extension.yaml +++ /dev/null @@ -1,12 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/conflict-app - version: v1alpha1 -spec: - dependencies: - - {id: https://example.com/python-fixtures/conflict-alpha, version: v1alpha1} - - {id: https://example.com/python-fixtures/conflict-beta, version: v1alpha1} - kinds: - - name: app.fixture - diff --git a/testdata/authoring/vocabulary-conflict-invalid/beta/beta_fixture/__init__.py b/testdata/authoring/vocabulary-conflict-invalid/beta/beta_fixture/__init__.py deleted file mode 100644 index 0b80311..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/beta/beta_fixture/__init__.py +++ /dev/null @@ -1,5 +0,0 @@ -class Beta: - @staticmethod - def declare(name: str) -> object: - return object() - diff --git a/testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.bindings.yaml b/testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.bindings.yaml deleted file mode 100644 index 58988a4..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.bindings.yaml +++ /dev/null @@ -1,13 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsBinding -metadata: - extension: {id: https://example.com/python-fixtures/conflict-beta, version: v1alpha1} - language: python -python: - package: beta_fixture - declarations: - - class: Beta - function: declare - nameArg: 0 - kind: shared.fixture - diff --git a/testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.extension.yaml b/testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.extension.yaml deleted file mode 100644 index 3496fc8..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/beta/runtimeconditions.extension.yaml +++ /dev/null @@ -1,9 +0,0 @@ -apiVersion: runtimeconditions.io/v1alpha1 -kind: RuntimeConditionsExtensionDefinition -metadata: - id: https://example.com/python-fixtures/conflict-beta - version: v1alpha1 -spec: - kinds: - - name: shared.fixture - diff --git a/testdata/authoring/vocabulary-conflict-invalid/fixture.yaml b/testdata/authoring/vocabulary-conflict-invalid/fixture.yaml deleted file mode 100644 index c259dd7..0000000 --- a/testdata/authoring/vocabulary-conflict-invalid/fixture.yaml +++ /dev/null @@ -1,3 +0,0 @@ -valid: false -wantErrorContains: vocabulary conflict for kind:shared.fixture - diff --git a/tests/test_binding_profiler.py b/tests/test_binding_profiler.py deleted file mode 100644 index f533049..0000000 --- a/tests/test_binding_profiler.py +++ /dev/null @@ -1,28 +0,0 @@ -from __future__ import annotations - -from pathlib import Path - -import yaml - -from runtimeconditions_profiler.main import DiscoveryOptions, ProjectDiscovery - - -TESTDATA = Path(__file__).resolve().parents[1] / "testdata" - - -def test_authoring_fixtures() -> None: - fixtures_root = TESTDATA / "authoring" - for fixture in sorted(path for path in fixtures_root.iterdir() if path.is_dir()): - config = yaml.safe_load((fixture / "fixture.yaml").read_text()) - result = ProjectDiscovery().discover(fixture, DiscoveryOptions()) - if config["valid"]: - assert not result.has_errors, f"{fixture.name} should be valid: {messages(result.diagnostics)}" - else: - assert result.has_errors, f"{fixture.name} should fail" - expected = config.get("wantErrorContains") - if expected: - assert expected in messages(result.diagnostics) - - -def messages(diagnostics) -> str: - return "; ".join(diagnostic.message for diagnostic in diagnostics) diff --git a/tests/test_extension_identity.py b/tests/test_extension_identity.py index c185cde..45d360e 100644 --- a/tests/test_extension_identity.py +++ b/tests/test_extension_identity.py @@ -49,90 +49,6 @@ def test_profile_reference_keeps_ids_that_do_not_end_with_the_version_tail() -> assert profile_reference((FULL, "v2")) == f"{FULL}:v2" -def test_expand_identifier_rebuilds_the_full_id() -> None: - from runtimeconditions_profiler.extension.identity import expand_identifier, parse_identifier - assert expand_identifier(*parse_identifier(f"{SHORT}:v1alpha1")) == FULL - assert expand_identifier(FULL, "v1alpha1") == FULL - assert expand_identifier("acme/jobs", "1.0.0") == "acme/jobs" -def test_validator_resolves_a_short_extension_reference() -> None: - from types import SimpleNamespace - - from runtimeconditions_profiler.profile.validator import ProfileValidator - - from runtimeconditions_profiler.extension.definition import parse_extension_definition - - definition = parse_extension_definition({"metadata": {"id": FULL, "version": "v1alpha1"}, "spec": {}}, FULL, FULL) - artifact = SimpleNamespace(id=FULL, version="v1alpha1", definition=definition) - discovery = SimpleNamespace(validated_artifacts=[], sdk_extensions=[artifact]) - profile = {"apiVersion": "runtimeconditions.io/v1alpha1", "kind": "RuntimeConditionsProfile", "extensions": [f"{SHORT}:v1alpha1"], "conditions": []} - messages = [item.message for item in ProfileValidator().validate(profile, discovery)] - assert not [m for m in messages if "missing extension definition" in m] - - -BASE = "https://example.test/rc/base/v1/runtimeconditions.extension.yaml" -TOP = "https://example.test/rc/top/v1/runtimeconditions.extension.yaml" - - -def _definitions(): - from runtimeconditions_profiler.extension.definition import parse_extension_definition - - base = parse_extension_definition({"metadata": {"id": BASE, "version": "v1"}, "spec": {}}, BASE, BASE) - top = parse_extension_definition({"metadata": {"id": TOP, "version": "v1"}, "spec": {"dependencies": [BASE]}}, TOP, TOP) - return {(BASE, "v1"): base, (TOP, "v1"): top} - - -def test_resolve_reference_finds_the_version_of_a_bare_id() -> None: - from runtimeconditions_profiler.extension.identity import resolve_reference - - known = [(BASE, "v1"), (TOP, "v1")] - assert resolve_reference((BASE, ""), known) == (BASE, "v1") - assert resolve_reference((BASE, "v1"), known) == (BASE, "v1") - assert resolve_reference(("https://example.test/other", ""), known) == ("https://example.test/other", "") - # Two versions of one id are ambiguous, so the reference is left alone. - assert resolve_reference((BASE, ""), [(BASE, "v1"), (BASE, "v2")]) == (BASE, "") - - -def test_string_dependencies_resolve_to_their_definitions() -> None: - from runtimeconditions_profiler.extension.definition import dependency_cycle_errors, resolve_definitions - from runtimeconditions_profiler.util import add_extension_closure - - definitions = _definitions() - assert [item.id for item in resolve_definitions((TOP, "v1"), definitions)] == [BASE, TOP] - assert dependency_cycle_errors(definitions) == [] - closure: set[tuple[str, str]] = set() - add_extension_closure((TOP, "v1"), {key: value.dependencies for key, value in definitions.items()}, closure) - assert closure == {(BASE, "v1"), (TOP, "v1")} - - -MAIL = "https://example.test/rc/mail/v1/runtimeconditions.extension.yaml" - - -def test_validator_checks_operations_written_as_strings() -> None: - from types import SimpleNamespace - - from runtimeconditions_profiler.extension.definition import parse_extension_definition - from runtimeconditions_profiler.profile.validator import ProfileValidator - - spec = { - "kinds": [{"name": "api"}], - "interfaceTypes": [{"name": "smtp", "targetKind": "api"}], - "interfaceFields": [{"name": "operations", "targetKind": "api", "targetType": "smtp"}], - "fieldValues": [{"field": "interface.operations[]", "targetKind": "api", "targetType": "smtp", "values": ["send"]}], - } - definition = parse_extension_definition({"metadata": {"id": MAIL, "version": "v1"}, "spec": spec}, MAIL, MAIL) - discovery = SimpleNamespace(validated_artifacts=[], sdk_extensions=[SimpleNamespace(id=MAIL, version="v1", definition=definition)]) - - def messages(operations: list[str]) -> list[str]: - profile = { - "apiVersion": "runtimeconditions.io/v1alpha1", - "kind": "RuntimeConditionsProfile", - "extensions": ["https://example.test/rc/mail:v1"], - "conditions": [{"kind": "api", "interface": {"type": "smtp", "operations": operations}}], - } - return [item.message for item in ProfileValidator().validate(profile, discovery)] - - assert not [m for m in messages(["send"]) if "operations" in m] - assert any("interface.operations[0] receive for api/smtp" in m for m in messages(["receive"])) diff --git a/tests/test_installed_binding_discovery.py b/tests/test_installed_binding_discovery.py index 93b3f3c..e61d9ea 100644 --- a/tests/test_installed_binding_discovery.py +++ b/tests/test_installed_binding_discovery.py @@ -1,6 +1,6 @@ from __future__ import annotations -from runtimeconditions_profiler.extension.identity import parse_identifier, reference_object +from runtimeconditions_profiler.extension.identity import parse_identifier import sys import json