Skip to content

omnipy.components.remote.models

CLASS DESCRIPTION
HttpUrlModel
QueryParamsModel
UrlDataclassModel
UrlPathModel

DEFAULT_PORTS module-attribute 

DEFAULT_PORTS = {80, 443}

QueryParamsJoinerModel module-attribute 

QueryParamsJoinerModel = NestedJoinItemsModel.adjust(
    "QueryParamsJoinerModel", delimiters=("&", "=")
)

QueryParamsSplitterModel module-attribute 

QueryParamsSplitterModel = NestedSplitToItemsModel.adjust(
    "QueryParamsSplitterModel", delimiters=("&", "=")
)

AutoResponseContentModel

Bases: Model[ResponseContentPydModel | StrictBytesModel | StrictStrModel | JsonListOrDictModel]

CLASS DESCRIPTION
Config
Source code in src/omnipy/components/remote/models.py 
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
class AutoResponseContentModel(Model[ResponseContentPydModel | StrictBytesModel | StrictStrModel
                                     | JsonListOrDictModel]):
    class Config(Model.Config):
        smart_union = False

    @classmethod
    def _parse_data(  # type: ignore[override]
        cls,
        data: ResponseContentPydModel | StrictBytesModel | StrictStrModel | AnyJsonListOrDictModel
    ) -> StrictBytesModel | StrictStrModel | AnyJsonListOrDictModel:
        if isinstance(data, ResponseContentPydModel):
            assert isinstance(data.content_type, ModelFriendlyMimeType)

            mimetype_tuple = (data.content_type.type, data.content_type.subtype)
            match mimetype_tuple:
                case ('application', 'json'):
                    return JsonListOrDictModel(data.response)
                case ('text', 'plain'):
                    return StrictStrModel(data.response)
                case ('application', 'octet-stream') | _:
                    return StrictBytesModel(data.response)
        else:
            return data

Config

Bases: Model.Config

ATTRIBUTE DESCRIPTION
smart_union

Source code in src/omnipy/components/remote/models.py 
246
247
class Config(Model.Config):
    smart_union = False

smart_union class-attribute instance-attribute 

smart_union = False

HttpUrlModel

Bases: Model[UrlDataclassModel | str]

METHOD DESCRIPTION
to_data
Source code in src/omnipy/components/remote/models.py 
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
class HttpUrlModel(Model[UrlDataclassModel | str]):
    if TYPE_CHECKING:

        def __new__(cls, *args: Any, **kwargs: Any) -> 'HttpUrlModel_UrlDataclassModel':
            ...

    @classmethod
    def _parse_data(cls, data: UrlDataclassModel | str) -> UrlDataclassModel:
        if data == '':
            data = 'http://localhost/'
        if data == 'https://':
            data = 'https://localhost/'
        # For validation only
        url_obj = pyd.Url(str(data) if isinstance(data, UrlDataclassModel) else data)

        parts: dict[str, str | int | None] = {}
        for key in UrlDataclassModel.__fields__.keys():
            match key:
                case 'scheme':
                    val = url_obj.scheme
                    assert val in {'http', 'https'}, f'Unsupported scheme: {val}'
                    parts[key] = val
                case 'host':
                    parts[key] = url_obj.unicode_host()
                case 'username' | 'password' | 'path' | 'fragment':
                    val = getattr(url_obj, key)
                    parts[key] = unquote(val) if val is not None else None
                case _:
                    parts[key] = getattr(url_obj, key)

        return UrlDataclassModel(**{
            key: val  # type: ignore[arg-type]
            for key, val in parts.items()
            if val is not None
        })

    def __add__(self, other: str) -> 'HttpUrlModel':
        return HttpUrlModel(str(self) + other)

    def to_data(self) -> str:
        return str(self.content)

    def __str__(self) -> str:
        return str(self.content)

to_data 

to_data() -> str
Source code in src/omnipy/components/remote/models.py 
201
202
def to_data(self) -> str:
    return str(self.content)

HttpUrlModel_UrlDataclassModel

Bases: HttpUrlModel, UrlDataclassModel

Source code in src/omnipy/components/remote/models.py 
210
211
class HttpUrlModel_UrlDataclassModel(HttpUrlModel, UrlDataclassModel):  # type: ignore[misc]
    ...

ModelFriendlyMimeType

Bases: pyd.BaseModel

ATTRIBUTE DESCRIPTION
parameters

TYPE: tuple[tuple[str, str], ...]

subtype

TYPE: str

suffix

TYPE: str

type

TYPE: str

Source code in src/omnipy/components/remote/models.py 
214
215
216
217
218
class ModelFriendlyMimeType(pyd.BaseModel):
    type: str
    subtype: str
    suffix: str
    parameters: tuple[tuple[str, str], ...]

parameters instance-attribute 

parameters: tuple[tuple[str, str], ...]

subtype instance-attribute 

subtype: str

suffix instance-attribute 

suffix: str

type instance-attribute 

type: str

QueryParamsModel

Bases: Model[dict[str, str] | tuple[tuple[str, str], ...] | tuple[str, ...] | str]

METHOD DESCRIPTION
to_data
Source code in src/omnipy/components/remote/models.py 
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
class QueryParamsModel(Model[dict[str, str] | tuple[tuple[str, str], ...] | tuple[str, ...] | str]):
    if TYPE_CHECKING and TYPE_CHECKER != 'mypy':

        def __new__(cls, *args: Any, **kwargs: Any) -> 'QueryParamsModel_dict':
            ...

    @classmethod
    def _validate_tuple_of_pairs(
            cls, params_list: list[str | list] | str) -> TypeGuard[list[tuple[str, str]]]:
        # The validated type is really a list of lists of two items, but we can't express that with
        # Python type hints, so we use a list of tuple pairs instead.
        return all(isinstance(param, list) and len(param) == 2 for param in params_list)

    @classmethod
    def _parse_data(
        cls, data: dict[str, str] | tuple[tuple[str, str], ...] | tuple[str, ...] | str
    ) -> dict[str, str]:
        if isinstance(data, dict):
            return data

        params_list = QueryParamsSplitterModel(data).content
        assert cls._validate_tuple_of_pairs(params_list), \
            (f'Each parameter must have 2 elements only: [key, value]. '
             f'Incorrect parameter list: {params_list}')

        return dict((unquote(key), unquote(val)) for key, val in params_list)

    def to_data(self) -> str:
        with hold_and_reset_prev_attrib_value(self.config.model,
                                              'dynamically_convert_elements_to_models'):
            self.config.model.dynamically_convert_elements_to_models = False
            assert isinstance(self.content, dict)
            url_encoded_content = tuple(
                (quote(key), quote(val)) for key, val in self.content.items())
            return cast(str, QueryParamsJoinerModel(url_encoded_content).to_data())

    def __str__(self) -> str:
        return self.to_data()

to_data 

to_data() -> str
Source code in src/omnipy/components/remote/models.py 
57
58
59
60
61
62
63
64
def to_data(self) -> str:
    with hold_and_reset_prev_attrib_value(self.config.model,
                                          'dynamically_convert_elements_to_models'):
        self.config.model.dynamically_convert_elements_to_models = False
        assert isinstance(self.content, dict)
        url_encoded_content = tuple(
            (quote(key), quote(val)) for key, val in self.content.items())
        return cast(str, QueryParamsJoinerModel(url_encoded_content).to_data())

QueryParamsModel_dict

Bases: QueryParamsModel, dict

Source code in src/omnipy/components/remote/models.py 
72
73
class QueryParamsModel_dict(QueryParamsModel, dict):  # type: ignore[misc]
    ...

ResponseContentPydModel

Bases: pyd.BaseModel

CLASS DESCRIPTION
Config
METHOD DESCRIPTION
parse_content_type
ATTRIBUTE DESCRIPTION
content_type

TYPE: ModelFriendlyMimeType | str

response

TYPE: object

Source code in src/omnipy/components/remote/models.py 
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
class ResponseContentPydModel(pyd.BaseModel):
    content_type: ModelFriendlyMimeType | str
    response: object

    class Config:
        arbitrary_types_allowed = True

    @pyd.validator('content_type', allow_reuse=True)
    def parse_content_type(cls, content_type: ModelFriendlyMimeType | str) -> ModelFriendlyMimeType:
        from .lazy_import import MimeType, parse_mimetype

        if isinstance(content_type, ModelFriendlyMimeType):
            return content_type

        mime_type: MimeType = parse_mimetype(content_type)
        return ModelFriendlyMimeType(
            type=mime_type.type,
            subtype=mime_type.subtype,
            suffix=mime_type.suffix,
            parameters=tuple(mime_type.parameters.items()),
        )

content_type instance-attribute 

content_type: ModelFriendlyMimeType | str

response instance-attribute 

response: object

Config

ATTRIBUTE DESCRIPTION
arbitrary_types_allowed

Source code in src/omnipy/components/remote/models.py 
225
226
class Config:
    arbitrary_types_allowed = True

arbitrary_types_allowed class-attribute instance-attribute 

arbitrary_types_allowed = True

parse_content_type 

parse_content_type(content_type: ModelFriendlyMimeType | str) -> ModelFriendlyMimeType
Source code in src/omnipy/components/remote/models.py 
228
229
230
231
232
233
234
235
236
237
238
239
240
241
@pyd.validator('content_type', allow_reuse=True)
def parse_content_type(cls, content_type: ModelFriendlyMimeType | str) -> ModelFriendlyMimeType:
    from .lazy_import import MimeType, parse_mimetype

    if isinstance(content_type, ModelFriendlyMimeType):
        return content_type

    mime_type: MimeType = parse_mimetype(content_type)
    return ModelFriendlyMimeType(
        type=mime_type.type,
        subtype=mime_type.subtype,
        suffix=mime_type.suffix,
        parameters=tuple(mime_type.parameters.items()),
    )

UrlDataclassModel

Bases: pyd.BaseModel

ATTRIBUTE DESCRIPTION
fragment

TYPE: str | None

host

TYPE: str

password

TYPE: str | None

path

TYPE: UrlPathModel_PurePosixPath

port

TYPE: int | None

query

TYPE: QueryParamsModel_dict

scheme

TYPE: str

username

TYPE: str | None

Source code in src/omnipy/components/remote/models.py 
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
class UrlDataclassModel(pyd.BaseModel):
    # Mutable fields
    scheme: str
    username: str | None = None
    password: str | None = None
    host: str = 'localhost'
    port: int | None = None

    if TYPE_CHECKING:
        path: UrlPathModel_PurePosixPath = pyd.Field(default_factory=UrlPathModel)
        query: QueryParamsModel_dict = pyd.Field(default_factory=QueryParamsModel)

    else:
        path: UrlPathModel = pyd.Field(default_factory=UrlPathModel)
        query: QueryParamsModel = pyd.Field(default_factory=QueryParamsModel)

    fragment: str | None = None

    def __str__(self) -> str:
        kwargs: dict[str, str | int] = {}
        for key, val in self.dict().items():
            if val is None:
                continue
            match key:
                case 'port':
                    if val in DEFAULT_PORTS:
                        continue
                    kwargs[key] = val
                case 'path':
                    # Fix for second problem described in
                    # https://github.com/pydantic/pydantic/issues/7186#issuecomment-1912791497
                    if val != '.':
                        kwargs[key] = val.lstrip('/')
                case 'query':
                    if val:
                        kwargs[key] = str(val)
                case _:
                    kwargs[key] = val

        return str(pyd.Url.build(**kwargs))  # type: ignore[arg-type]

fragment class-attribute instance-attribute 

fragment: str | None = None

host class-attribute instance-attribute 

host: str = 'localhost'

password class-attribute instance-attribute 

password: str | None = None

path class-attribute instance-attribute 

path: UrlPathModel_PurePosixPath = pyd.Field(default_factory=UrlPathModel)

port class-attribute instance-attribute 

port: int | None = None

query class-attribute instance-attribute 

query: QueryParamsModel_dict = pyd.Field(default_factory=QueryParamsModel)

scheme instance-attribute 

scheme: str

username class-attribute instance-attribute 

username: str | None = None

UrlPathModel

Bases: Model[PurePosixPath | str]

METHOD DESCRIPTION
to_data
Source code in src/omnipy/components/remote/models.py 
 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
class UrlPathModel(Model[PurePosixPath | str]):
    if TYPE_CHECKING and TYPE_CHECKER != 'mypy':

        def __new__(cls, *args: Any, **kwargs: Any) -> 'UrlPathModel_PurePosixPath':
            ...

    @classmethod
    def _parse_data(cls, data: PurePosixPath | str) -> PurePosixPath:
        return PurePosixPath(data) if isinstance(data, str) else data

    def to_data(self) -> str:
        return str(self.content)

    def __str__(self) -> str:
        return str(self.content)

    def _slash_operator(self, other: PurePosixPath | str | object) -> PurePosixPath:
        content = cast(PurePosixPath, self.content)
        match other:
            case PurePosixPath() | str():
                return content / other
            case _:
                return content / str(other)

    def __truediv__(self, other: PurePosixPath | str | object) -> 'UrlPathModel_PurePosixPath':
        return UrlPathModel(self._slash_operator(other))

    def __floordiv__(self, other: PurePosixPath | str | object) -> 'UrlPathModel_PurePosixPath':
        self.content = self._slash_operator(other)
        return self  # type: ignore[return-value]

    def __add__(self, other: PurePosixPath | str | object) -> 'UrlPathModel_PurePosixPath':
        return UrlPathModel(str(self) + str(other))

to_data 

to_data() -> str
Source code in src/omnipy/components/remote/models.py 
86
87
def to_data(self) -> str:
    return str(self.content)

UrlPathModel_PurePosixPath

Bases: UrlPathModel, PurePosixPath

Source code in src/omnipy/components/remote/models.py 
113
114
class UrlPathModel_PurePosixPath(UrlPathModel, PurePosixPath):  # type: ignore[misc]
    ...