def to_dict(self, found: typing.Set = None) -> typing.Dict[str, typing.Any]: if found is None: found = set() mapper = class_mapper(self.__class__) columns = [column.key for column in mapper.columns] result = dict() for column in columns: if isinstance(getattr(self, column), type(datetime)): result[column] = getattr(self, column).isoformat() elif isinstance(getattr(self, column), enum.Enum): result[column] = getattr(self, column).name else: result[column] = getattr(self, column) for name, relation in mapper.relationships.items(): if relation not in found: found.add(relation) related_obj = getattr(self, name) if related_obj is not None: if relation.uselist: result[name] = [ child.to_dict(found) for child in related_obj ] else: result[name] = related_obj.to_dict(found) return result
def _tensor_dependencies(tensor: KerasTensor, visited: tp.Set): ref = tensor.ref() if ref not in visited: visited.add(ref) if isinstance(tensor, KerasTensor): # reject `EagerTensor`s for input_tensor in tf.nest.flatten(tensor.node.input_tensors): yield from _tensor_dependencies(input_tensor, visited) yield tensor
def dynamodb_attribute_to_set(cls, value: t.Set) -> t.Set: if len(value) == 1: elem = value.pop() if elem == cls.SET_PLACEHOLDER_VALUE: return set() else: value.add(elem) return value
def _find_target(self, node: TreeNode, nodes: typing.Set, k: int) -> bool: if not node: return False if k - node.val in nodes: return True nodes.add(node.val) return self._find_target(node.left, nodes, k) or self._find_target(node.right, nodes, k)
def resolve_parameter(self, parameter, kwargs: typing.Dict, consts: typing.Dict, seen_state: typing.Set, parent_parameter=None) -> typing.List[typing.Tuple]: """ Resolve a parameter by inferring the component that suits it or by adding a value to kwargs or consts. The list of steps returned consists of a resolver function, a boolean that indicates if the function is async, function kwargs and consts and the output name. :param parameter: parameter to be resolved. :param kwargs: kwargs that defines current context. :param consts: consts that defines current context. :param seen_state: cached state. :param parent_parameter: parent parameter. :return: list of steps to resolve the component. """ if parameter.annotation is ReturnValue: kwargs[parameter.name] = "return_value" return [] # Check if the parameter class exists in 'initial'. if parameter.annotation in self.reverse_initial: initial_kwarg = self.reverse_initial[parameter.annotation] kwargs[parameter.name] = initial_kwarg return [] # The 'Parameter' annotation can be used to get the parameter # itself. Used for example in 'Header' components that need the # parameter name in order to lookup a particular value. if parameter.annotation is inspect.Parameter: consts[parameter.name] = parent_parameter return [] for component in self.components: if component.can_handle_parameter(parameter): identity = component.identity(parameter) kwargs[parameter.name] = identity if identity not in seen_state: seen_state.add(identity) return self.resolve_component( resolver=component.resolve, output_name=identity, seen_state=seen_state, parent_parameter=parameter, ) return [] else: raise ComponentNotFound(parameter.name)
def find_possible_values(grid: List[List[str]], pos: Tuple[int, int]) -> Set[str]: """ Вернуть множество возможных значения для указанной позиции >>> grid = read_sudoku('puzzle1.txt') >>> values = find_possible_values(grid, (0,2)) >>> values == {'1', '2', '4'} True >>> values = find_possible_values(grid, (4,7)) >>> values == {'2', '5', '9'} True """ i, j = pos Set = set() row = get_row(grid, pos) col = get_col(grid, pos) block = get_block(grid, pos) for q in range(1, len(grid) + 1): if str(q) not in row and str(q) not in col and str(q) not in block: Set.add(str(q)) return Set
def __construct_project_panel_items(self, key_path: typing.List[str], node: TreeNode, closed: bool, project_panel_items: typing.List, closed_items: typing.Set, encountered_items: typing.Set) -> None: # if the node has no data (no projects) and no children, do not display it; move down a level. if len(node.data) == 0 and len(node.children) == 1: # this node represents a directory that only has a sub directory. # start by extracting the key and only child. key, child = list(node.children.items())[0] # if not root (the key path is not empty), combine the child with the key (directory path). if len(key_path) > 0: new_key = key_path[:-1] + [ key_path[-1] + (key if key_path[-1].endswith("/") else "/" + key) ] # otherwise combine the child with the key (directory path). else: new_key = [key] # recurse self.__construct_project_panel_items(new_key, child, closed, project_panel_items, closed_items, encountered_items) else: # this node represents a directory that more than one of either sub directory or project. folder_key = "/".join(key_path) folder_closed = folder_key in self.__closed_items or closed if len(key_path) > 0: encountered_items.add(folder_key) if not closed: # closed indicates whether the parent is closed project_panel_items.append( ProjectPanelFolderItem(node, len(key_path) - 1, key_path[-1], folder_closed, folder_key)) for key, child in node.children.items(): self.__construct_project_panel_items(key_path + [key], child, folder_closed, project_panel_items, closed_items, encountered_items) for project_reference in typing.cast( typing.Sequence[Profile.ProjectReference], node.data): project_reference_parts = project_reference.project_reference_parts project_key = "/".join(key_path + [project_reference_parts[-1]] ) if project_reference_parts else str( id(project_reference)) encountered_items.add(project_key) if not folder_closed: def handle_item_controller_title_changed(t: str) -> None: self.property_changed_event.fire("value") display_item_counter = ProjectCounterDisplayItem( project_reference) display_item_counter.on_title_changed = handle_item_controller_title_changed project_panel_items.append( ProjectPanelProjectItem(len(key_path), project_reference, display_item_counter))