SimpleDialectType = typing.Any
try:
import clevercsv
import clevercsv.dialect
SimpleDialectType = clevercsv.dialect.SimpleDialect
except ImportError: # pragma: no cover
clevercsv = None
# Type definitions for helper dictionaries
CommaInfoParamsType = typing.TypedDict(
"CommaInfoParamsType",
{
#
"dialect": DialectType,
#
"simple_dialect": SimpleDialectType,
"has_header": bool,
"line_terminator": str,
})
CommaInfoType = typing.TypedDict(
"CommaInfoType",
{
# the parsed CSV rows
"rows": typing.List[typing.List[str]],
# a raw sample of the original file
"sample": str,
json_list_t = utils.json_list_t
json_primitive_t = utils.json_primitive_t
json_value_t = utils.json_value_t
# The following would be much more useful once GH/python/mypy#4441 is implemented…
if ty.TYPE_CHECKING:
# Lame workaround for type checkers
CommonArgs = ty.Union[bool, http.auth_t, http.cookies_t, http.reqdata_sync_t,
http.headers_t, http.timeout_t]
elif hasattr(ty, "TypedDict"):
# This is what type checkers should actually use
CommonArgs = ty.TypedDict("CommonArgs", {
"offline": bool,
"return_result": bool,
"auth": http.auth_t,
"cookies": http.cookies_t,
"data": http.reqdata_sync_t,
"headers": http.headers_t,
"timeout": http.timeout_t,
})
else:
CommonArgs = ty.Dict[str, ty.Any]
# work around GH/mypy/mypy#731: no recursive structural types yet
response_item_t = ty.Union[
json_primitive_t,
"ResponseBase",
"_response_item_list_t"
]
DateTimeBase,
BoolBase,
BinaryBase,
Schema,
_SchemaValidator,
_SchemaTypeChecker,
_SchemaEnumMaker
)
from petstore_api.model.user import User
# path params
UsernameSchema = StrSchema
RequestRequiredPathParams = typing.TypedDict(
'RequestRequiredPathParams',
{
'username': UsernameSchema,
}
)
RequestOptionalPathParams = typing.TypedDict(
'RequestOptionalPathParams',
{
},
total=False
)
class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
pass
request_path_username = api_client.PathParameter(
cls,
*args: typing.Union[dict, frozendict, ],
someProp: typing.Union[someProp, Unset] = unset,
_configuration: typing.Optional[Configuration] = None,
**kwargs: typing.Type[Schema],
) -> 'CompositionInPropertySchema':
return super().__new__(
cls,
*args,
someProp=someProp,
_configuration=_configuration,
**kwargs,
)
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {})
RequestOptionalQueryParams = typing.TypedDict(
'RequestOptionalQueryParams', {
'compositionAtRoot': CompositionAtRootSchema,
'compositionInProperty': CompositionInPropertySchema,
},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_composition_at_root = api_client.QueryParameter(
name="compositionAtRoot",
'type': 'integer'
},
'b': {
'type': 'string'
}
},
'required': ['a', 'b']
}))
if sys.version_info >= (3, 8):
TYPE_HINT_TEST_PARAMS.append((typing.Literal['x', 'y'], {
'enum': ['x', 'y'],
'type': 'string'
}))
TYPE_HINT_TEST_PARAMS.append(
(typing.TypedDict('TD', foo=int, bar=typing.List[str]), {
'type': 'object',
'properties': {
'foo': {
'type': 'integer'
},
'bar': {
'type': 'array',
'items': {
'type': 'string'
}
}
}
}))
TYPE_HINT_TEST_PARAMS.append((
typing.List[typing.TypedDict('TD', foo=str,
from petstore_api.model.order import Order
# path params
class OrderIdSchema(
_SchemaValidator(
inclusive_maximum=5,
inclusive_minimum=1,
), Int64Schema):
pass
RequestRequiredPathParams = typing.TypedDict('RequestRequiredPathParams', {
'order_id': OrderIdSchema,
})
RequestOptionalPathParams = typing.TypedDict('RequestOptionalPathParams', {},
total=False)
class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
pass
request_path_order_id = api_client.PathParameter(
name="order_id",
style=api_client.ParameterStyle.SIMPLE,
schema=OrderIdSchema,
required=True,
)
class UrlSchema(ListSchema):
_items = StrSchema
class ContextSchema(ListSchema):
_items = StrSchema
RefParamSchema = StringWithValidation
RequestRequiredQueryParams = typing.TypedDict(
'RequestRequiredQueryParams', {
'pipe': PipeSchema,
'ioutil': IoutilSchema,
'http': HttpSchema,
'url': UrlSchema,
'context': ContextSchema,
'refParam': RefParamSchema,
})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_pipe = api_client.QueryParameter(
name="pipe",
DATA_DIR = os.path.join(
os.path.dirname(os.path.realpath(__file__)),
"data",
)
CommaTableTestingExtrasType = typing.TypedDict(
"CommaTableTestingExtrasType", {
# the fixture table
"table": comma.classes.table.CommaTable,
# coordinates to a record that is guaranteed to exist
"record_index": int,
"field_index": int,
"field_name": str,
"original_value": typing.Any,
# references to the record and a copy
"some_record": comma.classes.row.CommaRow,
"some_record_copy": comma.classes.row.CommaRow,
})
# NOTE: refactor to make this an abstract test class?
# noinspection DuplicatedCode
class TestSacramentoRealEstateTransactions:
FILENAME = "Sacramentorealestatetransactions.csv"
FILEPATH = os.path.join(DATA_DIR, FILENAME)
Node = t.TypedDict(
"Node",
{
"id": int,
"x": float,
"y": float,
"color": str,
"text": str,
"type": NodeType,
"scheme": str,
"descriptors": t.Dict[str, int],
"cqdesc": t.Dict[str, t.Any],
"visible": bool,
"participantID": str,
"w": float,
"h": float,
#
# Specific to original OVA
#
"imgurl": t.Optional[str],
#
# Specific to ReCAP OVA
#
"majorClaim": t.Optional[bool],
"is_check_worthy": t.Optional[str],
"source": t.Optional[str],
"text_begin": t.Optional[t.List[int]],
"text_end": t.Optional[t.List[int]],
"text_length": t.Optional[t.List[int]],
"comment": t.Optional[str],
"annotator": t.Optional[str],
"date": t.Optional[str],
},
)
def AVAILABLE(cls):
return cls("available")
@classmethod
@property
def PENDING(cls):
return cls("pending")
@classmethod
@property
def SOLD(cls):
return cls("sold")
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {
'status': StatusSchema,
})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_status = api_client.QueryParameter(
name="status",
style=api_client.ParameterStyle.FORM,
schema=StatusSchema,
required=True,
from openapi_client.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
from openapi_client.model.queue import Queue
# path params
NumberSchema = StrSchema
RequestRequiredPathParams = typing.TypedDict('RequestRequiredPathParams', {
'number': NumberSchema,
})
RequestOptionalPathParams = typing.TypedDict('RequestOptionalPathParams', {},
total=False)
class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
pass
request_path_number = api_client.PathParameter(
name="number",
style=api_client.ParameterStyle.SIMPLE,
schema=NumberSchema,
required=True,
)
from frozendict import frozendict # noqa: F401
from openapi_client.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
# query params
StartSchema = IntSchema
DownloadSchema = BoolSchema
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {
'start': StartSchema,
'download': DownloadSchema,
},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_start = api_client.QueryParameter(
name="start",
style=api_client.ParameterStyle.FORM,
from frozendict import frozendict # noqa: F401
from openapi_client.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
# query params
StartSchema = StrSchema
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {
'start': StartSchema,
})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_start = api_client.QueryParameter(
name="start",
style=api_client.ParameterStyle.FORM,
schema=StartSchema,
required=True,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
_path = '/api/json'
_method = 'HEAD'
_auth = [
'jenkins_auth',
]
XJenkinsSchema = StrSchema
x_jenkins_parameter = api_client.HeaderParameter(
name="x-jenkins",
style=api_client.ParameterStyle.SIMPLE,
schema=XJenkinsSchema,
)
ResponseHeadersFor200 = typing.TypedDict('ResponseHeadersFor200', {
'x-jenkins': XJenkinsSchema,
})
@dataclass
class ApiResponseFor200(api_client.ApiResponse):
response: urllib3.HTTPResponse
headers: ResponseHeadersFor200
body: Unset = unset
_response_for_200 = api_client.OpenApiResponse(response_cls=ApiResponseFor200,
headers=[
x_jenkins_parameter,
])
else:
user = SlackUser.from_any(value=value)
if not only_existing or user.exists:
return user
return
# =============================================================================
SlackGroupMember = typing.TypedDict(
"SlackGroupMember",
{
"display": str,
"value": str,
},
total=True,
)
"""
"""
@slacktivate.slack.retry.slack_retry
def lookup_group_by_id(group_id: str) -> typing.Optional[slack_scim.Group]:
try:
result = slacktivate.slack.clients.scim().read_group(group_id)
except slack_scim.SCIMApiError as err:
# handle non-existing user error
if err.status == 404:
return
line_type: str
visible: bool
ActionResult = Optional[FinalizeRequest]
@dataclass
class ViewProcessTracking:
amount_unfiltered_rows: int = 0
amount_filtered_rows: int = 0
amount_rows_after_limit: int = 0
duration_fetch_rows: Snapshot = Snapshot.null()
duration_filter_rows: Snapshot = Snapshot.null()
duration_view_render: Snapshot = Snapshot.null()
CustomAttr = typing.TypedDict(
"CustomAttr",
{
"title": str,
"help": str,
"name": str,
"topic": str,
"type": str,
"add_custom_macro": bool,
"show_in_table": bool,
},
total=True,
)
DateTimeBase,
BoolBase,
BinaryBase,
Schema,
_SchemaValidator,
_SchemaTypeChecker,
_SchemaEnumMaker
)
from petstore_api.model.api_response import ApiResponse
# path params
PetIdSchema = Int64Schema
RequestRequiredPathParams = typing.TypedDict(
'RequestRequiredPathParams',
{
'petId': PetIdSchema,
}
)
RequestOptionalPathParams = typing.TypedDict(
'RequestOptionalPathParams',
{
},
total=False
)
class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
pass
request_path_pet_id = api_client.PathParameter(
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
# query params
Model1Schema = StrSchema
ABSchema = StrSchema
AbSchema = StrSchema
ModelSelfSchema = StrSchema
ABSchema = StrSchema
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {
'1': Model1Schema,
'aB': ABSchema,
'Ab': AbSchema,
'self': ModelSelfSchema,
'A-B': ABSchema,
},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
from petstore_api.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, DateSchema, DateTimeSchema, DecimalSchema, BoolSchema,
BinarySchema, NoneSchema, none_type, InstantiationMetadata, Unset, unset,
ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase, Int32Base,
Int64Base, Float32Base, Float64Base, NumberBase, DateBase, DateTimeBase,
BoolBase, BinaryBase, Schema, _SchemaValidator, _SchemaTypeChecker,
_SchemaEnumMaker)
from petstore_api.model.user import User
# query params
QuerySchema = StrSchema
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {
'query': QuerySchema,
})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_query = api_client.QueryParameter(
name="query",
style=api_client.ParameterStyle.FORM,
schema=QuerySchema,
required=True,
from petstore_api.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, DateSchema, DateTimeSchema, DecimalSchema, BoolSchema,
BinarySchema, NoneSchema, none_type, Configuration, Unset, unset,
ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase, Int32Base,
Int64Base, Float32Base, Float64Base, NumberBase, DateBase, DateTimeBase,
BoolBase, BinaryBase, Schema, _SchemaValidator, _SchemaTypeChecker,
_SchemaEnumMaker)
# query params
UsernameSchema = StrSchema
PasswordSchema = StrSchema
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {
'username': UsernameSchema,
'password': PasswordSchema,
})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_username = api_client.QueryParameter(
name="username",
style=api_client.ParameterStyle.FORM,
schema=UsernameSchema,
required=True,
from frozendict import frozendict # noqa: F401
from openapi_client.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
# path params
KeySchema = IntSchema
RequestRequiredPathParams = typing.TypedDict('RequestRequiredPathParams', {
'key': KeySchema,
})
RequestOptionalPathParams = typing.TypedDict('RequestOptionalPathParams', {},
total=False)
class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
pass
request_path_key = api_client.PathParameter(
name="key",
style=api_client.ParameterStyle.SIMPLE,
schema=KeySchema,
required=True,
)
pass
class RateLimitException(Exception):
pass
class InvalidKeyException(Exception):
pass
class ApiErrBadData(Exception):
pass
ServerGroup = typing.TypedDict("ServerGroup", {"sgid": int, "name": str})
SyncGroupChanges = typing.TypedDict("SyncGroupChanges", {
"removed": typing.List[str],
"added": typing.List[str]
})
def limit_fetch_api(
endpoint: str,
api_key: typing.Optional[str] = None,
level: int = 0,
exc: Exception = None,
) -> typing.Dict:
if level >= 3:
if isinstance(exc, RateLimitException):
raise RateLimitException(
import typing as T
td = T.TypedDict("name", {"field": str}, total=False)
from datetime import date, datetime # noqa: F401
from frozendict import frozendict # noqa: F401
from petstore_api.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, DateSchema, DateTimeSchema, DecimalSchema, BoolSchema,
BinarySchema, NoneSchema, none_type, Configuration, Unset, unset,
ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase, Int32Base,
Int64Base, Float32Base, Float64Base, NumberBase, DateBase, DateTimeBase,
BoolBase, BinaryBase, Schema, _SchemaValidator, _SchemaTypeChecker,
_SchemaEnumMaker)
# header params
ApiKeySchema = StrSchema
RequestRequiredHeaderParams = typing.TypedDict('RequestRequiredHeaderParams',
{})
RequestOptionalHeaderParams = typing.TypedDict('RequestOptionalHeaderParams', {
'api_key': ApiKeySchema,
},
total=False)
class RequestHeaderParams(RequestRequiredHeaderParams,
RequestOptionalHeaderParams):
pass
request_header_api_key = api_client.HeaderParameter(
name="api_key",
style=api_client.ParameterStyle.SIMPLE,
schema=ApiKeySchema,
from datetime import date, datetime # noqa: F401
from frozendict import frozendict # noqa: F401
from openapi_client.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
# header params
JenkinsCrumbSchema = StrSchema
RequestRequiredHeaderParams = typing.TypedDict('RequestRequiredHeaderParams',
{})
RequestOptionalHeaderParams = typing.TypedDict(
'RequestOptionalHeaderParams', {
'Jenkins-Crumb': JenkinsCrumbSchema,
},
total=False)
class RequestHeaderParams(RequestRequiredHeaderParams,
RequestOptionalHeaderParams):
pass
request_header_jenkins_crumb = api_client.HeaderParameter(
name="Jenkins-Crumb",
style=api_client.ParameterStyle.SIMPLE,
),
Float64Schema
):
@classmethod
@property
def POSITIVE_1_PT_1(cls):
return cls._enum_by_value[1.1](1.1)
@classmethod
@property
def NEGATIVE_1_PT_2(cls):
return cls._enum_by_value[-1.2](-1.2)
RequestRequiredQueryParams = typing.TypedDict(
'RequestRequiredQueryParams',
{
}
)
RequestOptionalQueryParams = typing.TypedDict(
'RequestOptionalQueryParams',
{
'enum_query_string_array': EnumQueryStringArraySchema,
'enum_query_string': EnumQueryStringSchema,
'enum_query_integer': EnumQueryIntegerSchema,
'enum_query_double': EnumQueryDoubleSchema,
},
total=False
)
class RequestQueryParams(RequestRequiredQueryParams, RequestOptionalQueryParams):
from petstore_api.schemas import ( # noqa: F401
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
from petstore_api.model.foo import Foo
# query params
MapBeanSchema = Foo
RequestRequiredQueryParams = typing.TypedDict('RequestRequiredQueryParams', {})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {
'mapBean': MapBeanSchema,
},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_map_bean = api_client.QueryParameter(
name="mapBean",
style=api_client.ParameterStyle.DEEP_OBJECT,
schema=MapBeanSchema,
AnyTypeSchema, ComposedSchema, DictSchema, ListSchema, StrSchema,
IntSchema, Int32Schema, Int64Schema, Float32Schema, Float64Schema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
# query params
SomeVarSchema = StrSchema
SomeVarSchema = StrSchema
SomeVarSchema = StrSchema
RequestRequiredQueryParams = typing.TypedDict(
'RequestRequiredQueryParams', {
'someVar': SomeVarSchema,
'SomeVar': SomeVarSchema,
'some_var': SomeVarSchema,
})
RequestOptionalQueryParams = typing.TypedDict('RequestOptionalQueryParams', {},
total=False)
class RequestQueryParams(RequestRequiredQueryParams,
RequestOptionalQueryParams):
pass
request_query_some_var = api_client.QueryParameter(
name="someVar",
style=api_client.ParameterStyle.FORM,
schema=SomeVarSchema,
NumberSchema, UUIDSchema, DateSchema, DateTimeSchema, DecimalSchema,
BoolSchema, BinarySchema, NoneSchema, none_type, Configuration, Unset,
unset, ComposedBase, ListBase, DictBase, NoneBase, StrBase, IntBase,
Int32Base, Int64Base, Float32Base, Float64Base, NumberBase, UUIDBase,
DateBase, DateTimeBase, BoolBase, BinaryBase, Schema, _SchemaValidator,
_SchemaTypeChecker, _SchemaEnumMaker)
from openapi_client.model.pipeline_run import PipelineRun
# path params
OrganizationSchema = StrSchema
PipelineSchema = StrSchema
RunSchema = StrSchema
RequestRequiredPathParams = typing.TypedDict(
'RequestRequiredPathParams', {
'organization': OrganizationSchema,
'pipeline': PipelineSchema,
'run': RunSchema,
})
RequestOptionalPathParams = typing.TypedDict('RequestOptionalPathParams', {},
total=False)
class RequestPathParams(RequestRequiredPathParams, RequestOptionalPathParams):
pass
request_path_organization = api_client.PathParameter(
name="organization",
style=api_client.ParameterStyle.SIMPLE,
schema=OrganizationSchema,
required=True,
def update_event(self, inp=-1):
self.set_output_val(0, typing.TypedDict(self.input(0), self.input(1)))