Method get_schema_object

robyn/openapi.py:577–680

Get the schema object for request/response body @param parameter: name of the parameter @param param_type: Any the type to be inferred @return: dict the properties object

(self, parameter: str, param_type: Any)

        return "string"

    def get_schema_object(self, parameter: str, param_type: Any) -> dict:
        """
        Get the schema object for request/response body

        @param parameter: name of the parameter
        @param param_type: Any the type to be inferred
        @return: dict the properties object
        """

        properties: dict = {
            "title": parameter.capitalize(),
        }

        # Primitive scalars (int, str, bool, float, dict, list).
        if param_type in _PRIMITIVE_TYPE_NAMES:
            properties["type"] = _PRIMITIVE_TYPE_NAMES[param_type]
            return properties

        # Special stdlib leaf types (datetime, date, UUID, Decimal, bytes, ...).
        # Pydantic-free handlers can return these without crashing or rendering
        # as a bare object (#1124).
        if isinstance(param_type, type) and param_type in _LEAF_TYPE_SCHEMAS:
            properties.update(_LEAF_TYPE_SCHEMAS[param_type])
            return properties

        # typing.Any -> any value, no constraints.
        if param_type is Any:
            return properties

        origin = get_origin(param_type)
        args = get_args(param_type)

        # typing.Literal[...] -> an enum of literal values.
        if origin is typing.Literal:
            properties["enum"] = list(args)
            inferred = type(args[0]) if args else str
            properties["type"] = _PRIMITIVE_TYPE_NAMES.get(inferred, "string")
            return properties

        # enum.Enum subclass -> enum of member values.
        if isinstance(param_type, type) and issubclass(param_type, enum.Enum):
            members = list(param_type)
            properties["enum"] = [member.value for member in members]
            if members:
                properties["type"] = _PRIMITIVE_TYPE_NAMES.get(type(members[0].value), "string")
            return properties

        # Sequence generics (list[X], tuple[X, ...], set[X]) -> array.
        if origin in (list, tuple, set, frozenset):
            properties["type"] = "array"
            if args:
                item_type = args[0]
                properties["items"] = self.get_schema_object(f"{parameter}_item", item_type)
            return properties

        # Mapping generics (dict[str, V]) -> object with typed additionalProperties.
        if origin is dict:
            properties["type"] = "object"