python-sdk/src/conductor/client/http/models/request_param.py at 9ea31b7a2603e2f286b32e8b8b22d652da35ff6a · conductor-oss/python-sdk · GitHub

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
from dataclasses import dataclass
from typing import Optional, Any
import six


@dataclass
class Schema:
    """Schema definition for request parameters."""

    swagger_types = {
        'type': 'str',
        'format': 'str',
        'default_value': 'object'
    }

    attribute_map = {
        'type': 'type',
        'format': 'format',
        'default_value': 'defaultValue'
    }

    type: Optional[str] = None
    format: Optional[str] = None
    default_value: Optional[Any] = None

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}
        for attr, _ in six.iteritems(self.swagger_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value
        return result

    def __str__(self):
        return f"Schema(type='{self.type}', format='{self.format}', default_value={self.default_value})"


@dataclass
class RequestParam:
    """Request parameter model for API endpoints."""

    swagger_types = {
        'name': 'str',
        'type': 'str',
        'required': 'bool',
        'schema': 'Schema'
    }

    attribute_map = {
        'name': 'name',
        'type': 'type',
        'required': 'required',
        'schema': 'schema'
    }

    name: Optional[str] = None
    type: Optional[str] = None  # Query, Header, Path, etc.
    required: bool = False
    schema: Optional[Schema] = None

    def to_dict(self):
        """Returns the model properties as a dict"""
        result = {}
        for attr, _ in six.iteritems(self.swagger_types):
            value = getattr(self, attr)
            if isinstance(value, list):
                result[attr] = list(map(
                    lambda x: x.to_dict() if hasattr(x, "to_dict") else x,
                    value
                ))
            elif hasattr(value, "to_dict"):
                result[attr] = value.to_dict()
            elif isinstance(value, dict):
                result[attr] = dict(map(
                    lambda item: (item[0], item[1].to_dict())
                    if hasattr(item[1], "to_dict") else item,
                    value.items()
                ))
            else:
                result[attr] = value
        return result

    def __str__(self):
        return f"RequestParam(name='{self.name}', type='{self.type}', required={self.required})"