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