Python typing.MutableMapping方法代碼示例

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def replace_variables(win_id, arglist):
    """Utility function to replace variables like {url} in a list of args."""
    tabbed_browser = objreg.get('tabbed-browser', scope='window',
                                window=win_id)
    values = {}  # type: typing.MutableMapping[str, str]
    args = []

    def repl_cb(matchobj):
        """Return replacement for given match."""
        var = matchobj.group("var")
        if var not in values:
            values[var] = VARIABLE_REPLACEMENTS[var](tabbed_browser)
        return values[var]

    try:
        for arg in arglist:
            # using re.sub with callback function replaces all variables in a
            # single pass and avoids expansion of nested variables (e.g.
            # "{url}" from clipboard is not expanded)
            args.append(VARIABLE_REPLACEMENT_PATTERN.sub(repl_cb, arg))
    except utils.ClipboardError as e:
        raise cmdutils.CommandError(e)
    return args 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def _get_many_using_multiprocessing(self, async_results) -> Mapping[str, EventBufferValueType]:
        num_process = min(len(async_results), self._sync_parallelism)

        with Pool(processes=num_process) as sync_pool:
            chunksize = max(1, math.floor(math.ceil(1.0 * len(async_results) / self._sync_parallelism)))

            task_id_to_states_and_info = sync_pool.map(
                fetch_celery_task_state,
                async_results,
                chunksize=chunksize)

            states_and_info_by_task_id: MutableMapping[str, EventBufferValueType] = {}
            for task_id, state_or_exception, info in task_id_to_states_and_info:
                if isinstance(state_or_exception, ExceptionWithTraceback):
                    self.log.error(  # pylint: disable=logging-not-lazy
                        CELERY_FETCH_ERR_MSG_HEADER + ":%s\n%s\n",
                        state_or_exception.exception, state_or_exception.traceback
                    )
                else:
                    states_and_info_by_task_id[task_id] = state_or_exception, info
        return states_and_info_by_task_id 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def _get_set_clear(
    mapping: MutableMapping[K, V],
    key: K,
    default_factory: Callable[[], V],
    *,
    clear: bool = False
) -> V:
    try:
        out = mapping[key]
    except KeyError:
        mapping[key] = out = default_factory()

    if clear:
        out.clear()

    return out 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def test_subclassing(self):

        class MMA(typing.MutableMapping):
            pass

        with self.assertRaises(TypeError):  # It's abstract
            MMA()

        class MMC(MMA):
            def __len__(self):
                return 0

        assert len(MMC()) == 0

        class MMB(typing.MutableMapping[KT, VT]):
            def __len__(self):
                return 0

        assert len(MMB()) == 0
        assert len(MMB[str, str]()) == 0
        assert len(MMB[KT, VT]()) == 0 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def build_smartstack_location_dict(
    location: str,
    matched_backends_and_tasks: List[
        Tuple[
            Optional[HaproxyBackend],
            Optional[Union[marathon_tools.MarathonTask, V1Pod]],
        ]
    ],
    should_return_individual_backends: bool = False,
) -> MutableMapping[str, Any]:
    running_backends_count = 0
    backends = []
    for backend, task in matched_backends_and_tasks:
        if backend is None:
            continue
        if backend_is_up(backend):
            running_backends_count += 1
        if should_return_individual_backends:
            backends.append(build_smartstack_backend_dict(backend, task))

    return {
        "name": location,
        "running_backends_count": running_backends_count,
        "backends": backends,
    } 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def _build_smartstack_location_dict_for_backends(
    synapse_host: str,
    registration: str,
    tasks: Sequence[MarathonTask],
    location: str,
    should_return_individual_backends: bool,
) -> MutableMapping[str, Any]:
    sorted_smartstack_backends = sorted(
        smartstack_tools.get_backends(
            registration,
            synapse_host=synapse_host,
            synapse_port=settings.system_paasta_config.get_synapse_port(),
            synapse_haproxy_url_format=settings.system_paasta_config.get_synapse_haproxy_url_format(),
        ),
        key=lambda backend: backend["status"],
        reverse=True,  # put 'UP' backends above 'MAINT' backends
    )
    matched_smartstack_backends_and_tasks = smartstack_tools.match_backends_and_tasks(
        sorted_smartstack_backends, tasks
    )
    return smartstack_tools.build_smartstack_location_dict(
        location,
        matched_smartstack_backends_and_tasks,
        should_return_individual_backends,
    ) 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def get_mesos_non_running_task_dict(
    task: Task, num_tail_lines: int
) -> MutableMapping[str, Any]:
    if num_tail_lines > 0:
        tail_lines = await get_tail_lines_for_mesos_task(
            task, get_short_task_id, num_tail_lines
        )
    else:
        tail_lines = {}

    task_dict = {
        "id": get_short_task_id(task["id"]),
        "hostname": await results_or_unknown(get_short_hostname_from_task(task)),
        "state": task["state"],
        "tail_lines": tail_lines,
    }

    task_start_time = get_first_status_timestamp(task)
    if task_start_time is not None:
        task_dict["deployed_timestamp"] = task_start_time

    return task_dict 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def get_language_strings(self, query: MutableMapping[str, Any], context: PipelineContext = None) -> LanguageStringsDto:
        locale = query["locale"] if "locale" in query else query["platform"].default_locale

        url = "https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/language.json".format(
            version=query["version"],
            locale=locale
        )
        try:
            body = json.loads(self._client.get(url)[0])
        except HTTPError as e:
            raise NotFoundError(str(e)) from e

        body["region"] = query["platform"].region.value
        body["locale"] = locale
        return LanguageStringsDto(body)

    #########
    # Runes #
    ######### 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def get_profile_icon(self, query: MutableMapping[str, Any], context: PipelineContext = None) -> ProfileIconDataDto:
        locale = query["locale"] if "locale" in query else query["platform"].default_locale

        url = "https://ddragon.leagueoflegends.com/cdn/{version}/data/{locale}/profileicon.json".format(
            version=query["version"],
            locale=locale
        )
        try:
            body = json.loads(self._client.get(url)[0])
        except HTTPError as e:
            raise NotFoundError(str(e)) from e

        body["region"] = query["platform"].region.value
        body["locale"] = locale
        body["version"] = query["version"]
        for pi in body["data"].values():
            pi["region"] = body["region"]
            pi["version"] = body["version"]
            pi["locale"] = locale
        return ProfileIconDataDto(body) 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def get_champion_all_rates(self, query: MutableMapping[str, Any], context: PipelineContext = None) -> ChampionAllRatesDto:
        try:
            return self._cache[ChampionRatesDto]
        except KeyError:
            pass
        url = "http://cdn.merakianalytics.com/riot/lol/resources/latest/en-US/championrates.json"
        try:
            body = self._client.get(url)[0]
            body = json.decode(body)
            body["data"] = {int(k): v for k, v in body["data"].items()}
        except HTTPError as e:
            raise NotFoundError(str(e)) from e

        result = ChampionAllRatesDto(**body)
        self._cache[ChampionRatesDto] = result
        return result 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def __init__(self, uuid: str, value: Optional[Sequence[int]],
                 flags: Sequence[str]):
        self.uuid = uuid
        self.value = value
        self.flags = flags
        self.descriptors: MutableMapping[str, GATTDescriptor] = dict() 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def __init__(self, parent=None):
        super().__init__(parent)
        self._cleaned_up = False
        self._filepath = None
        self._proc = None
        self._env = {}  # type: typing.MutableMapping[str, str]
        self._text_stored = False
        self._html_stored = False
        self._args = ()  # type: typing.Tuple[typing.Any, ...]
        self._kwargs = {} 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def _get_call_args(self, win_id):
        """Get arguments for a function call.

        Args:
            win_id: The window id this command should be executed in.

        Return:
            An (args, kwargs) tuple.
        """
        args = []  # type: typing.Any
        kwargs = {}  # type: typing.MutableMapping[str, typing.Any]
        signature = inspect.signature(self.handler)

        for i, param in enumerate(signature.parameters.values()):
            if self._handle_special_call_arg(pos=i, param=param,
                                             win_id=win_id, args=args,
                                             kwargs=kwargs):
                continue

            value = self._get_param_value(param)
            if param.kind == inspect.Parameter.POSITIONAL_OR_KEYWORD:
                args.append(value)
            elif param.kind == inspect.Parameter.VAR_POSITIONAL:
                if value is not None:
                    args += value
            elif param.kind == inspect.Parameter.KEYWORD_ONLY:
                kwargs[param.name] = value
            else:
                raise TypeError("{}: Invalid parameter type {} for argument "
                                "'{}'!".format(
                                    self.name, param.kind, param.name))
        return args, kwargs 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def __init__(self) -> None:
        super().__init__()
        self._partial_objs = {
        }  # type: typing.MutableMapping[_IndexType, typing.Callable[[], None]]
        self.command_only = []  # type: typing.MutableSequence[str] 

# 需要導入模塊: import typing [as 別名]
# 或者: from typing import MutableMapping [as 別名]
def __init__(self, parent=None):
        """Initialize and read quickmarks."""
        super().__init__(parent)

        self.marks = collections.OrderedDict(
        )  # type: typing.MutableMapping[str, str]

        self._init_lineparser()
        for line in self._lineparser:
            if not line.strip() or line.startswith('#'):
                # Ignore empty or whitespace-only lines and comments.
                continue
            self._parse_line(line)
        self._init_savemanager(objreg.get('save-manager'))