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))
