kya-validator 0.2.3

Rust core KYA (Know Your Agent) validator with Python bindings, TEE support, and blockchain integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

"""
Inspector API for KYA Validator.

This module provides interfaces for inspecting KYA manifests.
"""

from typing import Optional, Any
from .errors import KyaValidatorError


class Inspector:
    """Manifest inspector for KYA manifests.

    This class provides methods for inspecting and
    validating manifest structure and content.

    Examples
    --------
    >>> inspector = Inspector()
    >>> info = inspector.inspect(manifest)
    >>> print(info['kyaVersion'])
    1.0
    """

    def __init__(self):
        """Initialize inspector."""
        # Placeholder for future PyO3 bindings
        pass

    def inspect(self, manifest: dict[str, Any]) -> dict[str, Any]:
        """Inspect a KYA manifest.

        Parameters
        ----------
        manifest : dict
            Manifest to inspect.

        Returns
        -------
        dict
            Inspection results with manifest metadata.

        Raises
        ------
        KyaValidatorError
            If inspection fails.

        Examples
        --------
        >>> manifest = {
        ...     'kyaVersion': '1.0',
        ...     'agentId': 'did:key:z6Mk...',
        ... }
        >>> inspector = Inspector()
        >>> info = inspector.inspect(manifest)
        >>> print(info['kyaVersion'])
        1.0
        """
        # Placeholder for future PyO3 bindings
        # In production, this will call Rust inspect_manifest
        return {
            'kyaVersion': manifest.get('kyaVersion'),
            'agentId': manifest.get('agentId'),
            'verificationMethod': manifest.get('verificationMethod'),
            'hasProofs': len(manifest.get('proof', [])) > 0,
            'hasPermittedRegions': bool(manifest.get('permittedRegions')),
            'hasForbiddenRegions': bool(manifest.get('forbiddenRegions')),
            'maxTransactionValue': manifest.get('maxTransactionValue'),
        }

    def validate_version(
        self,
        manifest: dict[str, Any],
        allowed_versions: list[str],
    ) -> bool:
        """Validate KYA version against allowed versions.

        Parameters
        ----------
        manifest : dict
            Manifest to validate.
        allowed_versions : list[str]
            List of allowed version strings.

        Returns
        -------
        bool
            True if version is allowed, False otherwise.

        Examples
        --------
        >>> manifest = {'kyaVersion': '1.0'}
        >>> inspector = Inspector()
        >>> inspector.validate_version(manifest, ['1.0', '1.1'])
        True
        """
        version = manifest.get('kyaVersion')
        if not version:
            return False

        for allowed in allowed_versions:
            if version.startswith(allowed):
                return True

        return False

    def get_verification_methods(
        self,
        manifest: dict[str, Any],
    ) -> list[str]:
        """Get verification methods from manifest.

        Parameters
        ----------
        manifest : dict
            Manifest to extract from.

        Returns
        -------
        list[str]
            List of verification method IDs.
        """
        methods = manifest.get('verificationMethod', [])
        if isinstance(methods, list):
            return methods
        elif isinstance(methods, dict):
            return list(methods.keys())
        return []

    def get_proofs(self, manifest: dict[str, Any]) -> list[dict[str, Any]]:
        """Get proofs from manifest.

        Parameters
        ----------
        manifest : dict
            Manifest to extract from.

        Returns
        -------
        list[dict]
            List of proof objects.
        """
        return manifest.get('proof', [])


def inspect_manifest(manifest: dict[str, Any]) -> dict[str, Any]:
    """Inspect a KYA manifest (convenience function).

    This is a convenience function that creates an Inspector
    and inspects a manifest.

    Parameters
    ----------
    manifest : dict
            Manifest to inspect.

    Returns
    -------
    dict
            Inspection results.

    Examples
    --------
    >>> manifest = {
    ...     'kyaVersion': '1.0',
    ...     'agentId': 'did:key:z6Mk...',
    ... }
    >>> info = inspect_manifest(manifest)
    >>> print(info['kyaVersion'])
    1.0
    """
    inspector = Inspector()
    return inspector.inspect(manifest)