PlayerData = TypedDict(
"PlayerData",
{
"season": int,
"round": str,
"date": str,
"local_start_time": str,
"venue": str,
"attendance": int,
"home_team": str,
"hq1g": int,
"hq1b": int,
"hq2g": int,
"hq2b": int,
"hq3g": int,
"hq3b": int,
"hq4g": int,
"hq4b": int,
"home_score": int,
"away_team": str,
"aq1g": int,
"aq1b": int,
"aq2g": int,
"aq2b": int,
"aq3g": int,
"aq3b": int,
"aq4g": int,
"aq4b": int,
"away_score": int,
"first_name": str,
"surname": str,
"id": int,
"jumper_no": int,
"playing_for": str,
"kicks": int,
"marks": int,
"handballs": int,
"goals": int,
"behinds": int,
"hit_outs": int,
"tackles": int,
"rebounds": int,
"inside_50s": int,
"clearances": int,
"clangers": int,
"frees_for": int,
"frees_against": int,
"brownlow_votes": int,
"contested_possessions": int,
"uncontested_possessions": int,
"contested_marks": int,
"marks_inside_50": int,
"one_percenters": int,
"bounces": int,
"goal_assists": int,
"time_on_ground": int,
"substitute": int,
"umpire_1": str,
"umpire_2": str,
"umpire_3": str,
"umpire_4": str,
"group_id": int,
},
)
def internal_dissolve_vector(
vector: Union[str, ogr.DataSource],
attribute: Optional[str] = None,
out_path: str = None,
overwrite: bool = True,
add_index: bool = True,
process_layer: int = -1,
) -> str:
"""Clips a vector to a geometry."""
type_check(vector, [str, ogr.DataSource], "vector")
type_check(attribute, [str], "attribute", allow_none=True)
type_check(out_path, [str], "out_path", allow_none=True)
type_check(overwrite, [bool], "overwrite")
type_check(add_index, [bool], "add_index")
type_check(process_layer, [int], "process_layer")
vector_list, path_list = ready_io_vector(vector, out_path)
out_name = path_list[0]
out_format = path_to_driver_vector(out_name)
driver = ogr.GetDriverByName(out_format)
ref = open_vector(vector_list[0])
metadata = internal_vector_to_metadata(ref)
Layer_info = TypedDict(
"Layer_info",
{
"name": str,
"geom": str,
"fields": List[str]
},
)
layers: List[Layer_info] = []
if process_layer == -1:
for index in range(len(metadata["layers"])):
layers.append({
"name": metadata["layers"][index]["layer_name"],
"geom": metadata["layers"][index]["column_geom"],
"fields": metadata["layers"][index]["field_names"],
})
else:
layers.append({
"name":
metadata["layers"][process_layer]["layer_name"],
"geom":
metadata["layers"][process_layer]["column_geom"],
"fields":
metadata["layers"][process_layer]["field_names"],
})
destination: ogr.DataSource = driver.CreateDataSource(out_name)
# Check if attribute table is valid
for index in range(len(metadata["layers"])):
layer = layers[index]
if attribute is not None and attribute not in layer["fields"]:
layer_fields = layer["fields"]
raise ValueError(
f"Invalid attribute for layer. Layers has the following fields: {layer_fields}"
)
geom_col = layer["geom"]
name = layer["name"]
sql = None
if attribute is None:
sql = f"SELECT ST_Union({geom_col}) AS geom FROM {name};"
else:
sql = f"SELECT {attribute}, ST_Union({geom_col}) AS geom FROM {name} GROUP BY {attribute};"
result = ref.ExecuteSQL(sql, dialect="SQLITE")
destination.CopyLayer(result, name, ["OVERWRITE=YES"])
if add_index:
vector_add_index(destination)
destination.FlushCache()
return out_name
import os
from mypy_extensions import TypedDict
Environment = TypedDict(
"Environment",
{
"permission_url": str,
"media_url": str,
"datastore_reader_url": str,
"datastore_writer_url": str,
},
)
DEFAULTS = {
"PERMISSION_PROTOCOL": "http",
"PERMISSION_HOST": "localhost",
"PERMISSION_PORT": "9005",
"PERMISSION_PATH": "/internal/permission",
"MEDIA_PROTOCOL": "http",
"MEDIA_HOST": "localhost",
"MEDIA_PORT": "9006",
"MEDIA_PATH": "/internal/media",
"DATASTORE_READER_PROTOCOL": "http",
"DATASTORE_READER_HOST": "localhost",
"DATASTORE_READER_PORT": "9010",
"DATASTORE_READER_PATH": "/internal/datastore/reader",
"DATASTORE_WRITER_PROTOCOL": "http",
"DATASTORE_WRITER_HOST": "localhost",
"DATASTORE_WRITER_PORT": "9011",
"DATASTORE_WRITER_PATH": "/internal/datastore/writer",
class SearchResults(NamedTuple):
"""Represents a set of search results."""
total_hits: int
previous_page: Optional[int]
current_page: int
next_page: Optional[int]
limit: int
start: int
end: int
total: int
scored_hits: int
results: List[SearchResult]
class IndexablePage(NamedTuple):
"""Representation of a source page suitable for indexing."""
page: SourcePage
indexable_content: str
SiteTreePart = TypedDict('SiteTreePart', {
'children': 'SiteTree',
'title': str,
'path': str
})
SiteTree = Dict[str, SiteTreePart]
import asyncio
import time
from typing import List, Any, Dict, Union, Awaitable, Optional
from mypy_extensions import TypedDict
from aiocrypto_prices._api_requests import fetch_price_data, fetch_coin_list
from aiocrypto_prices.exceptions import CurrencyNotFound, UnfetchedInformation
CurrencyKwargs = TypedDict(
'CurrencyKwargs', {
'cache': int,
'target_currencies': List[str],
'full': bool,
'historical': Optional[str],
'human': bool
})
class Prices:
"""Prices object"""
def __init__(self, currency: 'Currency') -> None:
self._prices: Dict[str, float] = {}
self._currency = currency
async def get(self, target_currency: str, default: float = 0.0) -> float:
"""
Gets the price for a specified currency, if currency is not in target currencies,
it's added there for the specific currency
:param target_currency: Currency to get converted price for
config = ConfigHandler()
"""
Final entry point to get an set config variables. To get a config variable
use x = config[...], to set it use config[...] = x.
"""
T = TypeVar('T')
ChoiceType = Optional[Iterable[Dict[str, str]]]
ChoiceCallableType = Union[ChoiceType, Callable[[], ChoiceType]]
ValidatorsType = Iterable[Callable[[T], None]]
OnChangeType = Callable[[], None]
ConfigVariableDict = TypedDict('ConfigVariableDict', {
'key': str,
'default_value': Any,
'input_type': str,
'label': str,
'help_text': str,
'choices': ChoiceType,
})
class ConfigVariable:
"""
A simple object class to wrap new config variables.
The keyword arguments 'name' and 'default_value' are required.
The keyword arguments 'input_type', 'label', 'help_text' and 'hidden'
are for rendering a HTML form element. The 'input_type is also used for
validation. If you set 'input_type' to 'choice' you have to provide
'choices', which is a list of dictionaries containing a value and a
RawDeckDescription = TypedDict(
'RawDeckDescription',
{
'name': str, # Name of Deck
'url': str, # Source URL of Deck
'source': str, # Source name
'identifier': str, # Unique ID
'cards': CardsDescription, # Contents of Deck
'archetype': Optional[str],
'created_date':
float, # Date deck was created. If null, current time will be used.
# One of these three usernames is required:
'mtgo_username': Optional[str],
'tappedout_username': Optional[str],
'mtggoldfish_username': Optional[str],
# TappedOut Variables
'resource_uri': Optional[str],
'featured_card': Optional[str],
'score': Optional[int],
'thumbnail_url': Optional[str],
'small_thumbnail_url': Optional[str],
'slug': Optional[str],
'user': Optional[str], # This is mapped to tappedout_username
# Competition variables (League/Gatherling)
'competition_id': Optional[int],
'finish': Optional[int],
'wins': int,
'losses': int,
'draws': int,
},
total=False)
"""
Final entry point to get an set config variables. To get a config variable
use x = config[...], to set it use config[...] = x.
"""
T = TypeVar("T")
ChoiceType = Optional[Iterable[Dict[str, str]]]
ChoiceCallableType = Union[ChoiceType, Callable[[], ChoiceType]]
ValidatorsType = Iterable[Callable[[T], None]]
OnChangeType = Callable[[], None]
ConfigVariableDict = TypedDict(
"ConfigVariableDict",
{
"key": str,
"default_value": Any,
"input_type": str,
"label": str,
"help_text": str,
"choices": ChoiceType,
},
)
class ConfigVariable:
"""
A simple object class to wrap new config variables.
The keyword arguments 'name' and 'default_value' are required.
The keyword arguments 'input_type', 'label', 'help_text' and 'hidden'
are for rendering a HTML form element. The 'input_type is also used for
to_dict, )
from mypy_extensions import (
TypedDict, )
from ssz.exceptions import (
DeserializationError, )
from ssz.hash import (
hash_eth2, )
from ssz.sedes.base import (
BaseSedes,
LengthPrefixedSedes,
)
from ssz.utils import (
get_duplicates, )
AnyTypedDict = TypedDict("AnyTypedDict", {})
TAnyTypedDict = TypeVar("TAnyTypedDict", bound=AnyTypedDict)
class Container(LengthPrefixedSedes[TAnyTypedDict, Dict[str, Any]]):
length_bytes = 4
def __init__(self, fields: Sequence[Tuple[str, BaseSedes[Any,
Any]]]) -> None:
field_names = tuple(field_name for field_name, field_sedes in fields)
duplicate_field_names = get_duplicates(field_names)
if duplicate_field_names:
raise ValueError(
f"The following fields are duplicated {','.join(sorted(duplicate_field_names))}"
)
from mypy_extensions import TypedDict
from speclib import array
curve448_test = TypedDict('curve448_test', {
'private': str,
'public': str,
'result': str,
'valid': bool
})
curve448_test_vectors: array[curve448_test] = array([{
'private':
'3d262fddf9ec8e88495266fea19a34d28882acef045104d0d1aae121700a779c984c24f8cdd78fbff44943eba368f54b29259a4f1c600ad3',
'public':
'06fce640fa3487bfda5f6cf2d5263f8aad88334cbd07437f020f08f9814dc031ddbdc38c19c6da2583fa5429db94ada18aa7a7fb4ef8a086',
'result':
'ce3e4ff95a60dc6697da1db1d85e6afbdf79b50a2412d7546d5f239fe14fbaadeb445fc66a01b0779d98223961111e21766282f73dd96b6f',
'valid': True
}, {
'private':
'203d494428b8399352665ddca42f9de8fef600908e0d461cb021f8c538345dd77c3e4806e25f46d3315c44e0a5b4371282dd2c8d5be3095f',
'public':
'0fbcc2f993cd56d3305b0b7d9e55d4c1a8fb5dbb52f8e9a1e9b6201b165d015894e56c4d3570bee52fe205e28a78b91cdfbde71ce8d157db',
'result':
'884a02576239ff7a2f2f63b2db6a9ff37047ac13568e1e30fe63c4a7ad1b3ee3a5700df34321d62077e63633c575c1c954514e99da7c179d',
'valid': True
}, {
'private':
'9a8f4925d1519f5775cf46b04b5800d4ee9ee8bae8bc5565d498c28dd9c9baf574a9419744897391006382a6f127ab1d9ac2d8c0a598726b',
'public':
'3eb7a829b0cd20f5bcfc0b599b6feccf6da4627107bdb0d4f345b43027d8b972fc3e34fb4232a13ca706dcb57aec3dae07bdc1c67bf33609',
Hash32,
HexStr,
)
from mypy_extensions import (
TypedDict,
)
if TYPE_CHECKING:
from eth.abc import VirtualMachineAPI # noqa: F401
JournalDBCheckpoint = NewType('JournalDBCheckpoint', int)
AccountDetails = TypedDict('AccountDetails',
{'balance': int,
'nonce': int,
'code': bytes,
'storage': Dict[int, int]
})
AccountState = Dict[Address, AccountDetails]
AccountDiff = Iterable[Tuple[Address, str, Union[int, bytes], Union[int, bytes]]]
GeneralState = Union[
AccountState,
List[Tuple[Address, Dict[str, Union[int, bytes, Dict[int, int]]]]]
]
GenesisDict = Dict[str, Union[int, BlockNumber, bytes, Hash32]]
BytesOrView = Union[bytes, memoryview]
# notifications to match the model of push notifications
# above.
if idle and (private_message or mentioned):
# We require RabbitMQ to do this, as we can't call the email handler
# from the Tornado process. So if there's no rabbitmq support do nothing
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, users):
# type: (Mapping[str, Any], 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 typing import Any, Dict, List, Optional, Set, Union
import simplejson as json
from mypy_extensions import TypedDict
from ...shared.filters import Filter as FilterInterface
from ...shared.filters import FilterData
from ...shared.interfaces import Event, WriteRequestElement
from ...shared.patterns import Collection, FullQualifiedId
from .deleted_models_behaviour import DeletedModelsBehaviour
GetManyRequestData = TypedDict(
"GetManyRequestData",
{
"collection": str,
"ids": List[int],
"mapped_fields": List[str]
},
total=False,
)
class GetManyRequest:
"""
Encapsulates a single GetManyRequest to be used for get_many requests to the
datastore.
"""
mapped_fields: Optional[Set[str]]
def __init__(
class MesosState(TypedDict):
slaves: List
frameworks: List
orphan_tasks: List
MesosMetrics = TypedDict(
"MesosMetrics",
{
"master/cpus_total": int,
"master/cpus_used": int,
"master/disk_total": int,
"master/disk_used": int,
"master/gpus_total": int,
"master/gpus_used": int,
"master/mem_total": int,
"master/mem_used": int,
"master/tasks_running": int,
"master/tasks_staging": int,
"master/tasks_starting": int,
"master/slaves_active": int,
"master/slaves_inactive": int,
},
)
class MesosMaster:
def __init__(self, config):
self.config = config
def __str__(self):
tracer = jaeger_config.initialize_tracer()
app = Starlette(debug=True)
app.add_middleware(CORSMiddleware,
allow_origins=["*"],
allow_methods=["*"],
allow_headers=["*"])
SPANS: typing.Dict[str, opentracing.Span] = {}
StartSpanExtractRequest = TypedDict(
"StartSpanExtractRequest",
{
"name": str,
"reference": dict,
"relationship": typing.Union[Literal["child_of"],
Literal["follows_from"]],
},
)
StartSpanRequest = TypedDict(
"StartSpanRequest",
{
"name": str,
"reference": dict,
"relationship": typing.Union[Literal["child_of"],
Literal["follows_from"]],
},
)
from collections import OrderedDict, defaultdict
from functools import partial
from itertools import chain
from typing import TYPE_CHECKING, Any, Dict, List, NamedTuple, Optional, Tuple
from warnings import warn
from . import place
from .comments import parse as parse_comments
from .deprecated.finders import FindersManager
from .settings import DEFAULT_CONFIG, Config
if TYPE_CHECKING:
from mypy_extensions import TypedDict
CommentsAboveDict = TypedDict("CommentsAboveDict", {
"straight": Dict[str, Any],
"from": Dict[str, Any]
})
CommentsDict = TypedDict(
"CommentsDict",
{
"from": Dict[str, Any],
"straight": Dict[str, Any],
"nested": Dict[str, Any],
"above": CommentsAboveDict,
},
)
def _infer_line_separator(contents: str) -> str:
if "\r\n" in contents:
if TYPE_CHECKING:
from mypy_extensions import TypedDict
else:
def TypedDict(*args, **kwargs):
pass
Span = TypedDict(
"Span",
{
"trace_id": str,
"parent_span_id": str,
"span_id": str,
"start_timestamp": float,
"timestamp": float,
"same_process_as_parent": bool,
"op": str,
"description": Optional[str],
"fingerprint": Optional[Sequence[str]],
"tags": Optional[Any],
"data": Optional[Any],
},
)
# A callable strategy is a callable that when given a span, it tries to
# returns a fingerprint. If the strategy does not apply to the span, it
# should return `None` to indicate that the strategy should not be used
# and to try a different strategy. If the strategy does apply, it should
# return a list of strings that will serve as the span fingerprint.
CallableStrategy = Callable[[Span], Optional[Sequence[str]]]
from mypy_extensions import TypedDict
from pip._internal.distributions import AbstractDistribution
from pip._internal.index.package_finder import PackageFinder
from pip._internal.models.link import Link
from pip._internal.network.download import Downloader
from pip._internal.req.req_install import InstallRequirement
from pip._internal.req.req_tracker import RequirementTracker
from pip._internal.utils.hashes import Hashes
if PY2:
CopytreeKwargs = TypedDict(
'CopytreeKwargs',
{
'ignore': Callable[[str, List[str]], List[str]],
'symlinks': bool,
},
total=False,
)
else:
CopytreeKwargs = TypedDict(
'CopytreeKwargs',
{
'copy_function': Callable[[str, str], None],
'ignore': Callable[[str, List[str]], List[str]],
'ignore_dangling_symlinks': bool,
'symlinks': bool,
},
total=False,
)
from paasta_tools.utils import load_system_paasta_config
from paasta_tools.utils import paasta_print
from paasta_tools.utils import PaastaColors
from paasta_tools.utils import print_with_indent
from paasta_tools.utils import set_paasta_print_file
log = logging.getLogger('paasta_metastatus')
logging.basicConfig()
# kazoo can be really noisy - turn it down
logging.getLogger("kazoo").setLevel(logging.CRITICAL)
logging.getLogger("paasta_tools.autoscaling.autoscaling_cluster_lib").setLevel(
logging.ERROR)
ServiceInstanceStats = TypedDict('ServiceInstanceStats', {
'mem': float,
'cpus': float,
'disk': float,
'gpus': int
})
class FatalError(Exception):
def __init__(
self,
exit_code: int,
) -> None:
self.exit_code = exit_code
def parse_args(argv):
parser = argparse.ArgumentParser(description='', )
parser.add_argument(
import six
from six.moves import urllib, zip_longest
from mypy_extensions import TypedDict
# no imports from cwltool allowed
if os.name == 'posix':
import subprocess32 as subprocess # type: ignore # pylint: disable=import-error,unused-import
else:
import subprocess # type: ignore # pylint: disable=unused-import
windows_default_container_id = "frolvlad/alpine-bash"
Directory = TypedDict('Directory',
{'class': Text, 'listing': List[Dict[Text, Text]],
'basename': Text})
DEFAULT_TMP_PREFIX = "tmp"
processes_to_kill = collections.deque() # type: Deque[subprocess.Popen]
def versionstring():
# type: () -> Text
'''
version of CWLtool used to execute the workflow.
'''
pkg = pkg_resources.require("cwltool")
if pkg:
return u"%s %s" % (sys.argv[0], pkg[0].version)
return u"%s %s" % (sys.argv[0], "unknown version")
def make_builtin_typed_dict(self, name, annotations, total):
return TypedDict(name, annotations, total=total)
return timezone_info['error_message']
if timezone_info['status'] == 'ZERO_RESULTS':
raise TooFewItemsException(timezone_info['status'])
try:
timezone = dtutil.timezone(timezone_info['timeZoneId'])
except KeyError as e:
raise TooFewItemsException(
f'Unable to find a timezone in {timezone_info}')
return {
current_time(timezone, twentyfour):
[info['results'][0]['formatted_address']]
}
WISDateType = TypedDict('WISDateType', {
'exact': str,
'rough': str,
})
WISSetInfoType = TypedDict(
'WISSetInfoType', {
'name': str,
'code': str,
'codename': str,
'mtgoCode': str,
'symbol': str,
'enterDate': WISDateType,
'exitDate': WISDateType,
})
WISSchemaType = TypedDict('WISSchemaType', {
'deprecated': bool,
healthcheck_interval_seconds: float
healthcheck_max_consecutive_failures: int
healthcheck_mode: str
healthcheck_timeout_seconds: float
healthcheck_uri: str
instances: int
max_instances: int
min_instances: int
nerve_ns: str
registrations: List[str]
replication_threshold: int
bounce_priority: int
# Defined here to avoid import cycles -- this gets used in bounce_lib and subclassed in marathon_tools.
BounceMethodConfigDict = TypedDict('BounceMethodConfigDict', {"instances": int})
class ServiceNamespaceConfig(dict):
def get_healthcheck_mode(self) -> str:
"""Get the healthcheck mode for the service. In most cases, this will match the mode
of the service, but we do provide the opportunity for users to specify both. Default to the mode
if no healthcheck_mode is specified.
"""
healthcheck_mode = self.get('healthcheck_mode', None)
if not healthcheck_mode:
return self.get_mode()
else:
return healthcheck_mode
use x = config[...], to set it use config[...] = x.
"""
T = TypeVar("T")
ChoiceType = Optional[Iterable[Dict[str, str]]]
ChoiceCallableType = Union[ChoiceType, Callable[[], ChoiceType]]
ValidatorsType = Iterable[Callable[[T], None]]
OnChangeType = Callable[[], None]
ConfigVariableDict = TypedDict(
"ConfigVariableDict",
{
"defaultValue": Any,
"inputType": str,
"label": str,
"helpText": str,
"choices": ChoiceType,
"weight": int,
"group": str,
"subgroup": Optional[str],
},
)
class ConfigVariable:
"""
A simple object class to wrap new config variables.
The keyword arguments 'name' and 'default_value' are required.
The keyword arguments 'input_type', 'label', 'help_text' and 'hidden'
healthcheck_interval_seconds: float
healthcheck_max_consecutive_failures: int
healthcheck_mode: str
healthcheck_timeout_seconds: float
healthcheck_uri: str
instances: int
max_instances: int
min_instances: int
nerve_ns: str
registrations: List[str]
replication_threshold: int
bounce_start_deadline: float
# Defined here to avoid import cycles -- this gets used in bounce_lib and subclassed in marathon_tools.
BounceMethodConfigDict = TypedDict("BounceMethodConfigDict",
{"instances": int})
class ServiceNamespaceConfig(dict):
def get_healthcheck_mode(self) -> str:
"""Get the healthcheck mode for the service. In most cases, this will match the mode
of the service, but we do provide the opportunity for users to specify both. Default to the mode
if no healthcheck_mode is specified.
"""
healthcheck_mode = self.get("healthcheck_mode", None)
if not healthcheck_mode:
return self.get_mode()
else:
return healthcheck_mode
def get_mode(self) -> str:
from pytest import approx # type: ignore
def test_temperature():
assert temperature(f_temp=72) == {"c_temp": approx(22.22222), "f_temp": 72}
assert temperature(c_temp=22.2) == {
"c_temp": 22.2,
"f_temp": approx(71.96)
}
from mypy_extensions import TypedDict
TempDict = TypedDict("TempDict", {
"c_temp": float,
"f_temp": float,
})
def temperature_d(*,
f_temp: Optional[float] = None,
c_temp: Optional[float] = None) -> TempDict:
"""Convert between Fahrenheit temperature and
Celsius temperature.
:key f_temp: Temperature in °F.
:key c_temp: Temperature in °C.
:returns: dictionary with two keys:
:f_temp: Temperature in °F.
:c_temp: Temperature in °C.
"""
else:
return all([
res.get("since", 0) < (time.time() - self.delay)
for res in results
])
class StatusCodeNotAcceptableError(Exception):
pass
UrlSpec = TypedDict(
'UrlSpec',
{
'url_format': str,
'method': str,
'success_codes': str,
},
total=False,
)
@register_drain_method('http')
class HTTPDrainMethod(DrainMethod):
"""This drain policy issues arbitrary HTTP calls to arbitrary URLs specified by the parameters. The URLs are
specified as format strings, and will have variables such as {host}, {port}, etc. filled in."""
def __init__(
self,
service: str,
instance: str,
registrations: List[str],
def rewrite_TypedDict(self, typed_dict):
return TypedDict(typed_dict.__name__, {
name: self.rewrite(typ)
for name, typ in typed_dict.__annotations__.items()
},
total=typed_dict.__total__)
UserProfile,
UserMessage,
Reaction,
get_usermessage_by_message_id,
)
from typing import Any, Dict, List, Optional, Set, Tuple, Union, Sequence
from mypy_extensions import TypedDict
RealmAlertWords = Dict[int, List[str]]
RawUnreadMessagesResult = TypedDict(
'RawUnreadMessagesResult', {
'pm_dict': Dict[int, Any],
'stream_dict': Dict[int, Any],
'huddle_dict': Dict[int, Any],
'mentions': Set[int],
'muted_stream_ids': List[int],
'unmuted_stream_msgs': Set[int],
})
UnreadMessagesResult = TypedDict(
'UnreadMessagesResult', {
'pms': List[Dict[str, Any]],
'streams': List[Dict[str, Any]],
'huddles': List[Dict[str, Any]],
'mentions': List[int],
'count': int,
})
# We won't try to fetch more unread message IDs from the database than
import traceback
from datetime import date
from email.utils import formatdate
from glob import glob
import magic
from debian.deb822 import Deb822
from . import message_catalogs, sourcefileprocessing, umc
from .helper import make_parent_dir
try:
from typing import Any, Dict, Iterable, Iterator, List, Optional, Pattern, Tuple, Type # noqa F401
from types import TracebackType # noqa
from mypy_extensions import TypedDict
BaseModule = TypedDict('BaseModule', {'module_name': str, 'binary_package_name': str, 'abs_path_to_src_pkg': str, 'relative_path_src_pkg': str})
except ImportError:
pass
REFERENCE_LANG = 'de'
UMC_MODULES = '.umc-modules'
# Use this set to ignore whole sub trees of a given source tree
DIR_BLACKLIST = {
'doc',
'umc-module-templates',
'test',
'testframework',
}
# do not translate modules with these names, as they are examples and thus not worth the effort
MODULE_BLACKLIST = {
