import io
from typing import TypeVar, Callable
from python_crontab.interfaces.icron_entry import ICronEntry
from utilities import run_bash_cmd
Self = TypeVar("Self", bound="CronScriptManager")
class CronScriptManager:
def __init__(self, crontab_gen: ICronEntry):
"""
Manages the "CRUD" operation done in the cron scripts
@param crontab_gen: concrete implementation of class for setting the python script through crontab script
"""
self.crontab_gen = crontab_gen
self.was_entry_modified = False
self._new_cron_io = io.StringIO()
self._base_crontab_command = run_bash_cmd(["crontab", "-l"],
show_output=True)
self._cron_io: io.TextIOWrapper = self._base_crontab_command.result
self.some_entry_exists: bool = True if self._base_crontab_command.return_code == 0 else False
def _io_wrapper(self, func: Callable[..., str]) -> Callable[..., str]:
def inner_wrapper(*args, **kwargs) -> str:
update_crontab_script = func(*args, **kwargs)
self._new_cron_io.close()
run_bash_cmd(["crontab", "-r"])
return update_crontab_script.strip()
return inner_wrapper
Dict,
List,
Type,
TypeVar,
)
from .event import Events
from .exception import RunnerAlreadyExistsError
from .stats import RequestStats
from .runners import Runner, LocalRunner, MasterRunner, WorkerRunner
from .web import WebUI
from .user import User
from .user.task import filter_tasks_by_tags
from .shape import LoadTestShape
RunnerType = TypeVar("RunnerType", bound=Runner)
class Environment:
events: Events = None
"""
Event hooks used by Locust internally, as well as to extend Locust's functionality
See :ref:`events` for available events.
"""
user_classes: List[Type[User]] = []
"""User classes that the runner will run"""
shape_class: LoadTestShape = None
"""A shape class to control the shape of the load test"""
from __future__ import annotations
from typing import TYPE_CHECKING, TypeVar
from qtpy.QtWidgets import QListView
from ._base_item_view import _BaseEventedItemView
from .qt_list_model import QtListModel
if TYPE_CHECKING:
from qtpy.QtWidgets import QWidget
from ...utils.events.containers import SelectableEventedList
ItemType = TypeVar("ItemType")
class QtListView(_BaseEventedItemView[ItemType], QListView):
"""A QListView for a :class:`~napari.utils.events.SelectableEventedList`.
Designed to work with :class:`~napari._qt.containers.QtListModel`.
This class is an adapter between
:class:`~napari.utils.events.SelectableEventedList` and Qt's
`QAbstractItemView` interface (see `Qt Model/View Programming
<https://doc.qt.io/qt-5/model-view-programming.html>`_). It allows python
users to interact with the list in the "usual" python ways, updating any Qt
Views that may be connected, and also updates the python list object if any
GUI events occur in the view.
See docstring of :class:`_BaseEventedItemView` for additional background.
import asyncio
from concurrent.futures import Executor
from functools import partial, total_ordering
from pathlib import Path
from typing import Any, Awaitable, Callable, Generator, Optional, TypeVar, Union
from .compat import EventLoopMixin
from .thread_pool import threaded
T = TypeVar("T")
def proxy_method_async(
name: str,
in_executor: bool = True,
) -> Callable[..., Any]:
def wrap_to_future(loop: asyncio.AbstractEventLoop, func: Callable[..., T],
*args: Any, **kwargs: Any) -> asyncio.Future:
future = loop.create_future()
def _inner(): # type: ignore
try:
return future.set_result(func(*args, **kwargs))
except Exception as e:
return future.set_exception(e)
loop.call_soon(_inner)
return future
def wrap_to_thread(loop: asyncio.AbstractEventLoop, func: Callable[..., T],
executor: Executor, *args: Any,
import copy
from typing import Any, Type, TypeVar
import boost_histogram
from .._core import axis as ca
from .utils import register, set_module
T = TypeVar("T", bound="AxisTransform")
@set_module("boost_histogram.axis.transform")
class AxisTransform:
__slots__ = ("_this",)
_family: object
_this: Any
def __init_subclass__(cls, *, family: object) -> None:
super().__init_subclass__()
cls._family = family
def __copy__(self: T) -> T:
other: T = self.__class__.__new__(self.__class__)
other._this = copy.copy(self._this)
return other
@classmethod
def _convert_cpp(cls: Type[T], this: Any) -> T:
self: T = cls.__new__(cls)
self._this = this
return self
def map_special_case(instance_class: type,
entity_type: Platform) -> Platform:
if instance_class is veraApi.VeraSwitch and vera_device.device_id in remap:
return Platform.LIGHT
return entity_type
return next(
iter(
map_special_case(instance_class, entity_type)
for instance_class, entity_type in type_map.items()
if isinstance(vera_device, instance_class)),
None,
)
_DeviceTypeT = TypeVar("_DeviceTypeT", bound=veraApi.VeraDevice)
class VeraDevice(Generic[_DeviceTypeT], Entity):
"""Representation of a Vera device entity."""
def __init__(self, vera_device: _DeviceTypeT,
controller_data: ControllerData) -> None:
"""Initialize the device."""
self.vera_device = vera_device
self.controller = controller_data.controller
self._name = self.vera_device.name
# Append device id to prevent name clashes in HA.
self.vera_id = VERA_ID_FORMAT.format(slugify(vera_device.name),
vera_device.vera_device_id)
callbacks = self.callbacks[event][:]
for callback in callbacks:
# FIXME: if callback throws, we will lose the traceback
if asyncio.iscoroutinefunction(callback):
asyncio.run_coroutine_threadsafe(callback(event, *args), self.asyncio_loop)
else:
self.asyncio_loop.call_soon_threadsafe(callback, event, *args)
callback_mgr = CallbackManager()
trigger_callback = callback_mgr.trigger_callback
register_callback = callback_mgr.register_callback
unregister_callback = callback_mgr.unregister_callback
_NetAddrType = TypeVar("_NetAddrType")
class NetworkRetryManager(Generic[_NetAddrType]):
"""Truncated Exponential Backoff for network connections."""
def __init__(
self, *,
max_retry_delay_normal: float,
init_retry_delay_normal: float,
max_retry_delay_urgent: float = None,
init_retry_delay_urgent: float = None,
):
self._last_tried_addr = {} # type: Dict[_NetAddrType, Tuple[float, int]] # (unix ts, num_attempts)
# note: these all use "seconds" as unit
from ranzen import implements
from ranzen.misc import str_to_enum
__all__ = [
"GreedyCoreSetSampler",
"SequentialBatchSampler",
"SizedDataset",
"StratifiedBatchSampler",
"Subset",
"TrainTestSplit",
"TrainingMode",
"prop_random_split",
"stratified_split_indices",
]
T_co = TypeVar("T_co", covariant=True)
@runtime_checkable
class SizedDataset(Protocol[T_co]):
def __getitem__(self, index: int) -> T_co:
...
def __len__(self) -> int:
...
D = TypeVar("D", bound=SizedDataset)
class Subset(Generic[D]):
@attr.s(slots=True) # pragma: no mutate
class OperationDefinition:
"""A wrapper to store not resolved API operation definitions.
To prevent recursion errors we need to store definitions without resolving references. But operation definitions
itself can be behind a reference (when there is a ``$ref`` in ``paths`` values), therefore we need to store this
scope change to have a proper reference resolving later.
"""
raw: Dict[str, Any] = attr.ib() # pragma: no mutate
resolved: Dict[str, Any] = attr.ib() # pragma: no mutate
scope: str = attr.ib() # pragma: no mutate
parameters: Sequence[Parameter] = attr.ib() # pragma: no mutate
P = TypeVar("P", bound=Parameter)
@attr.s # pragma: no mutate
class APIOperation(Generic[P]):
"""A single operation defined in an API."""
# `path` does not contain `basePath`
# Example <scheme>://<host>/<basePath>/users - "/users" is path
# https://swagger.io/docs/specification/2-0/api-host-and-base-path/
path: str = attr.ib() # pragma: no mutate
method: str = attr.ib() # pragma: no mutate
definition: OperationDefinition = attr.ib(repr=False) # pragma: no mutate
schema: "BaseSchema" = attr.ib() # pragma: no mutate
app: Any = attr.ib(default=None) # pragma: no mutate
base_url: Optional[str] = attr.ib(default=None) # pragma: no mutate
Type,
TypeVar,
Union,
cast,
)
from make_it_sync import make_sync
from func_adl.util_types import unwrap_iterable
from .util_ast import as_ast, function_call, parse_as_ast
# Attribute that will be used to store the executor reference
executor_attr_name = "_func_adl_executor"
T = TypeVar("T")
S = TypeVar("S")
class ReturnedDataPlaceHolder:
"""Type returned for awkward, etc.,"""
pass
def _local_simplification(a: ast.Lambda) -> ast.Lambda:
"""Simplify the AST by removing unnecessary statements and
syntatic sugar
"""
from func_adl.ast.syntatic_sugar import resolve_syntatic_sugar
from typing_extensions import ParamSpec, Protocol
# submodules
from .datamodel import DataModel
from .dataoptions import DataOptions
from .typing import DataType, Order, Shape, Sizes
# constants
DEFAULT_OPTIONS = DataOptions(xr.DataArray)
# type hints
P = ParamSpec("P")
TDataArray = TypeVar("TDataArray", bound=xr.DataArray)
class DataClass(Protocol[P]):
"""Type hint for a dataclass object."""
def __init__(self, *args: P.args, **kwargs: P.kwargs) -> None:
...
__dataclass_fields__: Dict[str, Field[Any]]
class DataArrayClass(Protocol[P, TDataArray]):
"""Type hint for a dataclass object with a DataArray factory."""
def __init__(self, *args: P.args, **kwargs: P.kwargs) -> None:
"""
Patch the py-evm chain with a VMState that pauses when state data
is missing, and emits an event which requests the missing data.
"""
pausing_vm_config = tuple(
(starting_block, pausing_vm_decorator(vm, event_bus, loop, urgent=urgent))
for starting_block, vm in vm_config
)
PausingBeamChain = BeamChain.configure(
vm_configuration=pausing_vm_config,
chain_id=chain_id,
)
return PausingBeamChain(db)
TVMFuncReturn = TypeVar('TVMFuncReturn')
def pausing_vm_decorator(
original_vm_class: Type[VirtualMachineAPI],
event_bus: EndpointAPI,
loop: asyncio.AbstractEventLoop,
urgent: bool = True) -> Type[VirtualMachineAPI]:
"""
Decorate a py-evm VM so that it will pause when data is missing
"""
async def request_missing_storage(
missing_node_hash: Hash32,
storage_key: Hash32,
storage_root_hash: Hash32,
account_address: Address) -> MissingStorageCollected:
from typing import List, TypeVar, Generic, Tuple
T = TypeVar('T', int, float)
class Edge(Generic[T]):
def __init__(self, dst: int, weight: T) -> None:
self.dst: int = dst
self.weight: T = weight
def __lt__(self, e: 'Edge') -> bool:
return self.weight > e.weight
class Graph(Generic[T]):
def __init__(self, V: int) -> None:
self.V: int = V
self.E: List[List[Edge[T]]] = [[] for _ in range(V)]
self.edge_size: int = 0
def add_edge(self, src: int, dst: int, weight: T) -> None:
self.E[src].append(Edge(dst, weight))
self.edge_size += 1
class HeavyLightDecomposition(Generic[T]):
def __init__(self, G: Graph[T]) -> None:
self.G: Graph[T] = G
self.vid: List[int] = [0] * G.V
self.head: List[int] = [0] * G.V
self.heavy: List[int] = [-1] * G.V
self.parent: List[int] = [0] * G.V
Sequence,
Type,
TypeVar,
Union,
)
from typing_extensions import final
from returns._generated.futures import _future, _future_result
from returns._generated.iterable import iterable
from returns.io import IO, IOResult
from returns.primitives.container import BaseContainer
from returns.result import Failure, Result, Success
# Definitions:
_ValueType = TypeVar('_ValueType', covariant=True)
_NewValueType = TypeVar('_NewValueType')
_ErrorType = TypeVar('_ErrorType', covariant=True)
_NewErrorType = TypeVar('_NewErrorType')
# Aliases:
_FirstType = TypeVar('_FirstType')
_SecondType = TypeVar('_SecondType')
# Public composition helpers:
async def async_identity(instance: _FirstType) -> _FirstType:
"""
Async function that returns its argument.
from pandas.core.internals.base import (
DataManager,
SingleDataManager,
interleaved_dtype,
)
from pandas.core.internals.blocks import (
ensure_block_shape,
external_values,
new_block,
to_native_types,
)
if TYPE_CHECKING:
from pandas import Float64Index
T = TypeVar("T", bound="ArrayManager")
class ArrayManager(DataManager):
"""
Core internal data structure to implement DataFrame and Series.
Alternative to the BlockManager, storing a list of 1D arrays instead of
Blocks.
This is *not* a public API class
Parameters
----------
arrays : Sequence of arrays
axes : Sequence of Index
def current_user(self, request=None) -> TypeVar('User'):
""" retrieves the User instance for a request, otherwise None """
import os
import time
import unittest
from multiprocessing.sharedctypes import Synchronized
# We need to pick an ID for this test-backend invocation, and store it
# in this global so it can be used in init_worker; this is used to
# ensure the database IDs we select are unique for each `test-backend`
# run. This probably should use a locking mechanism rather than the
# below hack, which fails 1/10000000 of the itme.
random_id_range_start = random.randint(1, 10000000) * 100
_worker_id = 0 # Used to identify the worker process.
ReturnT = TypeVar('ReturnT') # Constrain return type to match
def slow(slowness_reason: str) -> Callable[[Callable[..., ReturnT]], Callable[..., ReturnT]]:
'''
This is a decorate that annotates a test as being "known
to be slow." The decorator will set expected_run_time and slowness_reason
as attributes of the function. Other code can use this annotation
as needed, e.g. to exclude these tests in "fast" mode.
'''
def decorator(f: Any) -> ReturnT:
f.slowness_reason = slowness_reason
return f
return decorator
def is_known_slow_test(test_method: Any) -> bool:
# -*- coding: utf-8 -*-
from typing import TypeVar
from odoo import models
from . import adapter
AdapterType = TypeVar(
'AdapterType',
bound='.'.join([adapter.Adapter.__module__, adapter.Adapter.__name__]))
OdooModelType = TypeVar('ModelType',
bound='.'.join(
[models.Model.__module__, models.Model.__name__]))
from typing import Any, Dict, List, Type, TypeVar
import attr
T = TypeVar("T", bound="CurrentUserInfoResponse200TeamsItem")
@attr.s(auto_attribs=True)
class CurrentUserInfoResponse200TeamsItem:
""" """
id: str
name: str
is_team_manager: int
additional_properties: Dict[str, Any] = attr.ib(init=False, factory=dict)
def to_dict(self) -> Dict[str, Any]:
id = self.id
name = self.name
is_team_manager = self.is_team_manager
field_dict: Dict[str, Any] = {}
field_dict.update(self.additional_properties)
field_dict.update({
"id": id,
"name": name,
"isTeamManager": is_team_manager,
})
return field_dict
# Unless required by applicable law or agreed to in writing,
# software distributed under the License is distributed on an
# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
# KIND, either express or implied. See the License for the
# specific language governing permissions and limitations
# under the License.
import functools
import re
import warnings
from collections.abc import Collection as ABCCollection
from typing import Any, Callable, Collection, Iterable, List, TypeVar, Union, cast
import pandas as pd # type: ignore
RT = TypeVar("RT")
def deprecated_api(
replace_with: str,
) -> Callable[[Callable[..., RT]], Callable[..., RT]]:
def wrapper(f: Callable[..., RT]) -> Callable[..., RT]:
@functools.wraps(f)
def wrapped(*args: Any, **kwargs: Any) -> RT:
warnings.warn(
f"{f.__name__} is deprecated, use {replace_with} instead",
DeprecationWarning,
stacklevel=2,
)
return f(*args, **kwargs)
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Utilities to use within loggers."""
import queue
import threading
from typing import Callable, TypeVar, Generic
from absl import logging
E = TypeVar("E")
class AsyncExecutor(Generic[E]):
"""Executes a blocking function asynchronously on a queue of items."""
def __init__(
self,
fn: Callable[[E], None],
queue_size: int = 1,
interruptible_interval_secs: float = 1.0,
):
"""Buffers elements in a queue and runs `fn` asynchronously..
NOTE: Once closed, `AsyncExecutor` will block until current `fn` finishes
but is not guaranteed to dequeue all elements currently stored in
from typing import List
from abc import abstractmethod
from typing import TypeVar, Protocol
class Comparable(Protocol):
"""Protocol for annotating comparable types."""
@abstractmethod
def __lt__(self, other) -> bool:
pass
CT = TypeVar("CT", bound=Comparable)
class SelectionSort:
@staticmethod
def sort(data_list: List[CT]):
for i in range(len(data_list)):
min_idx = i
for j in range(i + 1, len(data_list)):
if data_list[j] < data_list[min_idx]:
min_idx = j
data_list[i], data_list[min_idx] = data_list[min_idx], data_list[i]
if __name__ == '__main__':
test_list: List[int] = [1, 4, 2, 3, 6, 5]
SelectionSort.sort(test_list)
print(test_list)
from twisted.internet.defer import Deferred
from twisted.python.failure import Failure
from twisted.web.client import readBody
from twisted.web.iweb import IResponse
from unpaddedbase64 import decode_base64
from sydent.config.exceptions import ConfigError
from sydent.db.hashing_metadata import HashingMetadataStore
from sydent.db.threepid_associations import GlobalAssociationStore, SignedAssociations
from sydent.threepid import threePidAssocFromDict
from sydent.types import JsonDict
from sydent.util import json_decoder
from sydent.util.hash import sha256_and_url_safe_base64
from sydent.util.stringutils import normalise_address
PushUpdateReturn = TypeVar("PushUpdateReturn")
if TYPE_CHECKING:
from sydent.sydent import Sydent
logger = logging.getLogger(__name__)
SIGNING_KEY_ALGORITHM = "ed25519"
class Peer(Generic[PushUpdateReturn]):
def __init__(self, servername: str, pubkeys: Dict[str, str]):
"""
:param server_name: The peer's server name.
:param pubkeys: The peer's public keys in a Dict[key_id, key_b64]
"""
import bisect
import warnings
import functools
from torch._utils import _accumulate
from torch import randperm
# No 'default_generator' in torch/__init__.pyi
from torch import default_generator # type: ignore
from torch.utils.data._typing import _DataPipeMeta
from typing import TypeVar, Generic, Iterable, Iterator, Sequence, List, Optional, Tuple, Dict, Callable
from ... import Tensor, Generator
T_co = TypeVar('T_co', covariant=True)
T = TypeVar('T')
class Dataset(Generic[T_co]):
r"""An abstract class representing a :class:`Dataset`.
All datasets that represent a map from keys to data samples should subclass
it. All subclasses should overwrite :meth:`__getitem__`, supporting fetching a
data sample for a given key. Subclasses could also optionally overwrite
:meth:`__len__`, which is expected to return the size of the dataset by many
:class:`~torch.utils.data.Sampler` implementations and the default options
of :class:`~torch.utils.data.DataLoader`.
.. note::
:class:`~torch.utils.data.DataLoader` by default constructs a index
sampler that yields integral indices. To make it work with a map-style
dataset with non-integral indices/keys, a custom sampler must be provided.
"""
TypeVar,
Iterable,
Sequence,
Generic,
List,
Callable,
Set,
Deque,
Dict,
Any,
Optional,
)
from typing_extensions import Protocol
from heapq import heappush, heappop
T = TypeVar("T")
def linear_contains(iterable: Iterable[T], key: T) -> bool:
for item in iterable:
if item == key:
return True
return False
C = TypeVar("C", bound="Comparable")
class Comparable(Protocol):
def __eq__(self, other: Any) -> bool:
...
from __future__ import annotations
from typing import Any, TypeVar, List, Set, Dict, Tuple, Optional, Union
from grapl_analyzerlib.node_types import (
EdgeT,
PropType,
PropPrimitive,
EdgeRelationship,
)
from grapl_analyzerlib.schema import Schema
from grapl_analyzerlib.nodes.entity import EntitySchema, EntityQuery, EntityView
AQ = TypeVar("AQ", bound="AssetQuery")
AV = TypeVar("AV", bound="AssetView")
T = TypeVar("T")
OneOrMany = Union[List[T], T]
def default_asset_properties() -> Dict[str, PropType]:
return {
"hostname": PropType(
PropPrimitive.Str,
False,
),
}
def default_asset_edges() -> Dict[str, Tuple[EdgeT, str]]:
return {
from typing import Generic, List, Optional, Type, TypeVar
from fastapi.encoders import jsonable_encoder
from pydantic import BaseModel
from sqlalchemy.orm import Session
from cashback.db.base_class import Base
ModelType = TypeVar("ModelType", bound=Base)
CreateSchemaType = TypeVar("CreateSchemaType", bound=BaseModel)
UpdateSchemaType = TypeVar("UpdateSchemaType", bound=BaseModel)
# pylint: disable=redefined-builtin
class CRUDBase(Generic[ModelType, CreateSchemaType, UpdateSchemaType]):
def __init__(self, model: Type[ModelType]):
"""
CRUD object with default methods to Create, Read, Update, Delete (CRUD).
"""
self.model = model
def get(self, db_session: Session, id: int) -> Optional[ModelType]:
return db_session.query(self.model).filter(self.model.id == id).first()
def get_multi(self,
db_session: Session,
*,
skip=0,
limit=100) -> List[ModelType]:
return db_session.query(self.model).offset(skip).limit(limit).all()
# coding: UTF-8
from typing import Mapping, Tuple, TypeVar
from .accumulative import AccumulativeMonitor
from .base import BaseMonitor
from .combined import CombinedOneShotMonitor
from .idle import IdleMonitor
from .interval import IntervalMonitor
from .perf import PerfMonitor
from .power import PowerMonitor
from .rdtsc import RDTSCMonitor
from .resctrl import ResCtrlMonitor
from .runtime import RuntimeMonitor
MonitorData = TypeVar('MonitorData', int, float, Tuple, Mapping)
# Changes may cause incorrect behavior and will be lost if the code is regenerated.
# --------------------------------------------------------------------------
from typing import Any, AsyncIterable, Callable, Dict, Generic, Optional, TypeVar, Union
import warnings
from azure.core.async_paging import AsyncItemPaged, AsyncList
from azure.core.exceptions import ClientAuthenticationError, HttpResponseError, ResourceExistsError, ResourceNotFoundError, map_error
from azure.core.pipeline import PipelineResponse
from azure.core.pipeline.transport import AsyncHttpResponse, HttpRequest
from azure.core.polling import AsyncLROPoller, AsyncNoPolling, AsyncPollingMethod
from azure.mgmt.core.exceptions import ARMErrorFormat
from azure.mgmt.core.polling.async_arm_polling import AsyncARMPolling
from ... import models as _models
T = TypeVar('T')
ClsType = Optional[Callable[
[PipelineResponse[HttpRequest, AsyncHttpResponse], T, Dict[str,
Any]], Any]]
class VirtualRoutersOperations:
"""VirtualRoutersOperations async operations.
You should not instantiate this class directly. Instead, you should create a Client instance that
instantiates it for you and attaches it as an attribute.
:ivar models: Alias to model classes used in this operation group.
:type models: ~azure.mgmt.network.v2019_08_01.models
:param client: Client for service requests.
:param config: Configuration of service client.
@abc.abstractmethod
def redo(self) -> NoReturn:
"""
Redo implementation which should be overwritten
"""
@property
def text(self) -> str:
return self._text
@text.setter
def text(self, text: str) -> NoReturn:
self._text = text
T_ = TypeVar('T_', bound=UndoCommand)
def dict_stack_deco(func: Callable) -> Callable:
def inner(obj, *args, **kwargs):
# Only do the work to a NotarizedDict.
if hasattr(obj, '_stack_enabled') and obj._stack_enabled:
if not kwargs:
borg.stack.push(DictStack(obj, *args))
else:
borg.stack.push(DictStackReCreate(obj, **kwargs))
else:
func(obj, *args, **kwargs)
return inner
