iri-client 0.1.4

Rust client and Python bindings for the NERSC IRI API
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

from __future__ import annotations

from typing import Awaitable


class OperationDefinition:
    """Metadata for one generated `OpenAPI` operation.
    
    Returned by `Client.operations()` and `AsyncClient.operations()`.
    """
    @property
    def operation_id(self) -> str:
        """Stable `OpenAPI` operation identifier (for example, `"getFacility"`)."""
        ...

    @property
    def method(self) -> str:
        """Uppercase HTTP method (for example, `"GET"` or `"POST"`)."""
        ...

    @property
    def path_template(self) -> str:
        """Path template which may contain `{param}` placeholders."""
        ...

    @property
    def path_params(self) -> list[str]:
        """Required path-parameter names extracted from `path_template`."""
        ...


class Client:
    """Synchronous Python client for the IRI API.
    
    This class wraps the blocking Rust client and returns JSON payloads as
    strings.
    """
    def __init__(
        self,
        base_url: str | None = None,
        access_token: str | None = None,
    ) -> None: ...
    @staticmethod
    def operations() -> list[OperationDefinition]:
        """Return all generated `OpenAPI` operation definitions."""
        ...
    def get(self, path: str) -> str:
        """Perform a `GET` request against a raw API path."""
        ...
    def request(
        self,
        method: str,
        path: str,
        query_json: str | None = None,
        body_json: str | None = None,
    ) -> str:
        """Perform a raw HTTP request by method and path.
        
        Args:
            method: HTTP method (for example, `"GET"`).
            path: API path relative to the configured base URL.
            `query_json`: Optional JSON object (string) used as query parameters.
            `body_json`: Optional JSON value (string) used as request body.
        
        Returns:
            A JSON string containing the parsed response payload.
        """
        ...
    def call_operation(
        self,
        operation_id: str,
        path_params_json: str | None = None,
        query_json: str | None = None,
        body_json: str | None = None,
    ) -> str:
        """Call an endpoint by `OpenAPI` `operation_id`.
        
        Args:
            `operation_id`: Operation identifier from `Client.operations()`.
            `path_params_json`: Optional JSON object (string) for path parameters.
            `query_json`: Optional JSON object (string) for query parameters.
            `body_json`: Optional JSON value (string) for request body.
        
        Returns:
            A JSON string containing the parsed response payload.
        """
        ...


class AsyncClient:
    """Asynchronous Python client for the IRI API.
    
    Methods return awaitables using the Tokio runtime integration from
    `pyo3-async-runtimes`.
    """
    def __init__(
        self,
        base_url: str | None = None,
        access_token: str | None = None,
    ) -> None: ...
    @staticmethod
    def operations() -> list[OperationDefinition]:
        """Return all generated `OpenAPI` operation definitions."""
        ...
    def get(self, path: str) -> Awaitable[str]:
        """Perform an asynchronous `GET` request against a raw API path."""
        ...
    def request(
        self,
        method: str,
        path: str,
        query_json: str | None = None,
        body_json: str | None = None,
    ) -> Awaitable[str]:
        """Perform an asynchronous raw HTTP request by method and path.
        
        Args:
            method: HTTP method (for example, `"GET"`).
            path: API path relative to the configured base URL.
            `query_json`: Optional JSON object (string) used as query parameters.
            `body_json`: Optional JSON value (string) used as request body.
        
        Returns:
            An awaitable resolving to a JSON string response payload.
        """
        ...
    def call_operation(
        self,
        operation_id: str,
        path_params_json: str | None = None,
        query_json: str | None = None,
        body_json: str | None = None,
    ) -> Awaitable[str]:
        """Call an endpoint asynchronously by `OpenAPI` `operation_id`.
        
        Args:
            `operation_id`: Operation identifier from `AsyncClient.operations()`.
            `path_params_json`: Optional JSON object (string) for path parameters.
            `query_json`: Optional JSON object (string) for query parameters.
            `body_json`: Optional JSON value (string) for request body.
        
        Returns:
            An awaitable resolving to a JSON string response payload.
        """
        ...