from Blueprint.Color import Color, ColorDict from Blueprint.Entity import Entity, EntityDict, CurvedRailEntity from Blueprint.Icon import Icon, IconDict from Blueprint.Position import Position, PositionDict from Blueprint.Schedule import Schedule, ScheduleDict from Blueprint.Tile import Tile, TileDict BlueprintDict = TypedDict( "BlueprintDict", { "entities": List[EntityDict], "item": str, "version": int, "label": str, "icons": List[IconDict], "label_color": ColorDict, "tiles": List[TileDict], "schedules": List[ScheduleDict], "description": str, "snap-to-grid": PositionDict, "position-relative-to-grid": PositionDict, "absolute-snapping": bool, }) class Blueprint(FactorioBlueprintObject): dict_type: Type[TypedDict] = BlueprintDict field_translation_map = { "snap_to_grid": "snap-to-grid", "position_relative_to_grid": "position-relative-to-grid", "absolute_snapping": "absolute-snapping",
if num == 0: return self.points.append((now, num)) @property def value(self) -> int: """Get the summation of all non-expired points""" now = time.time() cutoff = now - self.window while self.points and self.points[0][0] < cutoff: self.points.pop(0) return sum([p[1] for p in self.points]) RemainingCapacity = TypedDict("RemainingCapacity", { "read": DecayingCapacityStore, "write": DecayingCapacityStore }) class RateLimit(object): """ Class for rate limiting requests to DynamoDB Parameters ---------- total_read : float, optional The overall maximum read units per second total_write : float, optional The overall maximum write units per second total : :class:`~dynamo3.result.Capacity`, optional A Capacity object. You can provide this instead of ``total_read`` and
TypeVar, Union, ) from urllib.parse import unquote import lxml.html from typing_extensions import TypedDict MACOS = platform.system() == "Darwin" LINUX = platform.system() == "Linux" WSL = 'microsoft' in platform.release().lower() StreamData = TypedDict( 'StreamData', { 'name': str, 'id': int, 'color': str, 'invite_only': bool, 'description': str, }) Message = TypedDict( 'Message', { 'id': int, 'sender_id': int, 'content': str, 'recipient_id': int, 'timestamp': int, 'client': str, 'subject': str, # Only for stream msgs. 'topic_links': List[str],
from typing_extensions import TypedDict from sentry_sdk.transport import Transport from sentry_sdk.integrations import Integration from sentry_sdk._types import Event, EventProcessor, BreadcrumbProcessor # Experiments are feature flags to enable and disable certain unstable SDK # functionality. Changing them from the defaults (`None`) in production # code is highly discouraged. They are not subject to any stability # guarantees such as the ones from semantic versioning. Experiments = TypedDict( "Experiments", { "max_spans": Optional[int], "record_sql_params": Optional[bool], "auto_enabling_integrations": Optional[bool], }, total=False, ) # This type exists to trick mypy and PyCharm into thinking `init` and `Client` # take these arguments (even though they take opaque **kwargs) class ClientConstructor(object): def __init__( self, dsn=None, # type: Optional[str] with_locals=True, # type: bool max_breadcrumbs=100, # type: int release=None, # type: Optional[str]
from asyncio import Semaphore from contextlib import asynccontextmanager from pathlib import Path import json from typing import Callable, Iterable, Sequence, Optional, NamedTuple, AsyncIterator, Any, Awaitable from typing_extensions import TypedDict from semver import VersionInfo from dds_ports.port import Port, PackageID from dds_ports import git, github, util PackageJSON = TypedDict('PackageJSON', { 'name': str, 'namespace': str, 'depends': Sequence[str], }) LibraryJSON = TypedDict('LibraryJSON', { 'name': str, 'uses': Sequence[str], }) FSTransformFn = Callable[[Path], Awaitable[None]] BUILD_SEMAPHORE = Semaphore(1) class SimpleGitHubAdaptingPort(NamedTuple): package_id: PackageID owner: str
) from rasa.shared.core.domain import Domain, State from rasa.shared.core.slots import Slot if TYPE_CHECKING: from typing_extensions import TypedDict from rasa.shared.core.training_data.structures import Story from rasa.shared.core.training_data.story_writer.story_writer import StoryWriter # precise type definition for `DialogueStateTracker.active_loop` TrackerActiveLoop = TypedDict( "TrackerActiveLoop", { LOOP_NAME: Optional[Text], LOOP_INTERRUPTED: bool, LOOP_REJECTED: bool, TRIGGER_MESSAGE: Dict, }, total=False, ) logger = logging.getLogger(__name__) # same as State but with Dict[...] substituted with FrozenSet[Tuple[...]] FrozenState = FrozenSet[Tuple[Text, FrozenSet[Tuple[Text, Tuple[Union[float, Text]]]]]] class EventVerbosity(Enum): """Filter on which events to include in tracker dumps."""
from sklearn.mixture import GaussianMixture except ImportError as e: raise ImportError( "scikit-learn is required to use the stochastic_events module. " "Please install scikit-learn using\n" "\tpip install scikit-learn\n" "or install acnportal with extra options\n" "\tpip install acnportal[scikit-learn]" ) CapFnCallable = Callable[[float, float, float, float], Tuple[float, float]] BatteryParams = TypedDict( "BatteryParams", {"type": Type[Battery], "capacity_fn": CapFnCallable, "kwargs": Dict[str, Any]}, total=False, ) class StochasticEvents: """ Base class for generating events from a stochastic model. Args: arrival_min (float): Clip arrive time at lower bound. Useful if you know that drivers should not arrive before a certain time. By default 0, meaning drivers do not arrive on the previous day. [hours since midnight] arrival_max (float): Clip arrive time at upper bound. Useful if you know drivers should not arrive after a certain time. My default 24, meaning drivers do not arrive the next day. [hours since midnight] duration_min (float): Clip duration to lower bound. Useful to limit session duration to a reasonable minimum. By default 0.0833 hours or 5 minutes. [hours] duration_max (float): Clip duration to upper bound. Useful to limit session duration to a reasonable maximum.
# # 2. Comparing individually the conformity scores of the training points with # the conformity scores from the associated model for a new test point # (as presented in Romano et al. 2020 for the "cumulated_score" method) # # Let's explore the two possibilites with the "score" method using # :class:`mapie.classification.MapieClassifier`. # # All we need to do is to provide with the `cv` argument a cross-validation # object or an integer giving the number of folds. # When estimating the prediction sets, we define how the scores are aggregated # with the ``agg_scores`` attribute. Params = TypedDict("Params", { "method": str, "cv": Optional[Union[int, str]], "random_state": Optional[int] }) ParamsPredict = TypedDict("ParamsPredict", { "include_last_label": Union[bool, str], "agg_scores": str }) kf = KFold(n_splits=5, shuffle=True) STRATEGIES = { "score_cv_mean": (Params(method="score", cv=kf, random_state=42), ParamsPredict(include_last_label=False, agg_scores="mean")), "score_cv_crossval": (Params(method="score", cv=kf, random_state=42), ParamsPredict(include_last_label=False,
from typing_extensions import TypedDict from typing import Any from pyobs.events import Event class MoveEvent(Event): """Event to be sent when moving to a new target.""" __module__ = "pyobs.events" pass DataTypeRaDec = TypedDict("DataTypeRaDec", {"ra": float, "dec": float}) class MoveRaDecEvent(MoveEvent): """Event to be sent when moving to RA/Dec.""" __module__ = "pyobs.events" def __init__(self, ra: float, dec: float, **kwargs: Any): MoveEvent.__init__(self) self.data: DataTypeRaDec = {"ra": ra, "dec": dec} @property def ra(self) -> float: return self.data["ra"] @property def dec(self) -> float:
self.mark_muted() def mark_muted(self) -> None: self.update_widget('M') # TODO: Handle event-based approach for topic-muting. class UnreadPMButton(urwid.Button): def __init__(self, user_id: int, email: str) -> None: self.user_id = user_id self.email = email DecodedStream = TypedDict('DecodedStream', { 'stream_id': Optional[int], 'stream_name': Optional[str], }) ParsedNarrowLink = TypedDict('ParsedNarrowLink', { 'narrow': str, 'stream': DecodedStream, 'topic_name': str, 'message_id': Optional[int], }, total=False) class MessageLinkButton(urwid.Button): def __init__(self, controller: Any, caption: str, link: str, display_attr: Optional[str]) -> None: self.controller = controller
# An entry in the test data set. # Each TestData is annotated with a 'type' as: # * 'A': pre-transition where the UTC offset is different # * 'B': post-transition where the UTC offset is different # * 'a': pre-transition where only the DST offset is different # * 'b': post-transition where only the DST offset is different # * 'S': a monthly test sample # * 'Y': end of year test sample TestItem = TypedDict( "TestItem", { 'epoch': int, # seconds from AceTime epoch of 2000-01-01T00:00:00Z 'total_offset': int, # total UTC offset in seconds 'dst_offset': int, # DST offset in seconds 'y': int, 'M': int, 'd': int, 'h': int, 'm': int, 's': int, 'abbrev': Optional[str], 'type': str, }) # The test data set (epoch -> timezone info) TestData = Dict[str, List[TestItem]] # The top-level validation data collection. This can be serialized to JSON. ValidationData = TypedDict( 'ValidationData', {
import re, subprocess, os, json, argparse, copy, shutil, inspect, sys from typing_extensions import TypedDict from datetime import datetime from typing import * scriptVersion: str = "2.3" fsmName: str = "none" context: str = "none" initial: str = "none" version: str = "none" TransitionType = TypedDict( 'TransitionType', { 'event': str, 'nextState': Optional[str], 'guardList': List[str], 'eventsSendList': List[str], 'actionList': List[str] }) newTransition: TransitionType = { 'event': "", 'nextState': "", 'guardList': [], 'eventsSendList': [], 'actionList': [] } StateType = TypedDict( 'StateType', { 'parentState': str, 'stateName': str,
def select_row(view, row): """ Select a `row` in an item view """ selmodel = view.selectionModel() selmodel.select(view.model().index(row, 0), QItemSelectionModel.ClearAndSelect) if TYPE_CHECKING: # pylint: disable=used-before-assignment _ScriptData = TypedDict("_ScriptData", { "name": str, "script": str, "filename": Optional[str] }) class OWPythonScript(OWWidget): name = "Python Script" description = "Write a Python script and run it on input data or models." icon = "icons/PythonScript.svg" priority = 3150 keywords = ["file", "program"] class Inputs: data = Input("Data", Table, replaces=["in_data"],
from __future__ import annotations from typing import Any, ClassVar, Dict, List, NoReturn, Optional, Union from s3transfer.manager import TransferConfig from typing_extensions import TypedDict from .utils import human_readable_to_bytes # If the user does not specify any overrides, # these are the default values we use for the s3 transfer # commands. TransferConfigDict = TypedDict( "TransferConfigDict", max_bandwidth=Optional[Union[int, str]], max_concurrent_requests=int, max_queue_size=int, multipart_chunksize=Union[int, str], multipart_threshold=Union[int, str], ) DEFAULTS: TransferConfigDict = { "max_bandwidth": None, "max_concurrent_requests": 10, "max_queue_size": 1000, "multipart_chunksize": 8 * (1024**2), "multipart_threshold": 8 * (1024**2), } class InvalidConfigError(Exception): """Invalid configuration."""
from __future__ import annotations from typing import Optional, Dict, Any from typing_extensions import TypedDict from pyobs.events.event import Event from pyobs.utils.enums import ImageType DataType = TypedDict("DataType", { "filename": str, "image_type": Optional[str], "raw": Optional[str] }) class NewImageEvent(Event): """Event to be sent on a new image.""" __module__ = "pyobs.events" def __init__(self, filename: str, image_type: Optional[ImageType] = None, raw: Optional[str] = None, **kwargs: Any): """Initializes new NewImageEvent. Args: filename: Name of new image file. image_type: Type of image. raw: Only for reduced images, references raw frame. """
import re import traceback from typing import AbstractSet, List, Mapping, Optional, Sequence, Tuple from typing_extensions import TypedDict from zulint.printer import BLUE, ENDC, GREEN, MAGENTA, YELLOW, colors, print_err Rule = TypedDict("Rule", { "bad_lines": Sequence[str], "description": str, "exclude": AbstractSet[str], "exclude_line": AbstractSet[Tuple[str, str]], "exclude_pattern": str, "good_lines": Sequence[str], "include_only": AbstractSet[str], "pattern": str, "strip": str, "strip_rule": str, }, total=False) LineTup = Tuple[int, str, str, str] class RuleList: """Defines and runs custom linting rules for the specified language.""" def __init__( self, langs: Sequence[str], rules: Sequence[Rule], max_length: Optional[int] = None,
import anyio # you would need to `pip install anyio` import httpx # you would need to `pip install httpx` from typing_extensions import Final, TypedDict from returns.context import RequiresContextFutureResultE from returns.functions import tap from returns.future import FutureResultE, future_safe from returns.iterables import Fold from returns.pipeline import managed from returns.result import ResultE, safe _URL: Final = 'https://jsonplaceholder.typicode.com/posts/{0}' _Post = TypedDict('_Post', { 'id': int, 'userId': int, 'title': str, 'body': str, }) def _close( client: httpx.AsyncClient, raw_value: ResultE[Sequence[str]], ) -> FutureResultE[None]: return future_safe(client.aclose)() def _fetch_post( post_id: int, ) -> RequiresContextFutureResultE[_Post, httpx.AsyncClient]: context: RequiresContextFutureResultE[
Event = TypedDict( 'Event', { 'type': str, # typing: 'sender': Dict[str, Any], # 'email', ... # typing & reaction: 'op': str, # reaction: 'user': Dict[str, Any], # 'email', 'user_id', 'full_name' 'reaction_type': str, 'emoji_code': str, 'emoji_name': str, # reaction & update_message: 'message_id': int, # update_message: 'rendered_content': str, # update_message_flags: 'messages': List[int], 'operation': str, 'flag': str, 'all': bool, # message: 'message': Message, 'flags': List[str], 'subject': str, # subscription: 'property': str, 'user_id': int, # Present when a streams subscribers are updated. 'stream_id': int, 'value': bool, 'message_ids': List[int] # Present when subject of msg(s) is updated }, total=False) # Each Event will only have a subset of these
class RpcPeerResponse(TypedDict): enode: str id: str name: str caps: Sequence[str] network: RpcPeerNetworkResponse RpcTransactionResponse = TypedDict('RpcTransactionResponse', { 'hash': HexStr, 'nonce': str, 'gas': str, 'gasPrice': str, # `from` being a reserved word forces us to use the alternate syntax for this type 'from': HexStr, 'to': HexStr, 'value': str, 'input': HexStr, 'r': str, 's': str, 'v': str, }) class RpcAccessList(TypedDict): address: str storageKeys: List[str] class RpcBlockTransactionResponse(RpcTransactionResponse): blockNumber: str
elif stream_email_notify: notice['trigger'] = 'stream_email_notify' else: raise AssertionError("Unknown notification trigger!") notice['stream_name'] = stream_name if not already_notified.get("email_notified"): queue_json_publish("missedmessage_emails", notice, lambda notice: None) notified['email_notified'] = True return notified ClientInfo = TypedDict( 'ClientInfo', { 'client': ClientDescriptor, 'flags': Optional[Iterable[str]], 'is_sender': bool, }) def get_client_info_for_message_event( event_template: Mapping[str, Any], users: Iterable[Mapping[str, Any]]) -> Dict[str, ClientInfo]: ''' Return client info for all the clients interested in a message. This basically includes clients for users who are recipients of the message, with some nuances for bots that auto-subscribe to all streams, plus users who may be mentioned, etc. ''' send_to_clients = {} # type: Dict[str, ClientInfo]
from sqlalchemy.dialects import postgresql from sqlalchemy.orm import Session from sqlalchemy.sql import func from sqlalchemy.sql.visitors import VisitableType from typing_extensions import TypedDict from superset import db logger = logging.getLogger(__name__) ColumnInfo = TypedDict( "ColumnInfo", { "name": str, "type": VisitableType, "nullable": bool, "default": Optional[Any], "autoincrement": str, "primary_key": int, }, ) example_column = { "name": "id", "type": sqlalchemy.sql.sqltypes.INTEGER(), "nullable": False, "default": None, "autoincrement": "auto", "primary_key": 1, }
from typing import Any, Optional, List, Dict, Tuple, Union from typing_extensions import TypedDict, Literal DagDef = TypedDict('DagDef', { "company": str, "default_input_key": Optional[str], "default_output_key": Optional[str], "high_priority": bool, "name": str, "nodes": List['NodeDef'], "queue_mng": Optional[str], "state": str, }) NodeDef = TypedDict('NodeDef', { "blobs": Dict[str, str], "id": str, "inputs": Dict[str, Tuple[str, str]], "kind": str, "name": str, "params": Dict[str, Any], }, total=False) S3BucketSettings = TypedDict('S3BucketSettings', { "api_version": Optional[str], "aws_access_key_id": str, "aws_secret_access_key": str, "aws_session_token": Optional[str], "buckets": Dict[str, str], "endpoint_url": Optional[str], "region_name": Optional[str], "use_ssl": Optional[bool],
class JiraVelocity(SourceCollector): """Collector to get sprint velocity from Jira.""" Board = TypedDict("Board", {"id": int, "name": str}) Points = TypedDict("Points", {"text": str, "value": float}) Sprint = TypedDict("Sprint", {"id": int, "name": str, "goal": str}) SprintPoints = dict[str, Points] async def _get_source_responses(self, *urls: URL) -> SourceResponses: """Extend to pass the Greenhopper velocity chart API.""" board_id = await self.__board_id(urls[0]) api_url = URL( f"{urls[0]}/rest/greenhopper/1.0/rapid/charts/velocity.json?rapidViewId={board_id}" ) return await super()._get_source_responses(api_url) async def _parse_source_responses( self, responses: SourceResponses) -> SourceMeasurement: """Override to parse the sprint values from the responses.""" api_url = await self._api_url() board_id = parse_qs(urlparse(str( responses.api_url)).query)["rapidViewId"][0] entity_url = URL( f"{api_url}/secure/RapidBoard.jspa?rapidView={board_id}&view=reporting&chart=sprintRetrospective&sprint=" ) json = await responses[0].json() # The JSON contains a list with sprints and a dict with the committed and completed points, indexed by sprint id sprints, points = json["sprints"], json["velocityStatEntries"] velocity_type = str(self._parameter("velocity_type")) nr_sprints = int(str(self._parameter("velocity_sprints"))) # Get the points, either completed, committed, or completed minus committed, as determined by the velocity type sprint_values = [ self.__velocity(points[str(sprint["id"])], velocity_type) for sprint in sprints[:nr_sprints] ] entities = [ self.__entity(sprint, points[str(sprint["id"])], velocity_type, entity_url) for sprint in sprints ] return SourceMeasurement( value=str(round(sum(sprint_values) / len(sprint_values))) if sprint_values else "0", entities=entities) @staticmethod def __velocity(sprint_points: SprintPoints, velocity_type: str) -> float: """Return the points completed, points committed, or difference between the two for the sprint.""" if velocity_type == "difference": return sprint_points["completed"]["value"] - sprint_points[ "estimated"]["value"] return sprint_points[velocity_type]["value"] @staticmethod def __entity(sprint: Sprint, sprint_points: SprintPoints, velocity_type: str, entity_url: URL) -> Entity: """Create a sprint entity.""" sprint_id = str(sprint["id"]) committed = sprint_points["estimated"]["text"] completed = sprint_points["completed"]["text"] difference = str( float(sprint_points["completed"]["value"] - sprint_points["estimated"]["value"])) measured = dict(completed=completed, estimated=committed, difference=difference)[velocity_type] return Entity( key=sprint_id, name=sprint["name"], goal=sprint.get("goal") or "", points_completed=completed, points_committed=committed, points_measured=measured, points_difference=difference, url=str(entity_url) + sprint_id, ) async def _landing_url(self, responses: SourceResponses) -> URL: """Override to create a link to the Greenhopper velocity chart.""" api_url = await self._api_url() board_id = parse_qs(urlparse(str( responses.api_url)).query)["rapidViewId"][0] return URL( f"{api_url}/secure/RapidBoard.jspa?rapidView={board_id}&view=reporting&chart=velocityChart" ) async def __board_id(self, api_url: URL) -> str: """Return the board id.""" last = False start_at = 0 boards: list[JiraVelocity.Board] = [] while not last: url = URL(f"{api_url}/rest/agile/1.0/board?startAt={start_at}") response = (await super()._get_source_responses(url))[0] json = await response.json() boards.extend(json["values"]) start_at += json["maxResults"] last = json["isLast"] board_name_or_id = str(self._parameter("board")).lower() matching_boards = [ b for b in boards if board_name_or_id in (str(b["id"]), b["name"].lower().strip()) ] if not matching_boards: message = f"Could not find a Jira board with id or name '{board_name_or_id}' at {api_url}" raise SourceCollectorException(message) return str(matching_boards[0]["id"])
from typing_extensions import TypedDict from typing import Optional, List from datetime import datetime from enum import Enum Todo = TypedDict( 'Todo', { "todo_id": int, "due_date": Optional[datetime], "frequency": Optional[str], "task": str, # Default to some string "timeSlot": Optional[int], "trackHabit": Optional[bool], "category": Optional[str], "remindBeforeDays": Optional[int] }) TodoLog = TypedDict('TodoLog', {"todo_id": int, "count": int, "action": str}) TodoCreatePayload = TypedDict( 'TodoCreatePayload', { "todo_id": Optional[int], "due_date": Optional[datetime], "frequency": Optional[str], "task": Optional[str], "timeSlot": Optional[int], "trackHabit": Optional[bool], "category": Optional[str], "remindBeforeDays": Optional[int] })
from enum import Enum from .config import FALLBACK_COLOR, USER_COLORS_DIR from typing import TYPE_CHECKING # pylint: disable=wrong-import-order if TYPE_CHECKING: from typing import List, Iterable, Optional, Callable # noqa from typing_extensions import TypedDict # noqa from .export_common import ExportDialog # noqa from .preview import ThemePreview # noqa from .preview_icons import IconThemePreview # noqa from .theme_model import ThemeModelValue # noqa from .theme_file_parser import ColorScheme # noqa AboutLink = TypedDict('AboutLink', {'name': str, 'url': str}) PLUGIN_PATH_PREFIX = "__plugin__" class OomoxPlugin(metaclass=ABCMeta): @property @abstractmethod def name(self) -> str: pass @property @abstractmethod def display_name(self) -> str: pass
from .message import ETMMsg from .msg_type import TGMsgType from .utils import TelegramChatID, EFBChannelChatIDStr, TgChatMsgIDStr, message_id_to_str, \ chat_id_to_str, OldMsgID, chat_id_str_to_id if TYPE_CHECKING: from . import TelegramChannel from .chat import ETMChatMember, ETMChatType database = SqliteDatabase(None) PickledDict = TypedDict( 'PickledDict', { "target": EFBChannelChatIDStr, "is_system": bool, "attributes": MessageAttribute, "commands": MessageCommands, "substitutions": Dict[Tuple[int, int], EFBChannelChatIDStr], "reactions": Dict[ReactionName, Collection[EFBChannelChatIDStr]] }, total=False) """ Dict entries for ``pickle`` field of ``msglog`` log. - ``target``: ``master_msg_id`` of the target message - ``is_system`` - ``attributes`` - ``commands`` - ``substitutions``: ``Dict[Tuple[int, int], SlaveChatID]`` - ``reactions``: ``Dict[str, Collection[SlaveChatID]]`` """
CONTAINER_ONLY: Final = 'container_only' DESCRIPTION: Final = "description" PATH_METHOD: Final = 'path' COMMANDS: Final = 'commands' SUCCESS: Final = 'success' FAILURE: Final = 'failure' COMMAND_NAME: Final = 'name' COMMAND_DESCRIPTION: Final = 'description' LEGACY_PATH_METHOD: Final = 'path_method' TypeUserConfiguration = TypedDict('TypeUserConfiguration', { 'name': str, 'description': str, 'container_only': bool, 'path': str, 'commands': List[str], 'success': str, 'failure': str, }, total=False) TypeLegacyUserConfiguration = TypedDict('TypeLegacyUserConfiguration', { 'name': str, 'description': str, 'container_only': bool, 'path_method': str, 'commands': List[str], 'success': str, 'failure': str, }, total=False)
from sentry_sdk._types import ( BreadcrumbProcessor, Event, EventProcessor, TracesSampler, ) # Experiments are feature flags to enable and disable certain unstable SDK # functionality. Changing them from the defaults (`None`) in production # code is highly discouraged. They are not subject to any stability # guarantees such as the ones from semantic versioning. Experiments = TypedDict( "Experiments", { "max_spans": Optional[int], "record_sql_params": Optional[bool], "smart_transaction_trimming": Optional[bool], "propagate_tracestate": Optional[bool], }, total=False, ) DEFAULT_QUEUE_SIZE = 100 DEFAULT_MAX_BREADCRUMBS = 100 # This type exists to trick mypy and PyCharm into thinking `init` and `Client` # take these arguments (even though they take opaque **kwargs) class ClientConstructor(object): def __init__( self, dsn=None, # type: Optional[str]