Python typing 模块，Container() 实例源码

def get_Generic_parameters(tp, generic_supertype):
    """tp must be a subclass of generic_supertype.
    Retrieves the type values from tp that correspond to parameters
    defined by generic_supertype.

    E.g. get_Generic_parameters(tp, typing.Mapping) is equivalent
    to get_Mapping_key_value(tp) except for the error message.

    Note that get_Generic_itemtype(tp) is not exactly equal to
    get_Generic_parameters(tp, typing.Container), as that method
    additionally contains treatment for typing.Tuple and typing.Iterable.
    """
    try:
        res = _select_Generic_superclass_parameters(tp, generic_supertype)
    except TypeError:
        res = None
    if res is None:
        raise TypeError("%s has no proper parameters defined by %s."%
                (type_str(tp), type_str(generic_supertype)))
    else:
        return tuple(res)

def parse_item_specifier_type(
        specifier, spec_types: Container=None, separator=':'):
    """
    Returns a tuple that splits the string int a specifier, and its specifier
    type.

    Retruns a tuple of (specifier, specifier_type). If no specifier type could
    be found in the set, returns None in place of the specifier_type.

    :param specifier: The specifier string, such as "ip:10.0.0.1".
    :param spec_types: A container whose elements are strings that will be
        recognized as specifier types.
    :param separator: Optional specifier. Defaults to ':'.
    :return: tuple
    """
    if separator in specifier:
        tokens = specifier.split(separator, 1)
        if tokens[0] in spec_types:
            specifier_type = tokens[0]
            specifier = tokens[1].strip()
        else:
            specifier_type = None
    else:
        specifier_type = None
    return specifier, specifier_type

def test_empty(self):
        asg = {Dict, List, Set, pytypes.Empty}

        empty_dict = pytypes.Empty[Dict]
        self.assertEqual(pytypes.deep_type({}), empty_dict)
        self.assertEqual(pytypes.type_str(empty_dict, asg), 'Empty[Dict]')
        self.assertTrue(pytypes.is_subtype(empty_dict, pytypes.Empty))
        #self.assertFalse(pytypes.is_subtype(Dict[str, int], empty_dict))
        self.assertTrue(pytypes.is_subtype(empty_dict, Dict[str, int]))
        self.assertTrue(pytypes.is_subtype(empty_dict, Dict))

        empty_lst = pytypes.Empty[List]
        self.assertEqual(pytypes.deep_type([]), empty_lst)
        self.assertEqual(pytypes.type_str(empty_lst, asg), 'Empty[List]')
        self.assertTrue(pytypes.is_subtype(empty_lst, pytypes.Empty))
        #self.assertFalse(pytypes.is_subtype(List[str], empty_lst))
        self.assertTrue(pytypes.is_subtype(empty_lst, List[int]))
        self.assertTrue(pytypes.is_subtype(empty_lst, List))
        self.assertFalse(pytypes.is_subtype(empty_lst, empty_dict))
        self.assertFalse(pytypes.is_subtype(empty_dict, empty_lst))

        empty_seq = pytypes.Empty[Sequence]
        empty_con = pytypes.Empty[typing.Container]
        self.assertTrue(pytypes.is_subtype(Dict[str, int],
                typing.Container[str]))
        self.assertFalse(pytypes.is_subtype(empty_dict, empty_seq))
        self.assertTrue(pytypes.is_subtype(empty_dict, empty_con))
        self.assertTrue(pytypes.is_subtype(empty_lst, empty_seq))
        self.assertFalse(pytypes.is_subtype(empty_seq, empty_lst))

        empty_set = pytypes.Empty[Set]
        self.assertEqual(pytypes.deep_type(set()), empty_set)
        self.assertEqual(pytypes.type_str(empty_set, asg), 'Empty[Set]')
        self.assertTrue(pytypes.is_subtype(empty_set, pytypes.Empty))
        #self.assertFalse(pytypes.is_subtype(Set[int], empty_set))
        self.assertTrue(pytypes.is_subtype(empty_set, Set[int]))
        self.assertTrue(pytypes.is_subtype(empty_set, Set))

def get_Generic_itemtype(sq, simplify=True):
    """Retrieves the item type from a PEP 484 generic or subclass of such.
    sq must be a typing.Tuple or (subclass of) typing.Iterable or typing.Container.
    Consequently this also works with typing.List, typing.Set and typing.Dict.
    Note that for typing.Dict and mapping types in general, the key type is regarded as item type.
    For typing.Tuple all contained types are returned as a typing.Union.
    If simplify == True some effort is taken to eliminate redundancies in such a union.
    """
    if isinstance(sq, TupleMeta):
        if simplify:
            itm_tps = [x for x in get_Tuple_params(sq)]
            simplify_for_Union(itm_tps)
            return Union[tuple(itm_tps)]
        else:
            return Union[get_Tuple_params(sq)]
    else:
        try:
            res = _select_Generic_superclass_parameters(sq, typing.Container)
        except TypeError:
            res = None
        if res is None:
            try:
                res = _select_Generic_superclass_parameters(sq, typing.Iterable)
            except TypeError:
                pass
        if res is None:
            raise TypeError("Has no itemtype: "+type_str(sq))
        else:
            return res[0]

def __init__(self, required_methods=JSON_CONTENT_REQUIRED_METHODS):
        # type: (Container) -> None
        """Initialize the middleware

        :param required_methods: a collection of HTTP methods for
            which "application/json" should be required as a
            Content-Type header
        """
        log.debug('JSONEnforcer.__init__(%s)', required_methods)
        self._methods = required_methods

def _get_name_for_position(position: List[int], variables: Container[str]) -> str:
        new_name = 'i{}'.format('.'.join(map(str, position)))
        if new_name in variables:
            counter = 1
            while '{}_{}'.format(new_name, counter) in variables:
                counter += 1
            new_name = '{}_{}'.format(new_name, counter)
        return new_name

def assertResponse(
            self,
            method: str,
            path: str,
            expected_code: typing.Union[int, typing.Container[int]],
            json_request_body: typing.Optional[dict]=None,
            expected_error: typing.Optional[ExpectedErrorFields]=None,
            **kwargs) -> DSSAssertResponse:
        """
        Make a request given a HTTP method and a path.  The HTTP status code is checked against `expected_code`.

        If json_request_body is provided, it is serialized and set as the request body, and the content-type of the
        request is set to application/json.

        The first element of the return value is the response object.  The second element of the return value is the
        response text.  Attempt to parse the response body as JSON and return that as the third element of the return
        value.  Otherwise, the third element of the return value is None.

        If expected_error is provided, the content-type is expected to be "application/problem+json" and the response is
        tested in accordance to the documentation of `ExpectedErrorFields`.
        """
        if json_request_body is not None:
            if 'data' in kwargs:
                self.fail("both json_input and data are defined")
            kwargs['data'] = json.dumps(json_request_body)
            if 'headers' not in kwargs:
                kwargs['headers'] = {}
            kwargs['headers']['Content-Type'] = "application/json"

        response = getattr(self.app, method)(path, **kwargs)
        try:
            actual_json = response.json()
        except json.decoder.JSONDecodeError:
            actual_json = None

        try:
            if isinstance(expected_code, collections.abc.Container):
                self.assertIn(response.status_code, expected_code)
            else:
                self.assertEqual(response.status_code, expected_code)

            if expected_error is not None:
                self.assertEqual(response.headers['content-type'], "application/problem+json")
                self.assertEqual(actual_json['code'], expected_error.code)
                self.assertIn('title', actual_json)
                if expected_error.status is not None:
                    self.assertEqual(actual_json['status'], expected_error.status)
                if expected_error.expect_stacktrace is not None:
                    self.assertEqual('stacktrace' in actual_json, expected_error.expect_stacktrace)
        except AssertionError:
            if actual_json is not None:
                print("Response:")
                pprint.pprint(actual_json)
            raise

        return DSSAssertResponse(response, response.content, actual_json)