def _define_grammar(): from pyparsing import ( Literal as Literal, Word, Optional, alphas, alphanums, delimitedList, ) Separator = Literal("@").suppress() TagSeparator = Literal("?").suppress() Name = delimitedList(Word(alphas, alphanums + "_"), PATH_DELIM, combine=True).setResultsName("name") Tag = Word(alphas, alphanums + "_").setResultsName("tag") Selector = _selector_grammar.setResultsName("selector") SelectorType = (Literal("solids") | Literal("faces") | Literal("edges") | Literal("vertices")).setResultsName("selector_kind") return (Name + Optional(TagSeparator + Tag) + Optional(Separator + SelectorType + Separator + Selector))
def __init__( self, scale:Optinal(int)=0.8, image_ext:Optional(str)='.jpg', label_ext:Optional(str)='.txt' ) -> None: self.scale = scale self.image_ext = image_ext self.label_ext = label_ext
def make_bone( armature: bpy.types.Armature, name: str, head: Optional(Vector) = None, tail: Optional(Vector) = None, up: Optional(Vector) = None, parent: Optional(bpy.types.EditBone) ) -> bpy.types.EditBone: """ Creates a new bone in the specified armature and returns the EditBone representing it. :param armature: The Armature data in which to create the new bone. :param name: Name of the new bone to create. :param head: If not None, the head position of the new bone. :param tail: If not None, the tail position of the new bone. :param up: If not None, the up vector of the new bone for roll calculation. :param parent: Parent EditBone of this new bone. :return: an EditBone. :throws: ValueError if head, tail, or up are not mathutils.Vectors, if the Armature is not in edit mode, or if a bone by the specified name already exists """ if not bpy.context.mode == 'EDIT': raise ValueError('Armature "{}" not in Edit mode.'.format( armature.name)) for vector in head, tail, up: if vector and not isinstance(vector, Vector): raise ValueError( 'head, tail, and up must be None or mathutils.Vector.') if name in armature.edit_bones: raise ValueError( 'A bone named "{}" already exists in Armature "{}".'.format( name, armature.name)) if head is None: head = Vector([0, 0, 0]) if tail is None: tail = Vector([0, 2, 0]) bone = armature.edit_bones.new() ## copies are here to protect against passing another bone.head or bone.tail bone.head = head.copy() bone.tail = tail.copy() if up: bone.align_roll(up) if parent: bone.parent = parent return bone
def __init__(self, ip_info): security_data = ip_info['security'] self.is_proxy: bool = security_data['is_proxy'] self.proxy_type: Optional(str) = security_data['proxy_type'] self.is_crawler: bool = security_data['is_crawler'] self.crawler_name: Optional(str) = security_data['crawler_name'] self.crawler_type: Optional(str) = security_data['crawler_type'] self.is_tor: bool = security_data['is_tor'] self.threat_level: Optional(str) = security_data['threat_level'] self.threat_types: list = security_data['threat_types']
def __init__(self, log: bool = True, log_level: str = "INFO") -> None: self._log_level: str = log_level.upper() # Following attributes are set in :func:``_initialize`` self._ctx: Optional(plaidml.Context) = None self._supported_devices: Optional(List[plaidml._DeviceConfig]) = None self._all_devices: Optional(List[plaidml._DeviceConfig]) = None self._device_details: Optional(List[dict]) = None super().__init__(log=log)
def __init__(self: 'SemanticVersion', major: Counter = 0, minor: Optional(Counter) = 0, micro: Optional(Counter) = 0, prerelease: Optional[PreRelease] = None, build: Optional[Build] = None): self._major = major self._minor = minor self._micro = micro self._prerelease = PreRelease(prerelease) if prerelease else None self._build = Build(build) if build else None
class IntegerGrader(Grader): """ Numeric grader for integer values """ fields = { 'max': Optional(int), 'min': Optional(int), 'answer': int, } def grade(self, value): return 100 if self.answer == value else 0
class NumericGrader(Grader): """ Numeric float values. """ fields = { 'max': Optional(float), 'min': Optional(float), 'answer': float, 'tolerance': 0.0 } def grade(self, value): tol = self.tolerance return 100 if abs(value - self.answer) <= tol else 0
class Delivery(BaseModel): user: UUID name: str post: str permission: str available: bool task: set() = None is_deleted: bool = False events: Optional(List[events.Event]) = [] class Config: title = "Delivery" allow_mutations = False extra = "Forbid" def allocate(self, order: Shipping): if self.available == False: self.events.append(events.NotAvailable(self.user)) return None else: self.task.add(order) def can_deliver(self, order: Shipping) -> bool: return self.available def remove_shipping(self, order: Shipping): if order in self.task: self.task.remove(order) self.available = True def mark_completed(self, order: Shipping): if order in self.task: self.task.remove(order) self.task.order.status = "Completed"
def run(game: typing.Optional = None, rounds_total: int = 3): print('Welcome to the Brain Games!') if game is not None: print(game.DESCRIPTION) name = prompt.string('May I have your name? ') print(f'Hello {name}') if game is not None: current_round_num = 0 while current_round_num < rounds_total: question, answer = game.prepare_round() print(f'Question: {question}') user_answer = prompt.string("Your answer: ") if user_answer == answer: print('Correct!') current_round_num += 1 else: print(f"'{user_answer}' is wrong answer ;(. " f"Correct answer was '{answer}'.\n" f"Let's try again, {name}!") return print(f'Congratulations! {name}')
def get_elasticsearch_client(url: str) -> Elasticsearch: if ELASTICSEARCH_AWS_HOSTED: credentials = boto3.Session().get_credentials() return Elasticsearch( hosts=[url], http_auth=AWS4Auth( credentials.access_key, credentials.secret_key, ELASTICSEARCH_AWS_REGION, "es", session_token=credentials.token, ), use_ssl=True, verify_certs=True, connection_class=RequestsHttpConnection, ) else: api_key: Optional(Tuple[str, str]) = None if ELASTICSEARCH_API_KEY_ID and ELASTICSEARCH_API_KEY: api_key = (ELASTICSEARCH_API_KEY_ID, ELASTICSEARCH_API_KEY) return Elasticsearch( hosts=[url], timeout=ELASTICSEARCH_TIMEOUT, verify_certs=ELASTICSEARCH_VERIFY_CERTS, use_ssl=ELASTICSEARCH_USE_SSL, ssl_show_warn=ELASTICSEARCH_SSL_SHOW_WARN, ca_certs=ELASTICSEARCH_CA_CERTS, client_cert=ELASTICSEARCH_CLIENT_CERT, client_key=ELASTICSEARCH_CLIENT_KEY, api_key=api_key, )
def kmp_algo(inp_string: str, substr: str) -> Optional(int): """ Implementation of Knuth-Morrison-Pratt algorithm :param inp_string: String where substr is to be found (haystack) :param substr: substr to be found in inp_string (needle) :return: index where first occurrence of substr in inp_string started or None if not found """ def prefix_fun(prefix_str: str) -> List[int]: """ Prefix function for KMP :param prefix_str: dubstring for prefix function :return: prefix values table """ prefix_str = [0] * len(inp_string) for i in range(1, len(prefix_str)): k = prefix_str[i - 1] while k > 0 and prefix_str[k] != inp_string[i]: k = prefix_str[k - 1] if prefix_str[k] == inp_string[i]: k = k + 1 prefix_str[i] = k print(inp_string, substr, prefix_fun) return prefix_str
class ReviewTextInfo(NamedTuple): """商品レビュー内の1文に関する情報 Attributes: review_id (int): レビュー番号 last_review_id (int): 最後のレビュー番号 text_id (int): 文番号 last_text_id (int): 最後の文番号 star (float): 評価 title (str): レビューのタイトル review (str): レビュー全文 text (str): 対象としている文 result Optional(Dict[str, Tuple(AttrExtractionResult, ...)]): 抽出結果 """ review_id: int last_review_id: int text_id: int last_text_id: int star: float title: str review: str text: str result: Optional(Dict[str, Tuple(AttrExtractionResult, ...)]) @classmethod def from_dictionary(cls, dictionary: Dict[str, Any]): this = cls(**dictionary) result_dict = this.result for attr, results in result_dict.items(): result_dict[attr] = AttrExtractionResult(*results) return this._replace(result=result_dict)
def main(): settings: Optional(Settings) = None try: module_path: str = os.path.dirname( os.path.realpath(inspect.getfile(inspect.currentframe()))) settings = Settings(module_path) processChoices(settings) report_generated = False if settings.dump_document_structure: print("\n%s" % getDocumentStructureDocString(settings)) if settings.mass_report or len(settings.mass_report_members) > 0: writeMassReport(settings) report_generated = True elif settings.isFirmwareBinaryDefined(): exportDocument(settings) report_generated = True if settings.driver_template_file: settings.writeParameterTemplateFile( settings.driver_template_file, output_actual_values=report_generated) except Exception as exception: errorOutput(settings, exception, force_stacktrace=True) sys.exit(RETURN_CODE_UNRECOVERABLE_ERROR) else: print(f"{CHECKERED_FLAG} Done.") if error_handling.WARNINGS_OCCURRED: print(f"{WARNING} Watch out! Warnings occurred.") sys.exit(RETURN_CODE_WARNINGS_OCCURRED)
def _GetSiteData (siteModule: typing.Optional) -> typing.Dict[str, typing.Any]: if siteModule is None: return dict() if hasattr(siteModule, "GetSiteData"): return siteModule.GetSiteData() return dict()
def _GetModData(modModule: typing.Optional) -> typing.Dict[str, typing.Any]: if modModule is None: return dict() if hasattr(modModule, "GetModData"): return modModule.GetModData() return dict()
def selected_col(self)->Optional(str): """ Get selected feature value :return: Selected feature name r None if Nothing selected """ index = self.features_widget.currentIndex() if index < 1: return None return self.features[index]
def get_queue_by_id(queue_id: int) -> Optional(Queue): """ Find the queue by the queue_id.\n Inputs:\n queue_id --> The id of the queue to look for.\n Returns:\n The queue object, return None if it is not in the database.\n """ return Queue.query.filter_by(id=queue_id).first()
class PetForm(FlaskForm): name = StringField( "Pet Name", validators=[InputRequired(message="Name cannot be blank")]) species = SelectField("Species", choices=[('fish', 'Fish'), ('dog', 'Dog'), ('hedgehog', 'Hedgehog')]) photo_url = StringField("Photo Url", validators=[URL(), Optional()]) age = IntegerField("Pet Age", validators=[Optional(), NumberRange(min=0, max=30)]) notes = StringField("Notes") available = BooleanField("Is Available")
def serialize_optional(self, context: TypeEvaluationContext, tt: OptionalType, obj: Any): from ..._gen.com.digitalasset.ledger.api.v1.value_pb2 import Optional ut = tt.type_parameter optional_message = Optional() if obj is not None: ctor, val = self._serialize_dispatch(context.append_path('?'), ut, obj) _set_value(optional_message.value, ctor, val) return 'optional', optional_message
def convert_property(prop_name, prop): # it's datetime if "format" in prop and prop["format"] == "date-time": return "xsd:dataTime" # it's another object elif prop.get("type") is None and prop.get("$ref") is not None: prop_type = prop["$ref"].split("/")[-1] if defs is None or prop_type not in defs: raise RuntimeError(f"{prop_type} not found in defs.") if pipe: return self.from_json_schema(prop_type, defs[prop_type], pipe=True) else: self.from_json_schema(prop_type, defs[prop_type], subdoc=True) return self.object[prop_type]._to_dict() # it's enum elif prop.get("type") is None and prop.get("enum") is not None: # create enum name from snake case to camal case enum_name = prop_name.replace("_", " ").capitalize().replace( " ", "") enum_dict = { "@id": enum_name, "@type": "Enum", "@value": prop["enum"] } if pipe: return enum_dict else: self._contruct_class(enum_dict) return self.object[enum_name]._to_dict() # it's a List elif prop["type"] == "array": prop_type = convert_property(prop["items"]) return {"@type": "List", "@class": prop_type} elif isinstance(prop["type"], list): prop_type = prop["type"] # it's Optional if "null" in prop_type: prop_type.remove("null") prop_type = prop_type[0] # can only have one type # it's list in a 'type' so assume no ref return to_woql_type( Optional.__getitem__(convert_dict[prop_type])) # THIS SHOULD BE TaggedUnion # elif len(prop_type) > 1: # prop_type = to_woql_type( # Union.__getitem__(*map(lambda x: convert_dict[x], prop_type)) # ) # type is wrapped in a list else: return to_woql_type(convert_dict[prop_type[0]]) else: return to_woql_type(convert_dict[prop["type"]])
def __make_pydantic(cls): """ Temporary wrapper function to convert an MSONable class into a PyDantic Model for the sake of building schemas """ if any(cls == T for T in built_in_primitives): return cls if cls in prim_to_type_hint: return prim_to_type_hint[cls] if cls == Any: return Any if type(cls) == TypeVar: return cls if hasattr(cls, "__origin__") and hasattr(cls, "__args__"): args = tuple(__make_pydantic(arg) for arg in cls.__args__) if cls.__origin__ == Union: return Union.__getitem__(args) if cls.__origin__ == Optional and len(args) == 1: return Optional.__getitem__(args) if cls._name == "List": return List.__getitem__(args) if cls._name == "Tuple": return Tuple.__getitem__(args) if cls._name == "Set": return Set.__getitem__(args) if cls._name == "Sequence": return Sequence.__getitem__(args) if issubclass(cls, MSONable): if cls.__name__ not in STUBS: STUBS[cls] = MSONable_to_pydantic(cls) return STUBS[cls] if cls == ndarray: return List[Any] return cls
def invoke_all(*, requests: List, region: Optional(str='us-east-1')): async def wrapper(): async with aiohttp.ClientSession(raise_for_status=True) as session: invocations = run_invocations( requests=requests, default_region=region, session=session, ) return await asyncio.gather(*invocations) loop = asyncio.get_event_loop() results = loop.run_until_complete(wrapper()) return results
def preprocess_image_from_dir( self, dir_path: str, des_dir: Optional(str)='train_data' ) -> None: list_image_path = glob.glob(dir_path + '/*' + self.image_ext) list_image_path.sort() src_image_folder = os.path.join(des_dir, 'inputs') des_image_folder = os.path.join(des_dir, 'outputs') for image_path in list_image_path: image_name = image_path.split('/')[-1].replace('.jpg', '.png') print('Image name: {}'.format(image_name)) image, labels = self.read_image_and_label(image_path) shape = image.shape density = self.preprocess_image(image, labels) cv2.imwrite(os.path.join(src_image_folder, image_name), image[shape[0] // 2:, :, :]) cv2.imwrite(os.path.join(des_image_folder, image_name), density[shape[0] // 2:, :])
def get_numbers_of_pyments_in_lines( xml_file: str) -> Tuple[Optional[List[int]], Optional[str]]: """Получаем номера строк, где встречается Плательщик и возвращаем line_list или None""" line_list: List[int] = list() xml_encoding: Optional(str) = None with open(xml_file, 'r', encoding='windows-1251') as file: for num, line in enumerate(file): encoding = find_encoding_in_string(line) if encoding: xml_encoding = encoding if "<Плательщик>" in line: line_list.append(num) logger.info("Кодировка документа {0}".format(xml_encoding)) if line_list: return line_list, xml_encoding else: return None, xml_encoding
def _scan_file(self, results: ScanResults, user: NamedUser, org: Organization, repo: Repository, commitsha: str, filename: str, filelist: List[str]) -> None: file: Optional(ContentFile) = None content: str = None for scanner in self._scanners: if scanner.want(filename): if not file: file = repo.get_contents(filename, ref=commitsha) content = file.decoded_content.decode("utf-8") reposlug = "{}/{}".format(org.login, repo.name) result = scanner.check(reposlug, commitsha, file.sha, file.path, content, filelist) results.add(result)
def __init__(self, possible_actions: List[AVAILABLE_ACTION], game: GAME, prev_player: int = None, skip_actions=False, heuristic=None) -> None: self.children = {} self.possible_actions: Set[AVAILABLE_ACTION] = set(possible_actions) self._is_leaf: bool = True self.simulations: int = 0 self.wins: int = 0 self._state = game.get_state() self._terminating = game.done self.current_player = game.current_player self.prev_player = prev_player self.game = game self.skip_actions = skip_actions self.heuristic: Optional(List[float]) = heuristic( game._get_obs(), self.current_player) if heuristic else None
def kmp_algo(inp_string: str, substr: str) -> Optional(int): """ Implementation of Knuth-Morrison-Pratt algorithm :param inp_string: String where substr is to be found (haystack) :param substr: substr to be found in inp_string (needle) :return: index where first occurrence of substr in inp_string started or None if not found """ def prefix_fun(prefix_str: str) -> List[int]: """ Prefix function for KMP :param prefix_str: dubstring for prefix function :return: prefix values table """ print(prefix_str) return [] print(inp_string, substr, prefix_fun) return None
def run_invocations(*, requests: List, base_url: str, default_region: Optional(str), session): for request in requests: if not request.get('region') and not default_region: raise ValueError( 'Must provide a region, either in the invocation arguments or' 'as a default region when calling invoke_all') region = request.get('region') if type(request['region']) is str else \ default_region base_url = LAMBDA_ENDPOINT.format(region=region) url = os.path.join(base_url, request['function_name'], 'invocations') yield invoke( url=url, payload=request['payload'], invocation_type=request['invocation_type'], session=session, )
class Settings(BaseSettings): POSTGRES_SERVER: str POSTGRES_USER: str POSTGRES_PASSWORD: str POSTGRES_DB: str SQLALCHEMY_DATABASE_URI: Optional(PostgresDsn) = None @validator("SQLALCHEMY_DATABASE_URI", pre=True) def assemble_db_connection(cls, v: Optional[str], values: Dict[str, Any]) -> Any: if isinstance(v, str): return v return PostgresDsn.build(scheme="postgresql", user=values.get("POSTGRES_USER"), password=values.get("POSTGRES_PASSWORD"), host=values.get("POSTGRES_SERVER"), path=f"/{values.get('POSTGRES_DB') or ''}") class Config: case_sensitive = True env_file = ".env"