omnipy.components.json.models

CLASS	DESCRIPTION
JsonCustomDictModel
JsonCustomListModel
JsonDictModel	JsonDictModel is a limited JSON model supporting only JSON content
JsonDictOfDictsModel
JsonDictOfDictsOfScalarsModel
JsonDictOfListsModel
JsonDictOfListsOfDictsModel
JsonDictOfListsOfScalarsModel
JsonDictOfNestedListsModel
JsonDictOfScalarsModel
JsonListModel	JsonListModel is a limited JSON model supporting only JSON content
JsonListOfDictsModel
JsonListOfDictsOfScalarsModel
JsonListOfListsModel
JsonListOfListsOfScalarsModel
JsonListOfNestedDictsModel
JsonListOfScalarsModel
JsonListOrDictModel	JsonListOrDictModel is a general JSON model supporting any JSON
JsonModel	JsonModel is a general JSON model supporting any JSON content, any
JsonNestedDictsModel
JsonNestedListsModel
JsonOnlyDictsModel
JsonOnlyListsModel
JsonScalarModel	JsonScalarModel is a limited JSON model supporting only scalar JSON
ParseStrAsJsonMixin

FUNCTION	DESCRIPTION
is_json_model_instance_hack	Check if the given object is an instance of a JSON model class.

ATTRIBUTE	DESCRIPTION
AnyJsonListOrDictModel	TYPE: TypeAlias
AnyJsonModel	TYPE: TypeAlias
AnyJsonOnlyDictsModel	TYPE: TypeAlias
AnyJsonOnlyListsModel	TYPE: TypeAlias
AnyJsonScalarModel	TYPE: TypeAlias

AnyJsonListOrDictModel module-attribute

AnyJsonListOrDictModel: TypeAlias = _JsonAnyListM | _JsonAnyDictM

AnyJsonModel module-attribute

AnyJsonModel: TypeAlias = AnyJsonScalarModel | AnyJsonListOrDictModel

AnyJsonOnlyDictsModel module-attribute

AnyJsonOnlyDictsModel: TypeAlias = AnyJsonScalarModel | _JsonNestedDictsM

AnyJsonOnlyListsModel module-attribute

AnyJsonOnlyListsModel: TypeAlias = AnyJsonScalarModel | _JsonNestedListsM

AnyJsonScalarModel module-attribute

AnyJsonScalarModel: TypeAlias = Model[None] | Model[int] | Model[float] | Model[str] | Model[bool]

JsonCustomDictModel

Bases: Model[_JsonDictM[_JsonBaseT]], Generic[_JsonBaseT]

Source code in src/omnipy/components/json/models.py

class JsonCustomDictModel(Model[_JsonDictM[_JsonBaseT]], Generic[_JsonBaseT]):
    ...

JsonCustomListModel

Bases: Model[_JsonListM[_JsonBaseT]], Generic[_JsonBaseT]

Source code in src/omnipy/components/json/models.py

class JsonCustomListModel(Model[_JsonListM[_JsonBaseT]], Generic[_JsonBaseT]):
    ...

JsonDictModel

Bases: Model[_JsonAnyDictM]

JsonDictModel is a limited JSON model supporting only JSON content that has a dict (or "object" in JSON nomenclature) at the root. The values of the top-level dict can be any JSON content, though, any levels deep.

Examples:

>>> my_json = JsonDictModel({'a': None, 'b': [1, 12.5, {'abc': 123}]})
>>> my_json.to_data()
{'a': None, 'b': [1, 12.5, {'abc': 123}]}
>>> my_json.to_json()
'{"a": null, "b": [1, 12.5, {"abc": 123}]}'
>>> print(my_json.to_json(pretty=True))
{
  "a": null,
  "b": [
    1,
    12.5,
    {
      "abc": 123
    }
  ]
}
>>> try:
...     my_json = JsonDictModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
... except Exception as e:
...     print(str(e).splitlines()[0])
3 validation errors for JsonDictModel

Source code in src/omnipy/components/json/models.py

class JsonDictModel(Model[_JsonAnyDictM]):
    """
    JsonDictModel is a limited JSON model supporting only JSON content
    that has a dict (or "object" in JSON nomenclature) at the root.
    The values of the top-level dict can be any JSON content, though,
    any levels deep.

    Examples:
        >>> my_json = JsonDictModel({'a': None, 'b': [1, 12.5, {'abc': 123}]})
        >>> my_json.to_data()
        {'a': None, 'b': [1, 12.5, {'abc': 123}]}
        >>> my_json.to_json()
        '{"a": null, "b": [1, 12.5, {"abc": 123}]}'
        >>> print(my_json.to_json(pretty=True))
        {
          "a": null,
          "b": [
            1,
            12.5,
            {
              "abc": 123
            }
          ]
        }
        >>> try:
        ...     my_json = JsonDictModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
        ... except Exception as e:
        ...     print(str(e).splitlines()[0])
        3 validation errors for JsonDictModel
    """

JsonDictOfDictsModel

Bases: Model[_JsonDictM[_JsonAnyDictM]]

Source code in src/omnipy/components/json/models.py

class JsonDictOfDictsModel(Model[_JsonDictM[_JsonAnyDictM]]):
    ...

JsonDictOfDictsOfScalarsModel

Bases: Model[_JsonDictM[_JsonDictOfScalars]]

Source code in src/omnipy/components/json/models.py

class JsonDictOfDictsOfScalarsModel(Model[_JsonDictM[_JsonDictOfScalars]]):
    ...

JsonDictOfListsModel

Bases: Model[_JsonDictM[_JsonAnyListM]]

Source code in src/omnipy/components/json/models.py

class JsonDictOfListsModel(Model[_JsonDictM[_JsonAnyListM]]):
    ...

JsonDictOfListsOfDictsModel

Bases: Model[_JsonDictM[_JsonListM[_JsonAnyDictM]]]

Source code in src/omnipy/components/json/models.py

class JsonDictOfListsOfDictsModel(Model[_JsonDictM[_JsonListM[_JsonAnyDictM]]]):
    ...

JsonDictOfListsOfScalarsModel

Bases: Model[_JsonDictM[_JsonListOfScalars]]

Source code in src/omnipy/components/json/models.py

class JsonDictOfListsOfScalarsModel(Model[_JsonDictM[_JsonListOfScalars]]):
    ...

JsonDictOfNestedListsModel

Bases: Model[_JsonDictM[_JsonNestedListsM]]

Source code in src/omnipy/components/json/models.py

class JsonDictOfNestedListsModel(Model[_JsonDictM[_JsonNestedListsM]]):
    ...

JsonDictOfScalarsModel

Bases: Model[_JsonDictOfScalars]

Source code in src/omnipy/components/json/models.py

class JsonDictOfScalarsModel(Model[_JsonDictOfScalars]):
    ...

JsonListModel

Bases: Model[_JsonAnyListM]

JsonListModel is a limited JSON model supporting only JSON content that has a list (or "array" in JSON nomenclature) at the root. The content of the top-level list can be any JSON content, though, any levels deep.

Examples:

>>> my_json = JsonListModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
>>> my_json.to_data()
[True, {'a': None, 'b': [1, 12.5, 'abc']}]
>>> my_json.to_json()
'[true, {"a": null, "b": [1, 12.5, "abc"]}]'
>>> print(my_json.to_json(pretty=True))
[
  true,
  {
    "a": null,
    "b": [
      1,
      12.5,
      "abc"
    ]
  }
]
>>> try:
...     my_json = JsonListModel({'a': None, 'b': [1, 12.5, {'abc': 123}]})
... except Exception as e:
...     print(str(e).splitlines()[0])
3 validation errors for JsonListModel

Source code in src/omnipy/components/json/models.py

class JsonListModel(Model[_JsonAnyListM]):
    """
    JsonListModel is a limited JSON model supporting only JSON content
    that has a list (or "array" in JSON nomenclature) at the root. The
    content of the top-level list can be any JSON content, though, any
    levels deep.

    Examples:
        >>> my_json = JsonListModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
        >>> my_json.to_data()
        [True, {'a': None, 'b': [1, 12.5, 'abc']}]
        >>> my_json.to_json()
        '[true, {"a": null, "b": [1, 12.5, "abc"]}]'
        >>> print(my_json.to_json(pretty=True))
        [
          true,
          {
            "a": null,
            "b": [
              1,
              12.5,
              "abc"
            ]
          }
        ]
        >>> try:
        ...     my_json = JsonListModel({'a': None, 'b': [1, 12.5, {'abc': 123}]})
        ... except Exception as e:
        ...     print(str(e).splitlines()[0])
        3 validation errors for JsonListModel
    """

JsonListOfDictsModel

Bases: Model[_JsonListM[_JsonAnyDictM]]

Source code in src/omnipy/components/json/models.py

class JsonListOfDictsModel(Model[_JsonListM[_JsonAnyDictM]]):
    ...

JsonListOfDictsOfScalarsModel

Bases: Model[_JsonListM[_JsonDictOfScalars]]

Source code in src/omnipy/components/json/models.py

class JsonListOfDictsOfScalarsModel(Model[_JsonListM[_JsonDictOfScalars]]):
    ...

JsonListOfListsModel

Bases: Model[_JsonListM[_JsonAnyListM]]

Source code in src/omnipy/components/json/models.py

class JsonListOfListsModel(Model[_JsonListM[_JsonAnyListM]]):
    ...

JsonListOfListsOfScalarsModel

Bases: Model[_JsonListM[_JsonListOfScalars]]

Source code in src/omnipy/components/json/models.py

class JsonListOfListsOfScalarsModel(Model[_JsonListM[_JsonListOfScalars]]):
    ...

JsonListOfNestedDictsModel

Bases: Model[_JsonListM[_JsonNestedDictsM]]

Source code in src/omnipy/components/json/models.py

class JsonListOfNestedDictsModel(Model[_JsonListM[_JsonNestedDictsM]]):
    ...

JsonListOfScalarsModel

Bases: Model[_JsonListOfScalars]

Source code in src/omnipy/components/json/models.py

class JsonListOfScalarsModel(Model[_JsonListOfScalars]):
    ...

JsonListOrDictModel

Bases: ParseStrAsJsonMixin[_JsonListOfDictUnion], Model[_JsonListOfDictUnion]

JsonListOrDictModel is a general JSON model supporting any JSON content except scalar data.

Examples:

>>> my_json = JsonListOrDictModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
>>> my_json.to_data()
[True, {'a': None, 'b': [1, 12.5, 'abc']}]
>>> my_json.to_json()
'[true, {"a": null, "b": [1, 12.5, "abc"]}]'
>>> print(my_json.to_json(pretty=True))
[
  true,
  {
    "a": null,
    "b": [
      1,
      12.5,
      "abc"
    ]
  }
]
>>> try:
...     my_json = JsonListOrDictModel(123)  # scalars not supported
... except Exception as e:
...     print(str(e).splitlines()[0])
34 validation errors for JsonListOrDictModel

METHOD	DESCRIPTION
start_chars_for_json_content

Source code in src/omnipy/components/json/models.py

class JsonListOrDictModel(ParseStrAsJsonMixin[_JsonListOfDictUnion], Model[_JsonListOfDictUnion]):
    """JsonListOrDictModel is a general JSON model supporting any JSON
    content except scalar data.

    Examples:
        >>> my_json = JsonListOrDictModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
        >>> my_json.to_data()
        [True, {'a': None, 'b': [1, 12.5, 'abc']}]
        >>> my_json.to_json()
        '[true, {"a": null, "b": [1, 12.5, "abc"]}]'
        >>> print(my_json.to_json(pretty=True))
        [
          true,
          {
            "a": null,
            "b": [
              1,
              12.5,
              "abc"
            ]
          }
        ]
        >>> try:
        ...     my_json = JsonListOrDictModel(123)  # scalars not supported
        ... except Exception as e:
        ...     print(str(e).splitlines()[0])
        34 validation errors for JsonListOrDictModel
    """
    @classmethod
    def start_chars_for_json_content(cls) -> str:
        return '[{'

    if TYPE_CHECKING and TYPE_CHECKER != 'mypy':

        @overload
        def __new__(cls, value: IsList | _JsonAnyListM) -> _JsonAnyListM:
            ...

        @overload
        def __new__(cls, value: IsDict | _JsonAnyDictM) -> _JsonAnyDictM:
            ...

        @overload
        def __new__(cls, value: IsStr | object) -> AnyJsonListOrDictModel:
            ...

        def __new__(cls, value: _JsonListOrDictContent | object) -> AnyJsonListOrDictModel:
            ...

start_chars_for_json_content classmethod

start_chars_for_json_content() -> str

Source code in src/omnipy/components/json/models.py

@classmethod
def start_chars_for_json_content(cls) -> str:
    return '[{'

JsonModel

Bases: ParseStrAsJsonMixin[_JsonAnyUnion], Model[_JsonAnyUnion]

JsonModel is a general JSON model supporting any JSON content, any levels deep.

Examples:

>>> my_int_json = JsonModel(123)
>>> my_int_json.to_data()
123
>>> my_int_json.to_json()
'123'
>>> my_json = JsonModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
>>> my_json.to_data()
[True, {'a': None, 'b': [1, 12.5, 'abc']}]
>>> my_json.to_json()
'[true, {"a": null, "b": [1, 12.5, "abc"]}]'
>>> print(my_json.to_json(pretty=True))
[
  true,
  {
    "a": null,
    "b": [
      1,
      12.5,
      "abc"
    ]
  }
]
>>> try:
...     my_json = JsonModel([{'a': [1, 2, 1+2j]}])  # nested complex number
... except Exception as e:
...     print(str(e).splitlines()[0])
34 validation errors for JsonModel

Source code in src/omnipy/components/json/models.py

class JsonModel(ParseStrAsJsonMixin[_JsonAnyUnion], Model[_JsonAnyUnion]):
    """
    JsonModel is a general JSON model supporting any JSON content, any
    levels deep.

    Examples:
        >>> my_int_json = JsonModel(123)
        >>> my_int_json.to_data()
        123
        >>> my_int_json.to_json()
        '123'
        >>> my_json = JsonModel([True, {'a': None, 'b': [1, 12.5, 'abc']}])
        >>> my_json.to_data()
        [True, {'a': None, 'b': [1, 12.5, 'abc']}]
        >>> my_json.to_json()
        '[true, {"a": null, "b": [1, 12.5, "abc"]}]'
        >>> print(my_json.to_json(pretty=True))
        [
          true,
          {
            "a": null,
            "b": [
              1,
              12.5,
              "abc"
            ]
          }
        ]
        >>> try:
        ...     my_json = JsonModel([{'a': [1, 2, 1+2j]}])  # nested complex number
        ... except Exception as e:
        ...     print(str(e).splitlines()[0])
        34 validation errors for JsonModel
    """

    if TYPE_CHECKING and TYPE_CHECKER != 'mypy':

        @overload
        def __new__(cls, value: None) -> Model[None]:
            ...

        @overload
        def __new__(cls, value: IsBool) -> Model_bool:  # pyright: ignore[reportOverlappingOverload]
            ...

        @overload
        def __new__(cls, value: IsInt) -> Model_int:
            ...

        @overload
        def __new__(cls, value: IsFloat) -> Model_float:
            ...

        @overload
        def __new__(cls, value: IsList | _JsonAnyListM) -> _JsonAnyListM:
            ...

        @overload
        def __new__(cls, value: IsDict | _JsonAnyDictM) -> _JsonAnyDictM:
            ...

        @overload
        def __new__(cls, value: IsStr | object) -> AnyJsonModel:
            ...

        def __new__(cls, value: _JsonAnyUnionContent | object) -> AnyJsonModel:
            ...

JsonNestedDictsModel

Bases: Model[_JsonNestedDictsM]

Source code in src/omnipy/components/json/models.py

class JsonNestedDictsModel(Model[_JsonNestedDictsM]):
    ...

JsonNestedListsModel

Bases: Model[_JsonNestedListsM]

Source code in src/omnipy/components/json/models.py

class JsonNestedListsModel(Model[_JsonNestedListsM]):
    ...

JsonOnlyDictsModel

Bases: Model[_JsonOnlyDictsUnion]

Source code in src/omnipy/components/json/models.py

class JsonOnlyDictsModel(Model[_JsonOnlyDictsUnion]):
    if TYPE_CHECKING and TYPE_CHECKER != 'mypy':

        @overload
        def __new__(cls, value: None) -> Model[None]:
            ...

        @overload
        def __new__(cls, value: IsBool) -> Model_bool:  # pyright: ignore[reportOverlappingOverload]
            ...

        @overload
        def __new__(cls, value: IsInt) -> Model_int:
            ...

        @overload
        def __new__(cls, value: IsFloat) -> Model_float:
            ...

        @overload
        def __new__(cls, value: IsStr) -> Model_str:
            ...

        @overload
        def __new__(cls, value: IsDict | _JsonNestedDictsM) -> _JsonNestedDictsM:
            ...

        @overload
        def __new__(cls, value: object) -> AnyJsonOnlyDictsModel:
            ...

        def __new__(cls, value: _JsonOnlyDictsUnionContent | object) -> AnyJsonOnlyDictsModel:
            ...

JsonOnlyListsModel

Bases: Model[_JsonOnlyListsUnion]

Source code in src/omnipy/components/json/models.py

class JsonOnlyListsModel(Model[_JsonOnlyListsUnion]):
    if TYPE_CHECKING and TYPE_CHECKER != 'mypy':

        @overload
        def __new__(cls, value: None) -> Model[None]:
            ...

        @overload
        def __new__(cls, value: IsBool) -> Model_bool:  # pyright: ignore[reportOverlappingOverload]
            ...

        @overload
        def __new__(cls, value: IsInt) -> Model_int:
            ...

        @overload
        def __new__(cls, value: IsFloat) -> Model_float:
            ...

        @overload
        def __new__(cls, value: IsStr) -> Model_str:
            ...

        @overload
        def __new__(cls, value: IsList | _JsonNestedListsM) -> _JsonNestedListsM:
            ...

        @overload
        def __new__(cls, value: object) -> AnyJsonOnlyListsModel:
            ...

        def __new__(cls, value: _JsonOnlyListsUnionContent | object) -> AnyJsonOnlyListsModel:
            ...

JsonScalarModel

Bases: Model[JsonScalar]

JsonScalarModel is a limited JSON model supporting only scalar JSON content, e.g. the basic types: None, int, float, str, and bool. Lists and dicts (or "objects") are not supported.

Examples:

>>> my_none = JsonScalarModel(None)
>>> my_none.to_data(), my_none.to_json()
(None, 'null')
>>> my_int = JsonScalarModel(123)
>>> my_int.to_data(), my_int.to_json()
(123, '123')
>>> my_float = JsonScalarModel(12.3)
>>> my_float.to_data(), my_float.to_json()
(12.3, '12.3')
>>> my_str = JsonScalarModel('abc')
>>> my_str.to_data(), my_str.to_json()
(abc, '"abc"')
>>> my_bool = JsonScalarModel(False)
>>> my_bool.to_data(), my_bool.to_json()
(False, '"false"')
>>> try:
...     my_json = JsonScalarModel([123])
... except Exception as e:
...     print(str(e).splitlines()[0])
6 validation errors for JsonScalarModel

Source code in src/omnipy/components/json/models.py

class JsonScalarModel(Model[JsonScalar]):
    """
    JsonScalarModel is a limited JSON model supporting only scalar JSON
    content, e.g. the basic types: `None`, `int`, `float`, `str`, and
    `bool`. Lists and dicts (or "objects") are not supported.

    Examples:
        >>> my_none = JsonScalarModel(None)
        >>> my_none.to_data(), my_none.to_json()
        (None, 'null')
        >>> my_int = JsonScalarModel(123)
        >>> my_int.to_data(), my_int.to_json()
        (123, '123')
        >>> my_float = JsonScalarModel(12.3)
        >>> my_float.to_data(), my_float.to_json()
        (12.3, '12.3')
        >>> my_str = JsonScalarModel('abc')
        >>> my_str.to_data(), my_str.to_json()
        (abc, '"abc"')
        >>> my_bool = JsonScalarModel(False)
        >>> my_bool.to_data(), my_bool.to_json()
        (False, '"false"')
        >>> try:
        ...     my_json = JsonScalarModel([123])
        ... except Exception as e:
        ...     print(str(e).splitlines()[0])
        6 validation errors for JsonScalarModel
    """

    if TYPE_CHECKING and TYPE_CHECKER != 'mypy':

        @overload
        def __new__(cls, value: None) -> Model[None]:
            ...

        @overload
        def __new__(cls, value: IsBool) -> Model_bool:  # pyright: ignore[reportOverlappingOverload]
            ...

        @overload
        def __new__(cls, value: IsInt) -> Model_int:
            ...

        @overload
        def __new__(cls, value: IsFloat) -> Model_float:
            ...

        @overload
        def __new__(cls, value: IsStr) -> Model_str:
            ...

        @overload
        def __new__(cls, value: object) -> AnyJsonScalarModel:
            ...

        def __new__(cls, value: JsonScalar | object) -> AnyJsonScalarModel:
            ...

ParseStrAsJsonMixin

Bases: Generic[_RootT]

METHOD	DESCRIPTION
start_chars_for_json_content

Source code in src/omnipy/components/json/models.py

class ParseStrAsJsonMixin(Generic[_RootT]):
    @classmethod
    def start_chars_for_json_content(cls) -> str:
        return '[{0123456789-tfn'  # not [{"0123456789-tfn'

    @classmethod
    def _parse_data(cls, data: Any) -> _RootT:
        cls_as_model = cast(type[Model[_RootT]], cls)
        if isinstance(data, str):
            if len(data) > 0 and data[0] in cls.start_chars_for_json_content():
                # Potentially a string representing JSON entities.
                parsed_json = parse_str_as_json(data)
                if not isinstance(parsed_json, pyd.UndefinedType):
                    if isinstance(parsed_json, str):
                        return cast(_RootT, parsed_json)
                    return cls_as_model(parsed_json).content

        return cast(_RootT, data)

start_chars_for_json_content classmethod

start_chars_for_json_content() -> str

Source code in src/omnipy/components/json/models.py

@classmethod
def start_chars_for_json_content(cls) -> str:
    return '[{0123456789-tfn'  # not [{"0123456789-tfn'

is_json_model_instance_hack

is_json_model_instance_hack(obj: Any) -> bool

Check if the given object is an instance of a JSON model class. Temporary solution to identify JSON model classes for output formatting.

(Does not work for JsonCustomListModel and JsonCustomDictModel)

PARAMETER	DESCRIPTION
obj	The object to check. TYPE: Any

RETURNS	DESCRIPTION
bool	True if the object is an instance of a JSON model class, False otherwise.

Source code in src/omnipy/components/json/models.py

def is_json_model_instance_hack(obj: Any) -> bool:
    """
    Check if the given object is an instance of a JSON model class.
    Temporary solution to identify JSON model classes for output formatting.

    (Does not work for JsonCustomListModel and JsonCustomDictModel)

    Args:
        obj: The object to check.

    Returns:
        True if the object is an instance of a JSON model class, False
        otherwise.
    """

    if is_model_instance(obj):
        plain_class = ensure_plain_type(obj.__class__)
        return plain_class in _all_json_model_classes
    return False