repo
stringlengths 7
55
| path
stringlengths 4
223
| func_name
stringlengths 1
134
| original_string
stringlengths 75
104k
| language
stringclasses 1
value | code
stringlengths 75
104k
| code_tokens
listlengths 19
28.4k
| docstring
stringlengths 1
46.9k
| docstring_tokens
listlengths 1
1.97k
| sha
stringlengths 40
40
| url
stringlengths 87
315
| partition
stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.init_default
|
def init_default(cls):
"""
Creates a ``Board`` with the standard chess starting position.
:rtype: Board
"""
return cls([
# First rank
[Rook(white, Location(0, 0)), Knight(white, Location(0, 1)), Bishop(white, Location(0, 2)),
Queen(white, Location(0, 3)), King(white, Location(0, 4)), Bishop(white, Location(0, 5)),
Knight(white, Location(0, 6)), Rook(white, Location(0, 7))],
# Second rank
[Pawn(white, Location(1, file)) for file in range(8)],
# Third rank
[None for _ in range(8)],
# Fourth rank
[None for _ in range(8)],
# Fifth rank
[None for _ in range(8)],
# Sixth rank
[None for _ in range(8)],
# Seventh rank
[Pawn(black, Location(6, file)) for file in range(8)],
# Eighth rank
[Rook(black, Location(7, 0)), Knight(black, Location(7, 1)), Bishop(black, Location(7, 2)),
Queen(black, Location(7, 3)), King(black, Location(7, 4)), Bishop(black, Location(7, 5)),
Knight(black, Location(7, 6)), Rook(black, Location(7, 7))]
])
|
python
|
def init_default(cls):
"""
Creates a ``Board`` with the standard chess starting position.
:rtype: Board
"""
return cls([
# First rank
[Rook(white, Location(0, 0)), Knight(white, Location(0, 1)), Bishop(white, Location(0, 2)),
Queen(white, Location(0, 3)), King(white, Location(0, 4)), Bishop(white, Location(0, 5)),
Knight(white, Location(0, 6)), Rook(white, Location(0, 7))],
# Second rank
[Pawn(white, Location(1, file)) for file in range(8)],
# Third rank
[None for _ in range(8)],
# Fourth rank
[None for _ in range(8)],
# Fifth rank
[None for _ in range(8)],
# Sixth rank
[None for _ in range(8)],
# Seventh rank
[Pawn(black, Location(6, file)) for file in range(8)],
# Eighth rank
[Rook(black, Location(7, 0)), Knight(black, Location(7, 1)), Bishop(black, Location(7, 2)),
Queen(black, Location(7, 3)), King(black, Location(7, 4)), Bishop(black, Location(7, 5)),
Knight(black, Location(7, 6)), Rook(black, Location(7, 7))]
])
|
[
"def",
"init_default",
"(",
"cls",
")",
":",
"return",
"cls",
"(",
"[",
"# First rank",
"[",
"Rook",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"0",
")",
")",
",",
"Knight",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"1",
")",
")",
",",
"Bishop",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"2",
")",
")",
",",
"Queen",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"3",
")",
")",
",",
"King",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"4",
")",
")",
",",
"Bishop",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"5",
")",
")",
",",
"Knight",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"6",
")",
")",
",",
"Rook",
"(",
"white",
",",
"Location",
"(",
"0",
",",
"7",
")",
")",
"]",
",",
"# Second rank",
"[",
"Pawn",
"(",
"white",
",",
"Location",
"(",
"1",
",",
"file",
")",
")",
"for",
"file",
"in",
"range",
"(",
"8",
")",
"]",
",",
"# Third rank",
"[",
"None",
"for",
"_",
"in",
"range",
"(",
"8",
")",
"]",
",",
"# Fourth rank",
"[",
"None",
"for",
"_",
"in",
"range",
"(",
"8",
")",
"]",
",",
"# Fifth rank",
"[",
"None",
"for",
"_",
"in",
"range",
"(",
"8",
")",
"]",
",",
"# Sixth rank",
"[",
"None",
"for",
"_",
"in",
"range",
"(",
"8",
")",
"]",
",",
"# Seventh rank",
"[",
"Pawn",
"(",
"black",
",",
"Location",
"(",
"6",
",",
"file",
")",
")",
"for",
"file",
"in",
"range",
"(",
"8",
")",
"]",
",",
"# Eighth rank",
"[",
"Rook",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"0",
")",
")",
",",
"Knight",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"1",
")",
")",
",",
"Bishop",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"2",
")",
")",
",",
"Queen",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"3",
")",
")",
",",
"King",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"4",
")",
")",
",",
"Bishop",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"5",
")",
")",
",",
"Knight",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"6",
")",
")",
",",
"Rook",
"(",
"black",
",",
"Location",
"(",
"7",
",",
"7",
")",
")",
"]",
"]",
")"
] |
Creates a ``Board`` with the standard chess starting position.
:rtype: Board
|
[
"Creates",
"a",
"Board",
"with",
"the",
"standard",
"chess",
"starting",
"position",
"."
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L73-L108
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.material_advantage
|
def material_advantage(self, input_color, val_scheme):
"""
Finds the advantage a particular side possesses given a value scheme.
:type: input_color: Color
:type: val_scheme: PieceValues
:rtype: double
"""
if self.get_king(input_color).in_check(self) and self.no_moves(input_color):
return -100
if self.get_king(-input_color).in_check(self) and self.no_moves(-input_color):
return 100
return sum([val_scheme.val(piece, input_color) for piece in self])
|
python
|
def material_advantage(self, input_color, val_scheme):
"""
Finds the advantage a particular side possesses given a value scheme.
:type: input_color: Color
:type: val_scheme: PieceValues
:rtype: double
"""
if self.get_king(input_color).in_check(self) and self.no_moves(input_color):
return -100
if self.get_king(-input_color).in_check(self) and self.no_moves(-input_color):
return 100
return sum([val_scheme.val(piece, input_color) for piece in self])
|
[
"def",
"material_advantage",
"(",
"self",
",",
"input_color",
",",
"val_scheme",
")",
":",
"if",
"self",
".",
"get_king",
"(",
"input_color",
")",
".",
"in_check",
"(",
"self",
")",
"and",
"self",
".",
"no_moves",
"(",
"input_color",
")",
":",
"return",
"-",
"100",
"if",
"self",
".",
"get_king",
"(",
"-",
"input_color",
")",
".",
"in_check",
"(",
"self",
")",
"and",
"self",
".",
"no_moves",
"(",
"-",
"input_color",
")",
":",
"return",
"100",
"return",
"sum",
"(",
"[",
"val_scheme",
".",
"val",
"(",
"piece",
",",
"input_color",
")",
"for",
"piece",
"in",
"self",
"]",
")"
] |
Finds the advantage a particular side possesses given a value scheme.
:type: input_color: Color
:type: val_scheme: PieceValues
:rtype: double
|
[
"Finds",
"the",
"advantage",
"a",
"particular",
"side",
"possesses",
"given",
"a",
"value",
"scheme",
"."
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L185-L200
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.advantage_as_result
|
def advantage_as_result(self, move, val_scheme):
"""
Calculates advantage after move is played
:type: move: Move
:type: val_scheme: PieceValues
:rtype: double
"""
test_board = cp(self)
test_board.update(move)
return test_board.material_advantage(move.color, val_scheme)
|
python
|
def advantage_as_result(self, move, val_scheme):
"""
Calculates advantage after move is played
:type: move: Move
:type: val_scheme: PieceValues
:rtype: double
"""
test_board = cp(self)
test_board.update(move)
return test_board.material_advantage(move.color, val_scheme)
|
[
"def",
"advantage_as_result",
"(",
"self",
",",
"move",
",",
"val_scheme",
")",
":",
"test_board",
"=",
"cp",
"(",
"self",
")",
"test_board",
".",
"update",
"(",
"move",
")",
"return",
"test_board",
".",
"material_advantage",
"(",
"move",
".",
"color",
",",
"val_scheme",
")"
] |
Calculates advantage after move is played
:type: move: Move
:type: val_scheme: PieceValues
:rtype: double
|
[
"Calculates",
"advantage",
"after",
"move",
"is",
"played"
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L202-L212
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.all_possible_moves
|
def all_possible_moves(self, input_color):
"""
Checks if all the possible moves has already been calculated
and is stored in `possible_moves` dictionary. If not, it is calculated
with `_calc_all_possible_moves`.
:type: input_color: Color
:rtype: list
"""
position_tuple = self.position_tuple
if position_tuple not in self.possible_moves:
self.possible_moves[position_tuple] = tuple(self._calc_all_possible_moves(input_color))
return self.possible_moves[position_tuple]
|
python
|
def all_possible_moves(self, input_color):
"""
Checks if all the possible moves has already been calculated
and is stored in `possible_moves` dictionary. If not, it is calculated
with `_calc_all_possible_moves`.
:type: input_color: Color
:rtype: list
"""
position_tuple = self.position_tuple
if position_tuple not in self.possible_moves:
self.possible_moves[position_tuple] = tuple(self._calc_all_possible_moves(input_color))
return self.possible_moves[position_tuple]
|
[
"def",
"all_possible_moves",
"(",
"self",
",",
"input_color",
")",
":",
"position_tuple",
"=",
"self",
".",
"position_tuple",
"if",
"position_tuple",
"not",
"in",
"self",
".",
"possible_moves",
":",
"self",
".",
"possible_moves",
"[",
"position_tuple",
"]",
"=",
"tuple",
"(",
"self",
".",
"_calc_all_possible_moves",
"(",
"input_color",
")",
")",
"return",
"self",
".",
"possible_moves",
"[",
"position_tuple",
"]"
] |
Checks if all the possible moves has already been calculated
and is stored in `possible_moves` dictionary. If not, it is calculated
with `_calc_all_possible_moves`.
:type: input_color: Color
:rtype: list
|
[
"Checks",
"if",
"all",
"the",
"possible",
"moves",
"has",
"already",
"been",
"calculated",
"and",
"is",
"stored",
"in",
"possible_moves",
"dictionary",
".",
"If",
"not",
"it",
"is",
"calculated",
"with",
"_calc_all_possible_moves",
".",
":",
"type",
":",
"input_color",
":",
"Color",
":",
"rtype",
":",
"list"
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L214-L227
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board._calc_all_possible_moves
|
def _calc_all_possible_moves(self, input_color):
"""
Returns list of all possible moves
:type: input_color: Color
:rtype: list
"""
for piece in self:
# Tests if square on the board is not empty
if piece is not None and piece.color == input_color:
for move in piece.possible_moves(self):
test = cp(self)
test_move = Move(end_loc=move.end_loc,
piece=test.piece_at_square(move.start_loc),
status=move.status,
start_loc=move.start_loc,
promoted_to_piece=move.promoted_to_piece)
test.update(test_move)
if self.king_loc_dict is None:
yield move
continue
my_king = test.piece_at_square(self.king_loc_dict[input_color])
if my_king is None or \
not isinstance(my_king, King) or \
my_king.color != input_color:
self.king_loc_dict[input_color] = test.find_king(input_color)
my_king = test.piece_at_square(self.king_loc_dict[input_color])
if not my_king.in_check(test):
yield move
|
python
|
def _calc_all_possible_moves(self, input_color):
"""
Returns list of all possible moves
:type: input_color: Color
:rtype: list
"""
for piece in self:
# Tests if square on the board is not empty
if piece is not None and piece.color == input_color:
for move in piece.possible_moves(self):
test = cp(self)
test_move = Move(end_loc=move.end_loc,
piece=test.piece_at_square(move.start_loc),
status=move.status,
start_loc=move.start_loc,
promoted_to_piece=move.promoted_to_piece)
test.update(test_move)
if self.king_loc_dict is None:
yield move
continue
my_king = test.piece_at_square(self.king_loc_dict[input_color])
if my_king is None or \
not isinstance(my_king, King) or \
my_king.color != input_color:
self.king_loc_dict[input_color] = test.find_king(input_color)
my_king = test.piece_at_square(self.king_loc_dict[input_color])
if not my_king.in_check(test):
yield move
|
[
"def",
"_calc_all_possible_moves",
"(",
"self",
",",
"input_color",
")",
":",
"for",
"piece",
"in",
"self",
":",
"# Tests if square on the board is not empty",
"if",
"piece",
"is",
"not",
"None",
"and",
"piece",
".",
"color",
"==",
"input_color",
":",
"for",
"move",
"in",
"piece",
".",
"possible_moves",
"(",
"self",
")",
":",
"test",
"=",
"cp",
"(",
"self",
")",
"test_move",
"=",
"Move",
"(",
"end_loc",
"=",
"move",
".",
"end_loc",
",",
"piece",
"=",
"test",
".",
"piece_at_square",
"(",
"move",
".",
"start_loc",
")",
",",
"status",
"=",
"move",
".",
"status",
",",
"start_loc",
"=",
"move",
".",
"start_loc",
",",
"promoted_to_piece",
"=",
"move",
".",
"promoted_to_piece",
")",
"test",
".",
"update",
"(",
"test_move",
")",
"if",
"self",
".",
"king_loc_dict",
"is",
"None",
":",
"yield",
"move",
"continue",
"my_king",
"=",
"test",
".",
"piece_at_square",
"(",
"self",
".",
"king_loc_dict",
"[",
"input_color",
"]",
")",
"if",
"my_king",
"is",
"None",
"or",
"not",
"isinstance",
"(",
"my_king",
",",
"King",
")",
"or",
"my_king",
".",
"color",
"!=",
"input_color",
":",
"self",
".",
"king_loc_dict",
"[",
"input_color",
"]",
"=",
"test",
".",
"find_king",
"(",
"input_color",
")",
"my_king",
"=",
"test",
".",
"piece_at_square",
"(",
"self",
".",
"king_loc_dict",
"[",
"input_color",
"]",
")",
"if",
"not",
"my_king",
".",
"in_check",
"(",
"test",
")",
":",
"yield",
"move"
] |
Returns list of all possible moves
:type: input_color: Color
:rtype: list
|
[
"Returns",
"list",
"of",
"all",
"possible",
"moves"
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L229-L264
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.runInParallel
|
def runInParallel(*fns):
"""
Runs multiple processes in parallel.
:type: fns: def
"""
proc = []
for fn in fns:
p = Process(target=fn)
p.start()
proc.append(p)
for p in proc:
p.join()
|
python
|
def runInParallel(*fns):
"""
Runs multiple processes in parallel.
:type: fns: def
"""
proc = []
for fn in fns:
p = Process(target=fn)
p.start()
proc.append(p)
for p in proc:
p.join()
|
[
"def",
"runInParallel",
"(",
"*",
"fns",
")",
":",
"proc",
"=",
"[",
"]",
"for",
"fn",
"in",
"fns",
":",
"p",
"=",
"Process",
"(",
"target",
"=",
"fn",
")",
"p",
".",
"start",
"(",
")",
"proc",
".",
"append",
"(",
"p",
")",
"for",
"p",
"in",
"proc",
":",
"p",
".",
"join",
"(",
")"
] |
Runs multiple processes in parallel.
:type: fns: def
|
[
"Runs",
"multiple",
"processes",
"in",
"parallel",
"."
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L266-L278
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.find_piece
|
def find_piece(self, piece):
"""
Finds Location of the first piece that matches piece.
If none is found, Exception is raised.
:type: piece: Piece
:rtype: Location
"""
for i, _ in enumerate(self.position):
for j, _ in enumerate(self.position):
loc = Location(i, j)
if not self.is_square_empty(loc) and \
self.piece_at_square(loc) == piece:
return loc
raise ValueError("{} \nPiece not found: {}".format(self, piece))
|
python
|
def find_piece(self, piece):
"""
Finds Location of the first piece that matches piece.
If none is found, Exception is raised.
:type: piece: Piece
:rtype: Location
"""
for i, _ in enumerate(self.position):
for j, _ in enumerate(self.position):
loc = Location(i, j)
if not self.is_square_empty(loc) and \
self.piece_at_square(loc) == piece:
return loc
raise ValueError("{} \nPiece not found: {}".format(self, piece))
|
[
"def",
"find_piece",
"(",
"self",
",",
"piece",
")",
":",
"for",
"i",
",",
"_",
"in",
"enumerate",
"(",
"self",
".",
"position",
")",
":",
"for",
"j",
",",
"_",
"in",
"enumerate",
"(",
"self",
".",
"position",
")",
":",
"loc",
"=",
"Location",
"(",
"i",
",",
"j",
")",
"if",
"not",
"self",
".",
"is_square_empty",
"(",
"loc",
")",
"and",
"self",
".",
"piece_at_square",
"(",
"loc",
")",
"==",
"piece",
":",
"return",
"loc",
"raise",
"ValueError",
"(",
"\"{} \\nPiece not found: {}\"",
".",
"format",
"(",
"self",
",",
"piece",
")",
")"
] |
Finds Location of the first piece that matches piece.
If none is found, Exception is raised.
:type: piece: Piece
:rtype: Location
|
[
"Finds",
"Location",
"of",
"the",
"first",
"piece",
"that",
"matches",
"piece",
".",
"If",
"none",
"is",
"found",
"Exception",
"is",
"raised",
"."
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L298-L314
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.get_piece
|
def get_piece(self, piece_type, input_color):
"""
Gets location of a piece on the board given the type and color.
:type: piece_type: Piece
:type: input_color: Color
:rtype: Location
"""
for loc in self:
piece = self.piece_at_square(loc)
if not self.is_square_empty(loc) and \
isinstance(piece, piece_type) and \
piece.color == input_color:
return loc
raise Exception("{} \nPiece not found: {}".format(self, piece_type))
|
python
|
def get_piece(self, piece_type, input_color):
"""
Gets location of a piece on the board given the type and color.
:type: piece_type: Piece
:type: input_color: Color
:rtype: Location
"""
for loc in self:
piece = self.piece_at_square(loc)
if not self.is_square_empty(loc) and \
isinstance(piece, piece_type) and \
piece.color == input_color:
return loc
raise Exception("{} \nPiece not found: {}".format(self, piece_type))
|
[
"def",
"get_piece",
"(",
"self",
",",
"piece_type",
",",
"input_color",
")",
":",
"for",
"loc",
"in",
"self",
":",
"piece",
"=",
"self",
".",
"piece_at_square",
"(",
"loc",
")",
"if",
"not",
"self",
".",
"is_square_empty",
"(",
"loc",
")",
"and",
"isinstance",
"(",
"piece",
",",
"piece_type",
")",
"and",
"piece",
".",
"color",
"==",
"input_color",
":",
"return",
"loc",
"raise",
"Exception",
"(",
"\"{} \\nPiece not found: {}\"",
".",
"format",
"(",
"self",
",",
"piece_type",
")",
")"
] |
Gets location of a piece on the board given the type and color.
:type: piece_type: Piece
:type: input_color: Color
:rtype: Location
|
[
"Gets",
"location",
"of",
"a",
"piece",
"on",
"the",
"board",
"given",
"the",
"type",
"and",
"color",
".",
":",
"type",
":",
"piece_type",
":",
"Piece",
":",
"type",
":",
"input_color",
":",
"Color",
":",
"rtype",
":",
"Location"
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L316-L332
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.place_piece_at_square
|
def place_piece_at_square(self, piece, location):
"""
Places piece at given get_location
:type: piece: Piece
:type: location: Location
"""
self.position[location.rank][location.file] = piece
piece.location = location
|
python
|
def place_piece_at_square(self, piece, location):
"""
Places piece at given get_location
:type: piece: Piece
:type: location: Location
"""
self.position[location.rank][location.file] = piece
piece.location = location
|
[
"def",
"place_piece_at_square",
"(",
"self",
",",
"piece",
",",
"location",
")",
":",
"self",
".",
"position",
"[",
"location",
".",
"rank",
"]",
"[",
"location",
".",
"file",
"]",
"=",
"piece",
"piece",
".",
"location",
"=",
"location"
] |
Places piece at given get_location
:type: piece: Piece
:type: location: Location
|
[
"Places",
"piece",
"at",
"given",
"get_location"
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L360-L368
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.move_piece
|
def move_piece(self, initial, final):
"""
Moves piece from one location to another
:type: initial: Location
:type: final: Location
"""
self.place_piece_at_square(self.piece_at_square(initial), final)
self.remove_piece_at_square(initial)
|
python
|
def move_piece(self, initial, final):
"""
Moves piece from one location to another
:type: initial: Location
:type: final: Location
"""
self.place_piece_at_square(self.piece_at_square(initial), final)
self.remove_piece_at_square(initial)
|
[
"def",
"move_piece",
"(",
"self",
",",
"initial",
",",
"final",
")",
":",
"self",
".",
"place_piece_at_square",
"(",
"self",
".",
"piece_at_square",
"(",
"initial",
")",
",",
"final",
")",
"self",
".",
"remove_piece_at_square",
"(",
"initial",
")"
] |
Moves piece from one location to another
:type: initial: Location
:type: final: Location
|
[
"Moves",
"piece",
"from",
"one",
"location",
"to",
"another"
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L370-L378
|
train
|
LordDarkula/chess_py
|
chess_py/core/board.py
|
Board.update
|
def update(self, move):
"""
Updates position by applying selected move
:type: move: Move
"""
if move is None:
raise TypeError("Move cannot be type None")
if self.king_loc_dict is not None and isinstance(move.piece, King):
self.king_loc_dict[move.color] = move.end_loc
# Invalidates en-passant
for square in self:
pawn = square
if isinstance(pawn, Pawn):
pawn.just_moved_two_steps = False
# Sets King and Rook has_moved property to True is piece has moved
if type(move.piece) is King or type(move.piece) is Rook:
move.piece.has_moved = True
elif move.status == notation_const.MOVEMENT and \
isinstance(move.piece, Pawn) and \
fabs(move.end_loc.rank - move.start_loc.rank) == 2:
move.piece.just_moved_two_steps = True
if move.status == notation_const.KING_SIDE_CASTLE:
self.move_piece(Location(move.end_loc.rank, 7), Location(move.end_loc.rank, 5))
self.piece_at_square(Location(move.end_loc.rank, 5)).has_moved = True
elif move.status == notation_const.QUEEN_SIDE_CASTLE:
self.move_piece(Location(move.end_loc.rank, 0), Location(move.end_loc.rank, 3))
self.piece_at_square(Location(move.end_loc.rank, 3)).has_moved = True
elif move.status == notation_const.EN_PASSANT:
self.remove_piece_at_square(Location(move.start_loc.rank, move.end_loc.file))
elif move.status == notation_const.PROMOTE or \
move.status == notation_const.CAPTURE_AND_PROMOTE:
try:
self.remove_piece_at_square(move.start_loc)
self.place_piece_at_square(move.promoted_to_piece(move.color, move.end_loc), move.end_loc)
except TypeError as e:
raise ValueError("Promoted to piece cannot be None in Move {}\n{}".format(repr(move), e))
return
self.move_piece(move.piece.location, move.end_loc)
|
python
|
def update(self, move):
"""
Updates position by applying selected move
:type: move: Move
"""
if move is None:
raise TypeError("Move cannot be type None")
if self.king_loc_dict is not None and isinstance(move.piece, King):
self.king_loc_dict[move.color] = move.end_loc
# Invalidates en-passant
for square in self:
pawn = square
if isinstance(pawn, Pawn):
pawn.just_moved_two_steps = False
# Sets King and Rook has_moved property to True is piece has moved
if type(move.piece) is King or type(move.piece) is Rook:
move.piece.has_moved = True
elif move.status == notation_const.MOVEMENT and \
isinstance(move.piece, Pawn) and \
fabs(move.end_loc.rank - move.start_loc.rank) == 2:
move.piece.just_moved_two_steps = True
if move.status == notation_const.KING_SIDE_CASTLE:
self.move_piece(Location(move.end_loc.rank, 7), Location(move.end_loc.rank, 5))
self.piece_at_square(Location(move.end_loc.rank, 5)).has_moved = True
elif move.status == notation_const.QUEEN_SIDE_CASTLE:
self.move_piece(Location(move.end_loc.rank, 0), Location(move.end_loc.rank, 3))
self.piece_at_square(Location(move.end_loc.rank, 3)).has_moved = True
elif move.status == notation_const.EN_PASSANT:
self.remove_piece_at_square(Location(move.start_loc.rank, move.end_loc.file))
elif move.status == notation_const.PROMOTE or \
move.status == notation_const.CAPTURE_AND_PROMOTE:
try:
self.remove_piece_at_square(move.start_loc)
self.place_piece_at_square(move.promoted_to_piece(move.color, move.end_loc), move.end_loc)
except TypeError as e:
raise ValueError("Promoted to piece cannot be None in Move {}\n{}".format(repr(move), e))
return
self.move_piece(move.piece.location, move.end_loc)
|
[
"def",
"update",
"(",
"self",
",",
"move",
")",
":",
"if",
"move",
"is",
"None",
":",
"raise",
"TypeError",
"(",
"\"Move cannot be type None\"",
")",
"if",
"self",
".",
"king_loc_dict",
"is",
"not",
"None",
"and",
"isinstance",
"(",
"move",
".",
"piece",
",",
"King",
")",
":",
"self",
".",
"king_loc_dict",
"[",
"move",
".",
"color",
"]",
"=",
"move",
".",
"end_loc",
"# Invalidates en-passant",
"for",
"square",
"in",
"self",
":",
"pawn",
"=",
"square",
"if",
"isinstance",
"(",
"pawn",
",",
"Pawn",
")",
":",
"pawn",
".",
"just_moved_two_steps",
"=",
"False",
"# Sets King and Rook has_moved property to True is piece has moved",
"if",
"type",
"(",
"move",
".",
"piece",
")",
"is",
"King",
"or",
"type",
"(",
"move",
".",
"piece",
")",
"is",
"Rook",
":",
"move",
".",
"piece",
".",
"has_moved",
"=",
"True",
"elif",
"move",
".",
"status",
"==",
"notation_const",
".",
"MOVEMENT",
"and",
"isinstance",
"(",
"move",
".",
"piece",
",",
"Pawn",
")",
"and",
"fabs",
"(",
"move",
".",
"end_loc",
".",
"rank",
"-",
"move",
".",
"start_loc",
".",
"rank",
")",
"==",
"2",
":",
"move",
".",
"piece",
".",
"just_moved_two_steps",
"=",
"True",
"if",
"move",
".",
"status",
"==",
"notation_const",
".",
"KING_SIDE_CASTLE",
":",
"self",
".",
"move_piece",
"(",
"Location",
"(",
"move",
".",
"end_loc",
".",
"rank",
",",
"7",
")",
",",
"Location",
"(",
"move",
".",
"end_loc",
".",
"rank",
",",
"5",
")",
")",
"self",
".",
"piece_at_square",
"(",
"Location",
"(",
"move",
".",
"end_loc",
".",
"rank",
",",
"5",
")",
")",
".",
"has_moved",
"=",
"True",
"elif",
"move",
".",
"status",
"==",
"notation_const",
".",
"QUEEN_SIDE_CASTLE",
":",
"self",
".",
"move_piece",
"(",
"Location",
"(",
"move",
".",
"end_loc",
".",
"rank",
",",
"0",
")",
",",
"Location",
"(",
"move",
".",
"end_loc",
".",
"rank",
",",
"3",
")",
")",
"self",
".",
"piece_at_square",
"(",
"Location",
"(",
"move",
".",
"end_loc",
".",
"rank",
",",
"3",
")",
")",
".",
"has_moved",
"=",
"True",
"elif",
"move",
".",
"status",
"==",
"notation_const",
".",
"EN_PASSANT",
":",
"self",
".",
"remove_piece_at_square",
"(",
"Location",
"(",
"move",
".",
"start_loc",
".",
"rank",
",",
"move",
".",
"end_loc",
".",
"file",
")",
")",
"elif",
"move",
".",
"status",
"==",
"notation_const",
".",
"PROMOTE",
"or",
"move",
".",
"status",
"==",
"notation_const",
".",
"CAPTURE_AND_PROMOTE",
":",
"try",
":",
"self",
".",
"remove_piece_at_square",
"(",
"move",
".",
"start_loc",
")",
"self",
".",
"place_piece_at_square",
"(",
"move",
".",
"promoted_to_piece",
"(",
"move",
".",
"color",
",",
"move",
".",
"end_loc",
")",
",",
"move",
".",
"end_loc",
")",
"except",
"TypeError",
"as",
"e",
":",
"raise",
"ValueError",
"(",
"\"Promoted to piece cannot be None in Move {}\\n{}\"",
".",
"format",
"(",
"repr",
"(",
"move",
")",
",",
"e",
")",
")",
"return",
"self",
".",
"move_piece",
"(",
"move",
".",
"piece",
".",
"location",
",",
"move",
".",
"end_loc",
")"
] |
Updates position by applying selected move
:type: move: Move
|
[
"Updates",
"position",
"by",
"applying",
"selected",
"move"
] |
14bebc2f8c49ae25c59375cc83d0b38d8ff7281d
|
https://github.com/LordDarkula/chess_py/blob/14bebc2f8c49ae25c59375cc83d0b38d8ff7281d/chess_py/core/board.py#L380-L427
|
train
|
cimm-kzn/CGRtools
|
CGRtools/algorithms/balance.py
|
Balance._balance
|
def _balance(self, ):
""" calc unbalanced charges and radicals for skin atoms
"""
meta = h.meta
for n in (skin_reagent.keys() | skin_product.keys()):
lost = skin_reagent[n]
cycle_lost = cycle(lost)
new = skin_product[n]
cycle_new = cycle(new)
atom = h._node[n]
dr = atom.p_radical - atom.radical
# radical balancing
if dr > 0: # radical added or increased.
for _, m in zip(range(dr), cycle_lost): # homolysis
s_atom = h._node[m]
s_atom.p_multiplicity = radical_unmap[s_atom.p_radical + 1]
meta.setdefault('rule #14. atom lost. common atom radical added or increased. '
'lost atom radical added', []).append((m, n))
for m in lost[dr:]:
meta.setdefault('rule #15. atom lost. common atom radical added or increased. '
'lost atom radical unchanged', []).append((m, n))
elif dr < 0: # radical removed or decreased.
if n in skin_product:
for m in lost:
meta.setdefault('rule #20. atom lost. common atom radical removed or decreased. '
'lost atom radical unchanged', []).append((m, n))
else:
for _, m in zip(range(-dr), cycle_lost): # radical elimination
s_atom = h._node[m]
s_atom.p_multiplicity = radical_unmap[s_atom.p_radical + 1]
meta.setdefault('rule #21. atom lost. common atom radical removed or decreased. '
'lost atom radical added', []).append((m, n))
for m in lost[-dr:]:
meta.setdefault('rule #20. atom lost. common atom radical removed or decreased. '
'lost atom radical unchanged', []).append((m, n))
else:
env = h.environment(n)
sv = atom.get_valence([(b.reagent, a.reagent) for b, a in env if b.order])
pv = atom.p_get_valence([(b.product, a.product) for b, a in env if b.p_order])
sh, ph = h.atom_total_h(n)
dv = pv - sv
dh = ph - sh
dc = atom.p_charge - atom.charge
if not (dv or dh or dc): # common atom unchanged. Substitution, Elimination
for m in skins:
meta.setdefault('rule #1. atom lost. common atom unchanged. '
'substitution, elimination, addition', []).append((m, n))
elif dv == dh == dc < 0: # explicit hydrogen removing
for m in skins:
h._node[m].p_charge = 1
meta.setdefault('rule #4. atom lost. common atom deprotonation', []).append((m, n))
else:
for m in skins:
meta.setdefault('rule #5. atom lost. common atom changed. '
'convert to reduction or oxidation', []).append((m, n))
pth = ph + sum(h.atom_total_h(x)[1] for x in skins)
if n in skin_product:
sth = sh + sum(h.atom_total_h(x)[0] for x in skin_product[n])
else:
sth = sh
dth = pth - sth
for n, skins in skin_product.items():
cycle_skins = cycle(skins)
atom = h._node[n]
dr = atom.p_radical - atom.radical
# radical balancing
if dr > 0: # radical added or increased.
if n in skin_reagent:
for m in skins:
meta.setdefault('rule #16. atom new. common atom radical added or increased. '
'new atom radical unchanged', []).append((m, n))
else:
for _, m in zip(range(dr), cycle_skins): # radical addition
s_atom = h._node[m]
s_atom.multiplicity = radical_unmap[s_atom.radical + 1]
meta.setdefault('rule #17. atom new. common atom radical added or increased. '
'new atom radical added', []).append((m, n))
for m in skins[dr:]:
meta.setdefault('rule #16. atom new. common atom radical added or increased. '
'new atom radical unchanged', []).append((m, n))
elif dr < 0: # radical removed or decreased.
for _, m in zip(range(-dr), cycle_skins): # recombination
s_atom = h._node[m]
s_atom.multiplicity = radical_unmap[s_atom.radical + 1]
meta.setdefault('rule #18. atom new. common atom radical removed or decreased. '
'new atom radical added', []).append((m, n))
for m in skins[-dr:]:
meta.setdefault('rule #19. atom new. common atom radical removed or decreased. '
'new atom radical unchanged', []).append((m, n))
else:
env = h.environment(n)
sv = atom.get_valence([(b.reagent, a.reagent) for b, a in env if b.order])
pv = atom.p_get_valence([(b.product, a.product) for b, a in env if b.p_order])
sh, ph = h.atom_total_h(n)
dv = pv - sv
dh = ph - sh
dc = atom.p_charge - atom.charge
if not (dv or dh or dc): # common atom unchanged. Substitution, Addition
for m in skins:
meta.setdefault('rule #2. atom new. common atom unchanged. '
'substitution, elimination, addition', []).append((m, n))
elif dv == dh == dc > 0: # explicit hydrogen addition
for m in skins:
h._node[m].charge = 1
h.meta.setdefault('rule #3. atom new. common atom protonation', []).append((m, n))
else:
for m in skins:
meta.setdefault('rule #6. atom new. common atom changed. '
'convert to reduction or oxidation', []).append((m, n))
sth = sh + sum(h.atom_total_h(x)[0] for x in skins)
if n in skin_reagent:
pth = ph + sum(h.atom_total_h(x)[1] for x in skin_reagent[n])
else:
pth = ph
dth = pth - sth
for n, sp in reverse_ext.items():
# charge neutralization
if dc > 0:
for _ in range(dc):
h.meta.setdefault('rule #7. charge neutralization. hydroxide radical added',
[]).append(h.add_atom(O(multiplicity=2), O(charge=-1)))
elif dc < 0:
for _ in range(-dc):
h.meta.setdefault('rule #8. charge neutralization. hydrogen radical added',
[]).append(h.add_atom(H(multiplicity=2), H(charge=1)))
# hydrogen balancing
if dth > 0:
red_e = 0
for m in sp['products']:
if h.nodes[m]['element'] == 'H': # set reduction H if explicit H count increased
h.nodes[m]['s_radical'] = 2
red_e += 1
h.meta.setdefault('rule #11. protonation. new explicit hydrogen radical added',
[]).append(m)
red = []
for _ in range(dth - red_e): # add reduction agents
m = h.add_atom(H(multiplicity=2), H())
red.append(m)
h.meta.setdefault('rule #10. protonation. hydrogen radical added', []).append(m)
red = iter(red)
dih = sub(*h.atom_implicit_h(n))
if dih < 0: # attach reduction H to central atom if implicit H atoms count increased
for _ in range(-dih):
m = next(red)
h.add_bond(m, n, None)
h.meta.setdefault('rule #12. protonation. new implicit hydrogen radical added',
[]).append(m)
for m in sp['reagents']: # attach reduction H if detached group implicit H count increased
dih = sub(*h.atom_implicit_h(m))
if dih < 0:
for _ in range(-dih):
o = next(red)
h.add_bond(o, m, None)
elif dth < 0:
oxo = []
for _ in range(-dth):
m = h.add_atom(O(multiplicity=2), O())
oxo.append(m)
h.meta.setdefault('rule #9. deprotonation. hydroxide radical added', []).append(m)
oxo = iter(oxo)
for m in sp['reagents']:
if h.nodes[m]['element'] == 'H':
o = next(oxo)
h.add_bond(o, m, None)
h.meta.setdefault('rule #13. hydrogen accepting by hydroxide radical added',
[]).append(m)
return h
|
python
|
def _balance(self, ):
""" calc unbalanced charges and radicals for skin atoms
"""
meta = h.meta
for n in (skin_reagent.keys() | skin_product.keys()):
lost = skin_reagent[n]
cycle_lost = cycle(lost)
new = skin_product[n]
cycle_new = cycle(new)
atom = h._node[n]
dr = atom.p_radical - atom.radical
# radical balancing
if dr > 0: # radical added or increased.
for _, m in zip(range(dr), cycle_lost): # homolysis
s_atom = h._node[m]
s_atom.p_multiplicity = radical_unmap[s_atom.p_radical + 1]
meta.setdefault('rule #14. atom lost. common atom radical added or increased. '
'lost atom radical added', []).append((m, n))
for m in lost[dr:]:
meta.setdefault('rule #15. atom lost. common atom radical added or increased. '
'lost atom radical unchanged', []).append((m, n))
elif dr < 0: # radical removed or decreased.
if n in skin_product:
for m in lost:
meta.setdefault('rule #20. atom lost. common atom radical removed or decreased. '
'lost atom radical unchanged', []).append((m, n))
else:
for _, m in zip(range(-dr), cycle_lost): # radical elimination
s_atom = h._node[m]
s_atom.p_multiplicity = radical_unmap[s_atom.p_radical + 1]
meta.setdefault('rule #21. atom lost. common atom radical removed or decreased. '
'lost atom radical added', []).append((m, n))
for m in lost[-dr:]:
meta.setdefault('rule #20. atom lost. common atom radical removed or decreased. '
'lost atom radical unchanged', []).append((m, n))
else:
env = h.environment(n)
sv = atom.get_valence([(b.reagent, a.reagent) for b, a in env if b.order])
pv = atom.p_get_valence([(b.product, a.product) for b, a in env if b.p_order])
sh, ph = h.atom_total_h(n)
dv = pv - sv
dh = ph - sh
dc = atom.p_charge - atom.charge
if not (dv or dh or dc): # common atom unchanged. Substitution, Elimination
for m in skins:
meta.setdefault('rule #1. atom lost. common atom unchanged. '
'substitution, elimination, addition', []).append((m, n))
elif dv == dh == dc < 0: # explicit hydrogen removing
for m in skins:
h._node[m].p_charge = 1
meta.setdefault('rule #4. atom lost. common atom deprotonation', []).append((m, n))
else:
for m in skins:
meta.setdefault('rule #5. atom lost. common atom changed. '
'convert to reduction or oxidation', []).append((m, n))
pth = ph + sum(h.atom_total_h(x)[1] for x in skins)
if n in skin_product:
sth = sh + sum(h.atom_total_h(x)[0] for x in skin_product[n])
else:
sth = sh
dth = pth - sth
for n, skins in skin_product.items():
cycle_skins = cycle(skins)
atom = h._node[n]
dr = atom.p_radical - atom.radical
# radical balancing
if dr > 0: # radical added or increased.
if n in skin_reagent:
for m in skins:
meta.setdefault('rule #16. atom new. common atom radical added or increased. '
'new atom radical unchanged', []).append((m, n))
else:
for _, m in zip(range(dr), cycle_skins): # radical addition
s_atom = h._node[m]
s_atom.multiplicity = radical_unmap[s_atom.radical + 1]
meta.setdefault('rule #17. atom new. common atom radical added or increased. '
'new atom radical added', []).append((m, n))
for m in skins[dr:]:
meta.setdefault('rule #16. atom new. common atom radical added or increased. '
'new atom radical unchanged', []).append((m, n))
elif dr < 0: # radical removed or decreased.
for _, m in zip(range(-dr), cycle_skins): # recombination
s_atom = h._node[m]
s_atom.multiplicity = radical_unmap[s_atom.radical + 1]
meta.setdefault('rule #18. atom new. common atom radical removed or decreased. '
'new atom radical added', []).append((m, n))
for m in skins[-dr:]:
meta.setdefault('rule #19. atom new. common atom radical removed or decreased. '
'new atom radical unchanged', []).append((m, n))
else:
env = h.environment(n)
sv = atom.get_valence([(b.reagent, a.reagent) for b, a in env if b.order])
pv = atom.p_get_valence([(b.product, a.product) for b, a in env if b.p_order])
sh, ph = h.atom_total_h(n)
dv = pv - sv
dh = ph - sh
dc = atom.p_charge - atom.charge
if not (dv or dh or dc): # common atom unchanged. Substitution, Addition
for m in skins:
meta.setdefault('rule #2. atom new. common atom unchanged. '
'substitution, elimination, addition', []).append((m, n))
elif dv == dh == dc > 0: # explicit hydrogen addition
for m in skins:
h._node[m].charge = 1
h.meta.setdefault('rule #3. atom new. common atom protonation', []).append((m, n))
else:
for m in skins:
meta.setdefault('rule #6. atom new. common atom changed. '
'convert to reduction or oxidation', []).append((m, n))
sth = sh + sum(h.atom_total_h(x)[0] for x in skins)
if n in skin_reagent:
pth = ph + sum(h.atom_total_h(x)[1] for x in skin_reagent[n])
else:
pth = ph
dth = pth - sth
for n, sp in reverse_ext.items():
# charge neutralization
if dc > 0:
for _ in range(dc):
h.meta.setdefault('rule #7. charge neutralization. hydroxide radical added',
[]).append(h.add_atom(O(multiplicity=2), O(charge=-1)))
elif dc < 0:
for _ in range(-dc):
h.meta.setdefault('rule #8. charge neutralization. hydrogen radical added',
[]).append(h.add_atom(H(multiplicity=2), H(charge=1)))
# hydrogen balancing
if dth > 0:
red_e = 0
for m in sp['products']:
if h.nodes[m]['element'] == 'H': # set reduction H if explicit H count increased
h.nodes[m]['s_radical'] = 2
red_e += 1
h.meta.setdefault('rule #11. protonation. new explicit hydrogen radical added',
[]).append(m)
red = []
for _ in range(dth - red_e): # add reduction agents
m = h.add_atom(H(multiplicity=2), H())
red.append(m)
h.meta.setdefault('rule #10. protonation. hydrogen radical added', []).append(m)
red = iter(red)
dih = sub(*h.atom_implicit_h(n))
if dih < 0: # attach reduction H to central atom if implicit H atoms count increased
for _ in range(-dih):
m = next(red)
h.add_bond(m, n, None)
h.meta.setdefault('rule #12. protonation. new implicit hydrogen radical added',
[]).append(m)
for m in sp['reagents']: # attach reduction H if detached group implicit H count increased
dih = sub(*h.atom_implicit_h(m))
if dih < 0:
for _ in range(-dih):
o = next(red)
h.add_bond(o, m, None)
elif dth < 0:
oxo = []
for _ in range(-dth):
m = h.add_atom(O(multiplicity=2), O())
oxo.append(m)
h.meta.setdefault('rule #9. deprotonation. hydroxide radical added', []).append(m)
oxo = iter(oxo)
for m in sp['reagents']:
if h.nodes[m]['element'] == 'H':
o = next(oxo)
h.add_bond(o, m, None)
h.meta.setdefault('rule #13. hydrogen accepting by hydroxide radical added',
[]).append(m)
return h
|
[
"def",
"_balance",
"(",
"self",
",",
")",
":",
"meta",
"=",
"h",
".",
"meta",
"for",
"n",
"in",
"(",
"skin_reagent",
".",
"keys",
"(",
")",
"|",
"skin_product",
".",
"keys",
"(",
")",
")",
":",
"lost",
"=",
"skin_reagent",
"[",
"n",
"]",
"cycle_lost",
"=",
"cycle",
"(",
"lost",
")",
"new",
"=",
"skin_product",
"[",
"n",
"]",
"cycle_new",
"=",
"cycle",
"(",
"new",
")",
"atom",
"=",
"h",
".",
"_node",
"[",
"n",
"]",
"dr",
"=",
"atom",
".",
"p_radical",
"-",
"atom",
".",
"radical",
"# radical balancing",
"if",
"dr",
">",
"0",
":",
"# radical added or increased.",
"for",
"_",
",",
"m",
"in",
"zip",
"(",
"range",
"(",
"dr",
")",
",",
"cycle_lost",
")",
":",
"# homolysis",
"s_atom",
"=",
"h",
".",
"_node",
"[",
"m",
"]",
"s_atom",
".",
"p_multiplicity",
"=",
"radical_unmap",
"[",
"s_atom",
".",
"p_radical",
"+",
"1",
"]",
"meta",
".",
"setdefault",
"(",
"'rule #14. atom lost. common atom radical added or increased. '",
"'lost atom radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"for",
"m",
"in",
"lost",
"[",
"dr",
":",
"]",
":",
"meta",
".",
"setdefault",
"(",
"'rule #15. atom lost. common atom radical added or increased. '",
"'lost atom radical unchanged'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"elif",
"dr",
"<",
"0",
":",
"# radical removed or decreased.",
"if",
"n",
"in",
"skin_product",
":",
"for",
"m",
"in",
"lost",
":",
"meta",
".",
"setdefault",
"(",
"'rule #20. atom lost. common atom radical removed or decreased. '",
"'lost atom radical unchanged'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"else",
":",
"for",
"_",
",",
"m",
"in",
"zip",
"(",
"range",
"(",
"-",
"dr",
")",
",",
"cycle_lost",
")",
":",
"# radical elimination",
"s_atom",
"=",
"h",
".",
"_node",
"[",
"m",
"]",
"s_atom",
".",
"p_multiplicity",
"=",
"radical_unmap",
"[",
"s_atom",
".",
"p_radical",
"+",
"1",
"]",
"meta",
".",
"setdefault",
"(",
"'rule #21. atom lost. common atom radical removed or decreased. '",
"'lost atom radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"for",
"m",
"in",
"lost",
"[",
"-",
"dr",
":",
"]",
":",
"meta",
".",
"setdefault",
"(",
"'rule #20. atom lost. common atom radical removed or decreased. '",
"'lost atom radical unchanged'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"else",
":",
"env",
"=",
"h",
".",
"environment",
"(",
"n",
")",
"sv",
"=",
"atom",
".",
"get_valence",
"(",
"[",
"(",
"b",
".",
"reagent",
",",
"a",
".",
"reagent",
")",
"for",
"b",
",",
"a",
"in",
"env",
"if",
"b",
".",
"order",
"]",
")",
"pv",
"=",
"atom",
".",
"p_get_valence",
"(",
"[",
"(",
"b",
".",
"product",
",",
"a",
".",
"product",
")",
"for",
"b",
",",
"a",
"in",
"env",
"if",
"b",
".",
"p_order",
"]",
")",
"sh",
",",
"ph",
"=",
"h",
".",
"atom_total_h",
"(",
"n",
")",
"dv",
"=",
"pv",
"-",
"sv",
"dh",
"=",
"ph",
"-",
"sh",
"dc",
"=",
"atom",
".",
"p_charge",
"-",
"atom",
".",
"charge",
"if",
"not",
"(",
"dv",
"or",
"dh",
"or",
"dc",
")",
":",
"# common atom unchanged. Substitution, Elimination",
"for",
"m",
"in",
"skins",
":",
"meta",
".",
"setdefault",
"(",
"'rule #1. atom lost. common atom unchanged. '",
"'substitution, elimination, addition'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"elif",
"dv",
"==",
"dh",
"==",
"dc",
"<",
"0",
":",
"# explicit hydrogen removing",
"for",
"m",
"in",
"skins",
":",
"h",
".",
"_node",
"[",
"m",
"]",
".",
"p_charge",
"=",
"1",
"meta",
".",
"setdefault",
"(",
"'rule #4. atom lost. common atom deprotonation'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"else",
":",
"for",
"m",
"in",
"skins",
":",
"meta",
".",
"setdefault",
"(",
"'rule #5. atom lost. common atom changed. '",
"'convert to reduction or oxidation'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"pth",
"=",
"ph",
"+",
"sum",
"(",
"h",
".",
"atom_total_h",
"(",
"x",
")",
"[",
"1",
"]",
"for",
"x",
"in",
"skins",
")",
"if",
"n",
"in",
"skin_product",
":",
"sth",
"=",
"sh",
"+",
"sum",
"(",
"h",
".",
"atom_total_h",
"(",
"x",
")",
"[",
"0",
"]",
"for",
"x",
"in",
"skin_product",
"[",
"n",
"]",
")",
"else",
":",
"sth",
"=",
"sh",
"dth",
"=",
"pth",
"-",
"sth",
"for",
"n",
",",
"skins",
"in",
"skin_product",
".",
"items",
"(",
")",
":",
"cycle_skins",
"=",
"cycle",
"(",
"skins",
")",
"atom",
"=",
"h",
".",
"_node",
"[",
"n",
"]",
"dr",
"=",
"atom",
".",
"p_radical",
"-",
"atom",
".",
"radical",
"# radical balancing",
"if",
"dr",
">",
"0",
":",
"# radical added or increased.",
"if",
"n",
"in",
"skin_reagent",
":",
"for",
"m",
"in",
"skins",
":",
"meta",
".",
"setdefault",
"(",
"'rule #16. atom new. common atom radical added or increased. '",
"'new atom radical unchanged'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"else",
":",
"for",
"_",
",",
"m",
"in",
"zip",
"(",
"range",
"(",
"dr",
")",
",",
"cycle_skins",
")",
":",
"# radical addition",
"s_atom",
"=",
"h",
".",
"_node",
"[",
"m",
"]",
"s_atom",
".",
"multiplicity",
"=",
"radical_unmap",
"[",
"s_atom",
".",
"radical",
"+",
"1",
"]",
"meta",
".",
"setdefault",
"(",
"'rule #17. atom new. common atom radical added or increased. '",
"'new atom radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"for",
"m",
"in",
"skins",
"[",
"dr",
":",
"]",
":",
"meta",
".",
"setdefault",
"(",
"'rule #16. atom new. common atom radical added or increased. '",
"'new atom radical unchanged'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"elif",
"dr",
"<",
"0",
":",
"# radical removed or decreased.",
"for",
"_",
",",
"m",
"in",
"zip",
"(",
"range",
"(",
"-",
"dr",
")",
",",
"cycle_skins",
")",
":",
"# recombination",
"s_atom",
"=",
"h",
".",
"_node",
"[",
"m",
"]",
"s_atom",
".",
"multiplicity",
"=",
"radical_unmap",
"[",
"s_atom",
".",
"radical",
"+",
"1",
"]",
"meta",
".",
"setdefault",
"(",
"'rule #18. atom new. common atom radical removed or decreased. '",
"'new atom radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"for",
"m",
"in",
"skins",
"[",
"-",
"dr",
":",
"]",
":",
"meta",
".",
"setdefault",
"(",
"'rule #19. atom new. common atom radical removed or decreased. '",
"'new atom radical unchanged'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"else",
":",
"env",
"=",
"h",
".",
"environment",
"(",
"n",
")",
"sv",
"=",
"atom",
".",
"get_valence",
"(",
"[",
"(",
"b",
".",
"reagent",
",",
"a",
".",
"reagent",
")",
"for",
"b",
",",
"a",
"in",
"env",
"if",
"b",
".",
"order",
"]",
")",
"pv",
"=",
"atom",
".",
"p_get_valence",
"(",
"[",
"(",
"b",
".",
"product",
",",
"a",
".",
"product",
")",
"for",
"b",
",",
"a",
"in",
"env",
"if",
"b",
".",
"p_order",
"]",
")",
"sh",
",",
"ph",
"=",
"h",
".",
"atom_total_h",
"(",
"n",
")",
"dv",
"=",
"pv",
"-",
"sv",
"dh",
"=",
"ph",
"-",
"sh",
"dc",
"=",
"atom",
".",
"p_charge",
"-",
"atom",
".",
"charge",
"if",
"not",
"(",
"dv",
"or",
"dh",
"or",
"dc",
")",
":",
"# common atom unchanged. Substitution, Addition",
"for",
"m",
"in",
"skins",
":",
"meta",
".",
"setdefault",
"(",
"'rule #2. atom new. common atom unchanged. '",
"'substitution, elimination, addition'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"elif",
"dv",
"==",
"dh",
"==",
"dc",
">",
"0",
":",
"# explicit hydrogen addition",
"for",
"m",
"in",
"skins",
":",
"h",
".",
"_node",
"[",
"m",
"]",
".",
"charge",
"=",
"1",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #3. atom new. common atom protonation'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"else",
":",
"for",
"m",
"in",
"skins",
":",
"meta",
".",
"setdefault",
"(",
"'rule #6. atom new. common atom changed. '",
"'convert to reduction or oxidation'",
",",
"[",
"]",
")",
".",
"append",
"(",
"(",
"m",
",",
"n",
")",
")",
"sth",
"=",
"sh",
"+",
"sum",
"(",
"h",
".",
"atom_total_h",
"(",
"x",
")",
"[",
"0",
"]",
"for",
"x",
"in",
"skins",
")",
"if",
"n",
"in",
"skin_reagent",
":",
"pth",
"=",
"ph",
"+",
"sum",
"(",
"h",
".",
"atom_total_h",
"(",
"x",
")",
"[",
"1",
"]",
"for",
"x",
"in",
"skin_reagent",
"[",
"n",
"]",
")",
"else",
":",
"pth",
"=",
"ph",
"dth",
"=",
"pth",
"-",
"sth",
"for",
"n",
",",
"sp",
"in",
"reverse_ext",
".",
"items",
"(",
")",
":",
"# charge neutralization",
"if",
"dc",
">",
"0",
":",
"for",
"_",
"in",
"range",
"(",
"dc",
")",
":",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #7. charge neutralization. hydroxide radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"h",
".",
"add_atom",
"(",
"O",
"(",
"multiplicity",
"=",
"2",
")",
",",
"O",
"(",
"charge",
"=",
"-",
"1",
")",
")",
")",
"elif",
"dc",
"<",
"0",
":",
"for",
"_",
"in",
"range",
"(",
"-",
"dc",
")",
":",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #8. charge neutralization. hydrogen radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"h",
".",
"add_atom",
"(",
"H",
"(",
"multiplicity",
"=",
"2",
")",
",",
"H",
"(",
"charge",
"=",
"1",
")",
")",
")",
"# hydrogen balancing",
"if",
"dth",
">",
"0",
":",
"red_e",
"=",
"0",
"for",
"m",
"in",
"sp",
"[",
"'products'",
"]",
":",
"if",
"h",
".",
"nodes",
"[",
"m",
"]",
"[",
"'element'",
"]",
"==",
"'H'",
":",
"# set reduction H if explicit H count increased",
"h",
".",
"nodes",
"[",
"m",
"]",
"[",
"'s_radical'",
"]",
"=",
"2",
"red_e",
"+=",
"1",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #11. protonation. new explicit hydrogen radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"m",
")",
"red",
"=",
"[",
"]",
"for",
"_",
"in",
"range",
"(",
"dth",
"-",
"red_e",
")",
":",
"# add reduction agents",
"m",
"=",
"h",
".",
"add_atom",
"(",
"H",
"(",
"multiplicity",
"=",
"2",
")",
",",
"H",
"(",
")",
")",
"red",
".",
"append",
"(",
"m",
")",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #10. protonation. hydrogen radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"m",
")",
"red",
"=",
"iter",
"(",
"red",
")",
"dih",
"=",
"sub",
"(",
"*",
"h",
".",
"atom_implicit_h",
"(",
"n",
")",
")",
"if",
"dih",
"<",
"0",
":",
"# attach reduction H to central atom if implicit H atoms count increased",
"for",
"_",
"in",
"range",
"(",
"-",
"dih",
")",
":",
"m",
"=",
"next",
"(",
"red",
")",
"h",
".",
"add_bond",
"(",
"m",
",",
"n",
",",
"None",
")",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #12. protonation. new implicit hydrogen radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"m",
")",
"for",
"m",
"in",
"sp",
"[",
"'reagents'",
"]",
":",
"# attach reduction H if detached group implicit H count increased",
"dih",
"=",
"sub",
"(",
"*",
"h",
".",
"atom_implicit_h",
"(",
"m",
")",
")",
"if",
"dih",
"<",
"0",
":",
"for",
"_",
"in",
"range",
"(",
"-",
"dih",
")",
":",
"o",
"=",
"next",
"(",
"red",
")",
"h",
".",
"add_bond",
"(",
"o",
",",
"m",
",",
"None",
")",
"elif",
"dth",
"<",
"0",
":",
"oxo",
"=",
"[",
"]",
"for",
"_",
"in",
"range",
"(",
"-",
"dth",
")",
":",
"m",
"=",
"h",
".",
"add_atom",
"(",
"O",
"(",
"multiplicity",
"=",
"2",
")",
",",
"O",
"(",
")",
")",
"oxo",
".",
"append",
"(",
"m",
")",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #9. deprotonation. hydroxide radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"m",
")",
"oxo",
"=",
"iter",
"(",
"oxo",
")",
"for",
"m",
"in",
"sp",
"[",
"'reagents'",
"]",
":",
"if",
"h",
".",
"nodes",
"[",
"m",
"]",
"[",
"'element'",
"]",
"==",
"'H'",
":",
"o",
"=",
"next",
"(",
"oxo",
")",
"h",
".",
"add_bond",
"(",
"o",
",",
"m",
",",
"None",
")",
"h",
".",
"meta",
".",
"setdefault",
"(",
"'rule #13. hydrogen accepting by hydroxide radical added'",
",",
"[",
"]",
")",
".",
"append",
"(",
"m",
")",
"return",
"h"
] |
calc unbalanced charges and radicals for skin atoms
|
[
"calc",
"unbalanced",
"charges",
"and",
"radicals",
"for",
"skin",
"atoms"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/algorithms/balance.py#L25-L206
|
train
|
cimm-kzn/CGRtools
|
CGRtools/algorithms/balance.py
|
Balance.clone_subgraphs
|
def clone_subgraphs(self, g):
if not isinstance(g, CGRContainer):
raise InvalidData('only CGRContainer acceptable')
r_group = []
x_group = {}
r_group_clones = []
newcomponents = []
''' search bond breaks and creations
'''
components, lost_bonds, term_atoms = self.__split_graph(g)
lost_map = {x: y for x, y in lost_bonds}
''' extract subgraphs and sort by group type (R or X)
'''
x_terminals = set(lost_map.values())
r_terminals = set(lost_map)
for i in components:
x_terminal_atom = x_terminals.intersection(i)
if x_terminal_atom:
x_group[x_terminal_atom.pop()] = i
continue
r_terminal_atom = r_terminals.intersection(i)
if r_terminal_atom:
r_group.append([r_terminal_atom, i])
continue
newcomponents.append(i)
''' search similar R groups and patch.
'''
tmp = g
for i in newcomponents:
for k, j in r_group:
gm = GraphMatcher(j, i, node_match=self.__node_match_products,
edge_match=self.__edge_match_products)
''' search for similar R-groups started from bond breaks.
'''
mapping = next((x for x in gm.subgraph_isomorphisms_iter() if k.issubset(x) and
all(x[y] in term_atoms for y in k)), None)
if mapping:
r_group_clones.append([k, mapping])
tmp = compose(tmp, self.__remap_group(j, tmp, mapping)[0])
break
''' add lose X groups to R groups
'''
for i, j in r_group_clones:
for k in i:
remappedgroup, mapping = self.__remap_group(x_group[lost_map[k]], tmp, {})
tmp = CGRcore.union(tmp, remappedgroup)
tmp.add_edge(j[k], mapping[lost_map[k]], s_bond=1, sp_bond=(1, None))
if r_group_clones:
tmp.meta.update(g.meta)
return tmp
return tmp.copy()
|
python
|
def clone_subgraphs(self, g):
if not isinstance(g, CGRContainer):
raise InvalidData('only CGRContainer acceptable')
r_group = []
x_group = {}
r_group_clones = []
newcomponents = []
''' search bond breaks and creations
'''
components, lost_bonds, term_atoms = self.__split_graph(g)
lost_map = {x: y for x, y in lost_bonds}
''' extract subgraphs and sort by group type (R or X)
'''
x_terminals = set(lost_map.values())
r_terminals = set(lost_map)
for i in components:
x_terminal_atom = x_terminals.intersection(i)
if x_terminal_atom:
x_group[x_terminal_atom.pop()] = i
continue
r_terminal_atom = r_terminals.intersection(i)
if r_terminal_atom:
r_group.append([r_terminal_atom, i])
continue
newcomponents.append(i)
''' search similar R groups and patch.
'''
tmp = g
for i in newcomponents:
for k, j in r_group:
gm = GraphMatcher(j, i, node_match=self.__node_match_products,
edge_match=self.__edge_match_products)
''' search for similar R-groups started from bond breaks.
'''
mapping = next((x for x in gm.subgraph_isomorphisms_iter() if k.issubset(x) and
all(x[y] in term_atoms for y in k)), None)
if mapping:
r_group_clones.append([k, mapping])
tmp = compose(tmp, self.__remap_group(j, tmp, mapping)[0])
break
''' add lose X groups to R groups
'''
for i, j in r_group_clones:
for k in i:
remappedgroup, mapping = self.__remap_group(x_group[lost_map[k]], tmp, {})
tmp = CGRcore.union(tmp, remappedgroup)
tmp.add_edge(j[k], mapping[lost_map[k]], s_bond=1, sp_bond=(1, None))
if r_group_clones:
tmp.meta.update(g.meta)
return tmp
return tmp.copy()
|
[
"def",
"clone_subgraphs",
"(",
"self",
",",
"g",
")",
":",
"if",
"not",
"isinstance",
"(",
"g",
",",
"CGRContainer",
")",
":",
"raise",
"InvalidData",
"(",
"'only CGRContainer acceptable'",
")",
"r_group",
"=",
"[",
"]",
"x_group",
"=",
"{",
"}",
"r_group_clones",
"=",
"[",
"]",
"newcomponents",
"=",
"[",
"]",
"components",
",",
"lost_bonds",
",",
"term_atoms",
"=",
"self",
".",
"__split_graph",
"(",
"g",
")",
"lost_map",
"=",
"{",
"x",
":",
"y",
"for",
"x",
",",
"y",
"in",
"lost_bonds",
"}",
"''' extract subgraphs and sort by group type (R or X)\n '''",
"x_terminals",
"=",
"set",
"(",
"lost_map",
".",
"values",
"(",
")",
")",
"r_terminals",
"=",
"set",
"(",
"lost_map",
")",
"for",
"i",
"in",
"components",
":",
"x_terminal_atom",
"=",
"x_terminals",
".",
"intersection",
"(",
"i",
")",
"if",
"x_terminal_atom",
":",
"x_group",
"[",
"x_terminal_atom",
".",
"pop",
"(",
")",
"]",
"=",
"i",
"continue",
"r_terminal_atom",
"=",
"r_terminals",
".",
"intersection",
"(",
"i",
")",
"if",
"r_terminal_atom",
":",
"r_group",
".",
"append",
"(",
"[",
"r_terminal_atom",
",",
"i",
"]",
")",
"continue",
"newcomponents",
".",
"append",
"(",
"i",
")",
"''' search similar R groups and patch.\n '''",
"tmp",
"=",
"g",
"for",
"i",
"in",
"newcomponents",
":",
"for",
"k",
",",
"j",
"in",
"r_group",
":",
"gm",
"=",
"GraphMatcher",
"(",
"j",
",",
"i",
",",
"node_match",
"=",
"self",
".",
"__node_match_products",
",",
"edge_match",
"=",
"self",
".",
"__edge_match_products",
")",
"''' search for similar R-groups started from bond breaks.\n '''",
"mapping",
"=",
"next",
"(",
"(",
"x",
"for",
"x",
"in",
"gm",
".",
"subgraph_isomorphisms_iter",
"(",
")",
"if",
"k",
".",
"issubset",
"(",
"x",
")",
"and",
"all",
"(",
"x",
"[",
"y",
"]",
"in",
"term_atoms",
"for",
"y",
"in",
"k",
")",
")",
",",
"None",
")",
"if",
"mapping",
":",
"r_group_clones",
".",
"append",
"(",
"[",
"k",
",",
"mapping",
"]",
")",
"tmp",
"=",
"compose",
"(",
"tmp",
",",
"self",
".",
"__remap_group",
"(",
"j",
",",
"tmp",
",",
"mapping",
")",
"[",
"0",
"]",
")",
"break",
"''' add lose X groups to R groups\n '''",
"for",
"i",
",",
"j",
"in",
"r_group_clones",
":",
"for",
"k",
"in",
"i",
":",
"remappedgroup",
",",
"mapping",
"=",
"self",
".",
"__remap_group",
"(",
"x_group",
"[",
"lost_map",
"[",
"k",
"]",
"]",
",",
"tmp",
",",
"{",
"}",
")",
"tmp",
"=",
"CGRcore",
".",
"union",
"(",
"tmp",
",",
"remappedgroup",
")",
"tmp",
".",
"add_edge",
"(",
"j",
"[",
"k",
"]",
",",
"mapping",
"[",
"lost_map",
"[",
"k",
"]",
"]",
",",
"s_bond",
"=",
"1",
",",
"sp_bond",
"=",
"(",
"1",
",",
"None",
")",
")",
"if",
"r_group_clones",
":",
"tmp",
".",
"meta",
".",
"update",
"(",
"g",
".",
"meta",
")",
"return",
"tmp",
"return",
"tmp",
".",
"copy",
"(",
")"
] |
search bond breaks and creations
|
[
"search",
"bond",
"breaks",
"and",
"creations"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/algorithms/balance.py#L208-L266
|
train
|
cimm-kzn/CGRtools
|
CGRtools/algorithms/balance.py
|
Balance.__get_substitution_paths
|
def __get_substitution_paths(g):
"""
get atoms paths from detached atom to attached
:param g: CGRContainer
:return: tuple of atoms numbers
"""
for n, nbrdict in g.adjacency():
for m, l in combinations(nbrdict, 2):
nms = nbrdict[m]['sp_bond']
nls = nbrdict[l]['sp_bond']
if nms == (1, None) and nls == (None, 1):
yield m, n, l
elif nms == (None, 1) and nls == (1, None):
yield l, n, m
|
python
|
def __get_substitution_paths(g):
"""
get atoms paths from detached atom to attached
:param g: CGRContainer
:return: tuple of atoms numbers
"""
for n, nbrdict in g.adjacency():
for m, l in combinations(nbrdict, 2):
nms = nbrdict[m]['sp_bond']
nls = nbrdict[l]['sp_bond']
if nms == (1, None) and nls == (None, 1):
yield m, n, l
elif nms == (None, 1) and nls == (1, None):
yield l, n, m
|
[
"def",
"__get_substitution_paths",
"(",
"g",
")",
":",
"for",
"n",
",",
"nbrdict",
"in",
"g",
".",
"adjacency",
"(",
")",
":",
"for",
"m",
",",
"l",
"in",
"combinations",
"(",
"nbrdict",
",",
"2",
")",
":",
"nms",
"=",
"nbrdict",
"[",
"m",
"]",
"[",
"'sp_bond'",
"]",
"nls",
"=",
"nbrdict",
"[",
"l",
"]",
"[",
"'sp_bond'",
"]",
"if",
"nms",
"==",
"(",
"1",
",",
"None",
")",
"and",
"nls",
"==",
"(",
"None",
",",
"1",
")",
":",
"yield",
"m",
",",
"n",
",",
"l",
"elif",
"nms",
"==",
"(",
"None",
",",
"1",
")",
"and",
"nls",
"==",
"(",
"1",
",",
"None",
")",
":",
"yield",
"l",
",",
"n",
",",
"m"
] |
get atoms paths from detached atom to attached
:param g: CGRContainer
:return: tuple of atoms numbers
|
[
"get",
"atoms",
"paths",
"from",
"detached",
"atom",
"to",
"attached"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/algorithms/balance.py#L292-L306
|
train
|
camptocamp/marabunta
|
marabunta/database.py
|
MigrationTable.versions
|
def versions(self):
""" Read versions from the table
The versions are kept in cache for the next reads.
"""
if self._versions is None:
with self.database.cursor_autocommit() as cursor:
query = """
SELECT number,
date_start,
date_done,
log,
addons
FROM {}
""".format(self.table_name)
cursor.execute(query)
rows = cursor.fetchall()
versions = []
for row in rows:
row = list(row)
# convert 'addons' to json
row[4] = json.loads(row[4]) if row[4] else []
versions.append(
self.VersionRecord(*row)
)
self._versions = versions
return self._versions
|
python
|
def versions(self):
""" Read versions from the table
The versions are kept in cache for the next reads.
"""
if self._versions is None:
with self.database.cursor_autocommit() as cursor:
query = """
SELECT number,
date_start,
date_done,
log,
addons
FROM {}
""".format(self.table_name)
cursor.execute(query)
rows = cursor.fetchall()
versions = []
for row in rows:
row = list(row)
# convert 'addons' to json
row[4] = json.loads(row[4]) if row[4] else []
versions.append(
self.VersionRecord(*row)
)
self._versions = versions
return self._versions
|
[
"def",
"versions",
"(",
"self",
")",
":",
"if",
"self",
".",
"_versions",
"is",
"None",
":",
"with",
"self",
".",
"database",
".",
"cursor_autocommit",
"(",
")",
"as",
"cursor",
":",
"query",
"=",
"\"\"\"\n SELECT number,\n date_start,\n date_done,\n log,\n addons\n FROM {}\n \"\"\"",
".",
"format",
"(",
"self",
".",
"table_name",
")",
"cursor",
".",
"execute",
"(",
"query",
")",
"rows",
"=",
"cursor",
".",
"fetchall",
"(",
")",
"versions",
"=",
"[",
"]",
"for",
"row",
"in",
"rows",
":",
"row",
"=",
"list",
"(",
"row",
")",
"# convert 'addons' to json",
"row",
"[",
"4",
"]",
"=",
"json",
".",
"loads",
"(",
"row",
"[",
"4",
"]",
")",
"if",
"row",
"[",
"4",
"]",
"else",
"[",
"]",
"versions",
".",
"append",
"(",
"self",
".",
"VersionRecord",
"(",
"*",
"row",
")",
")",
"self",
".",
"_versions",
"=",
"versions",
"return",
"self",
".",
"_versions"
] |
Read versions from the table
The versions are kept in cache for the next reads.
|
[
"Read",
"versions",
"from",
"the",
"table"
] |
ec3a7a725c7426d6ed642e0a80119b37880eb91e
|
https://github.com/camptocamp/marabunta/blob/ec3a7a725c7426d6ed642e0a80119b37880eb91e/marabunta/database.py#L77-L103
|
train
|
zetaops/zengine
|
zengine/views/menu.py
|
Menu.simple_crud
|
def simple_crud():
"""
Prepares menu entries for auto-generated model CRUD views.
This is simple version of :attr:`get_crud_menus()` without
Category support and permission control.
Just for development purposes.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
for mdl in model_registry.get_base_models():
results['other'].append({"text": mdl.Meta.verbose_name_plural,
"wf": 'crud',
"model": mdl.__name__,
"kategori": settings.DEFAULT_OBJECT_CATEGORY_NAME})
return results
|
python
|
def simple_crud():
"""
Prepares menu entries for auto-generated model CRUD views.
This is simple version of :attr:`get_crud_menus()` without
Category support and permission control.
Just for development purposes.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
for mdl in model_registry.get_base_models():
results['other'].append({"text": mdl.Meta.verbose_name_plural,
"wf": 'crud',
"model": mdl.__name__,
"kategori": settings.DEFAULT_OBJECT_CATEGORY_NAME})
return results
|
[
"def",
"simple_crud",
"(",
")",
":",
"results",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"mdl",
"in",
"model_registry",
".",
"get_base_models",
"(",
")",
":",
"results",
"[",
"'other'",
"]",
".",
"append",
"(",
"{",
"\"text\"",
":",
"mdl",
".",
"Meta",
".",
"verbose_name_plural",
",",
"\"wf\"",
":",
"'crud'",
",",
"\"model\"",
":",
"mdl",
".",
"__name__",
",",
"\"kategori\"",
":",
"settings",
".",
"DEFAULT_OBJECT_CATEGORY_NAME",
"}",
")",
"return",
"results"
] |
Prepares menu entries for auto-generated model CRUD views.
This is simple version of :attr:`get_crud_menus()` without
Category support and permission control.
Just for development purposes.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
|
[
"Prepares",
"menu",
"entries",
"for",
"auto",
"-",
"generated",
"model",
"CRUD",
"views",
".",
"This",
"is",
"simple",
"version",
"of",
":",
"attr",
":",
"get_crud_menus",
"()",
"without",
"Category",
"support",
"and",
"permission",
"control",
".",
"Just",
"for",
"development",
"purposes",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/menu.py#L43-L60
|
train
|
zetaops/zengine
|
zengine/views/menu.py
|
Menu.get_crud_menus
|
def get_crud_menus(self):
"""
Generates menu entries according to
:attr:`zengine.settings.OBJECT_MENU` and permissions
of current user.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
for object_type in settings.OBJECT_MENU:
for model_data in settings.OBJECT_MENU[object_type]:
if self.current.has_permission(model_data.get('wf', model_data['name'])):
self._add_crud(model_data, object_type, results)
return results
|
python
|
def get_crud_menus(self):
"""
Generates menu entries according to
:attr:`zengine.settings.OBJECT_MENU` and permissions
of current user.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
for object_type in settings.OBJECT_MENU:
for model_data in settings.OBJECT_MENU[object_type]:
if self.current.has_permission(model_data.get('wf', model_data['name'])):
self._add_crud(model_data, object_type, results)
return results
|
[
"def",
"get_crud_menus",
"(",
"self",
")",
":",
"results",
"=",
"defaultdict",
"(",
"list",
")",
"for",
"object_type",
"in",
"settings",
".",
"OBJECT_MENU",
":",
"for",
"model_data",
"in",
"settings",
".",
"OBJECT_MENU",
"[",
"object_type",
"]",
":",
"if",
"self",
".",
"current",
".",
"has_permission",
"(",
"model_data",
".",
"get",
"(",
"'wf'",
",",
"model_data",
"[",
"'name'",
"]",
")",
")",
":",
"self",
".",
"_add_crud",
"(",
"model_data",
",",
"object_type",
",",
"results",
")",
"return",
"results"
] |
Generates menu entries according to
:attr:`zengine.settings.OBJECT_MENU` and permissions
of current user.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
|
[
"Generates",
"menu",
"entries",
"according",
"to",
":",
"attr",
":",
"zengine",
".",
"settings",
".",
"OBJECT_MENU",
"and",
"permissions",
"of",
"current",
"user",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/menu.py#L62-L76
|
train
|
zetaops/zengine
|
zengine/views/menu.py
|
Menu._add_crud
|
def _add_crud(self, model_data, object_type, results):
"""
Creates a menu entry for given model data.
Updates results in place.
Args:
model_data: Model data.
object_type: Relation name.
results: Results dict.
"""
model = model_registry.get_model(model_data['name'])
field_name = model_data.get('field')
verbose_name = model_data.get('verbose_name', model.Meta.verbose_name_plural)
category = model_data.get('category', settings.DEFAULT_OBJECT_CATEGORY_NAME)
wf_dict = {"text": verbose_name,
"wf": model_data.get('wf', "crud"),
"model": model_data['name'],
"kategori": category}
if field_name:
wf_dict['param'] = field_name
results[object_type].append(wf_dict)
self._add_to_quick_menu(wf_dict['model'], wf_dict)
|
python
|
def _add_crud(self, model_data, object_type, results):
"""
Creates a menu entry for given model data.
Updates results in place.
Args:
model_data: Model data.
object_type: Relation name.
results: Results dict.
"""
model = model_registry.get_model(model_data['name'])
field_name = model_data.get('field')
verbose_name = model_data.get('verbose_name', model.Meta.verbose_name_plural)
category = model_data.get('category', settings.DEFAULT_OBJECT_CATEGORY_NAME)
wf_dict = {"text": verbose_name,
"wf": model_data.get('wf', "crud"),
"model": model_data['name'],
"kategori": category}
if field_name:
wf_dict['param'] = field_name
results[object_type].append(wf_dict)
self._add_to_quick_menu(wf_dict['model'], wf_dict)
|
[
"def",
"_add_crud",
"(",
"self",
",",
"model_data",
",",
"object_type",
",",
"results",
")",
":",
"model",
"=",
"model_registry",
".",
"get_model",
"(",
"model_data",
"[",
"'name'",
"]",
")",
"field_name",
"=",
"model_data",
".",
"get",
"(",
"'field'",
")",
"verbose_name",
"=",
"model_data",
".",
"get",
"(",
"'verbose_name'",
",",
"model",
".",
"Meta",
".",
"verbose_name_plural",
")",
"category",
"=",
"model_data",
".",
"get",
"(",
"'category'",
",",
"settings",
".",
"DEFAULT_OBJECT_CATEGORY_NAME",
")",
"wf_dict",
"=",
"{",
"\"text\"",
":",
"verbose_name",
",",
"\"wf\"",
":",
"model_data",
".",
"get",
"(",
"'wf'",
",",
"\"crud\"",
")",
",",
"\"model\"",
":",
"model_data",
"[",
"'name'",
"]",
",",
"\"kategori\"",
":",
"category",
"}",
"if",
"field_name",
":",
"wf_dict",
"[",
"'param'",
"]",
"=",
"field_name",
"results",
"[",
"object_type",
"]",
".",
"append",
"(",
"wf_dict",
")",
"self",
".",
"_add_to_quick_menu",
"(",
"wf_dict",
"[",
"'model'",
"]",
",",
"wf_dict",
")"
] |
Creates a menu entry for given model data.
Updates results in place.
Args:
model_data: Model data.
object_type: Relation name.
results: Results dict.
|
[
"Creates",
"a",
"menu",
"entry",
"for",
"given",
"model",
"data",
".",
"Updates",
"results",
"in",
"place",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/menu.py#L78-L99
|
train
|
zetaops/zengine
|
zengine/views/menu.py
|
Menu._add_to_quick_menu
|
def _add_to_quick_menu(self, key, wf):
"""
Appends menu entries to dashboard quickmenu according
to :attr:`zengine.settings.QUICK_MENU`
Args:
key: workflow name
wf: workflow menu entry
"""
if key in settings.QUICK_MENU:
self.output['quick_menu'].append(wf)
|
python
|
def _add_to_quick_menu(self, key, wf):
"""
Appends menu entries to dashboard quickmenu according
to :attr:`zengine.settings.QUICK_MENU`
Args:
key: workflow name
wf: workflow menu entry
"""
if key in settings.QUICK_MENU:
self.output['quick_menu'].append(wf)
|
[
"def",
"_add_to_quick_menu",
"(",
"self",
",",
"key",
",",
"wf",
")",
":",
"if",
"key",
"in",
"settings",
".",
"QUICK_MENU",
":",
"self",
".",
"output",
"[",
"'quick_menu'",
"]",
".",
"append",
"(",
"wf",
")"
] |
Appends menu entries to dashboard quickmenu according
to :attr:`zengine.settings.QUICK_MENU`
Args:
key: workflow name
wf: workflow menu entry
|
[
"Appends",
"menu",
"entries",
"to",
"dashboard",
"quickmenu",
"according",
"to",
":",
"attr",
":",
"zengine",
".",
"settings",
".",
"QUICK_MENU"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/menu.py#L101-L111
|
train
|
zetaops/zengine
|
zengine/views/menu.py
|
Menu._get_workflow_menus
|
def _get_workflow_menus(self):
"""
Creates menu entries for custom workflows.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
from zengine.lib.cache import WFSpecNames
for name, title, category in WFSpecNames().get_or_set():
if self.current.has_permission(name) and category != 'hidden':
wf_dict = {
"text": title,
"wf": name,
"kategori": category,
"param": "id"
}
results['other'].append(wf_dict)
self._add_to_quick_menu(name, wf_dict)
return results
|
python
|
def _get_workflow_menus(self):
"""
Creates menu entries for custom workflows.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
"""
results = defaultdict(list)
from zengine.lib.cache import WFSpecNames
for name, title, category in WFSpecNames().get_or_set():
if self.current.has_permission(name) and category != 'hidden':
wf_dict = {
"text": title,
"wf": name,
"kategori": category,
"param": "id"
}
results['other'].append(wf_dict)
self._add_to_quick_menu(name, wf_dict)
return results
|
[
"def",
"_get_workflow_menus",
"(",
"self",
")",
":",
"results",
"=",
"defaultdict",
"(",
"list",
")",
"from",
"zengine",
".",
"lib",
".",
"cache",
"import",
"WFSpecNames",
"for",
"name",
",",
"title",
",",
"category",
"in",
"WFSpecNames",
"(",
")",
".",
"get_or_set",
"(",
")",
":",
"if",
"self",
".",
"current",
".",
"has_permission",
"(",
"name",
")",
"and",
"category",
"!=",
"'hidden'",
":",
"wf_dict",
"=",
"{",
"\"text\"",
":",
"title",
",",
"\"wf\"",
":",
"name",
",",
"\"kategori\"",
":",
"category",
",",
"\"param\"",
":",
"\"id\"",
"}",
"results",
"[",
"'other'",
"]",
".",
"append",
"(",
"wf_dict",
")",
"self",
".",
"_add_to_quick_menu",
"(",
"name",
",",
"wf_dict",
")",
"return",
"results"
] |
Creates menu entries for custom workflows.
Returns:
Dict of list of dicts (``{'':[{}],}``). Menu entries.
|
[
"Creates",
"menu",
"entries",
"for",
"custom",
"workflows",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/menu.py#L113-L132
|
train
|
zetaops/zengine
|
zengine/middlewares.py
|
CORS.process_response
|
def process_response(self, request, response, resource):
"""
Do response processing
"""
origin = request.get_header('Origin')
if not settings.DEBUG:
if origin in settings.ALLOWED_ORIGINS or not origin:
response.set_header('Access-Control-Allow-Origin', origin)
else:
log.debug("CORS ERROR: %s not allowed, allowed hosts: %s" % (origin,
settings.ALLOWED_ORIGINS))
raise falcon.HTTPForbidden("Denied", "Origin not in ALLOWED_ORIGINS: %s" % origin)
# response.status = falcon.HTTP_403
else:
response.set_header('Access-Control-Allow-Origin', origin or '*')
response.set_header('Access-Control-Allow-Credentials', "true")
response.set_header('Access-Control-Allow-Headers', 'Content-Type')
# This could be overridden in the resource level
response.set_header('Access-Control-Allow-Methods', 'OPTIONS')
|
python
|
def process_response(self, request, response, resource):
"""
Do response processing
"""
origin = request.get_header('Origin')
if not settings.DEBUG:
if origin in settings.ALLOWED_ORIGINS or not origin:
response.set_header('Access-Control-Allow-Origin', origin)
else:
log.debug("CORS ERROR: %s not allowed, allowed hosts: %s" % (origin,
settings.ALLOWED_ORIGINS))
raise falcon.HTTPForbidden("Denied", "Origin not in ALLOWED_ORIGINS: %s" % origin)
# response.status = falcon.HTTP_403
else:
response.set_header('Access-Control-Allow-Origin', origin or '*')
response.set_header('Access-Control-Allow-Credentials', "true")
response.set_header('Access-Control-Allow-Headers', 'Content-Type')
# This could be overridden in the resource level
response.set_header('Access-Control-Allow-Methods', 'OPTIONS')
|
[
"def",
"process_response",
"(",
"self",
",",
"request",
",",
"response",
",",
"resource",
")",
":",
"origin",
"=",
"request",
".",
"get_header",
"(",
"'Origin'",
")",
"if",
"not",
"settings",
".",
"DEBUG",
":",
"if",
"origin",
"in",
"settings",
".",
"ALLOWED_ORIGINS",
"or",
"not",
"origin",
":",
"response",
".",
"set_header",
"(",
"'Access-Control-Allow-Origin'",
",",
"origin",
")",
"else",
":",
"log",
".",
"debug",
"(",
"\"CORS ERROR: %s not allowed, allowed hosts: %s\"",
"%",
"(",
"origin",
",",
"settings",
".",
"ALLOWED_ORIGINS",
")",
")",
"raise",
"falcon",
".",
"HTTPForbidden",
"(",
"\"Denied\"",
",",
"\"Origin not in ALLOWED_ORIGINS: %s\"",
"%",
"origin",
")",
"# response.status = falcon.HTTP_403",
"else",
":",
"response",
".",
"set_header",
"(",
"'Access-Control-Allow-Origin'",
",",
"origin",
"or",
"'*'",
")",
"response",
".",
"set_header",
"(",
"'Access-Control-Allow-Credentials'",
",",
"\"true\"",
")",
"response",
".",
"set_header",
"(",
"'Access-Control-Allow-Headers'",
",",
"'Content-Type'",
")",
"# This could be overridden in the resource level",
"response",
".",
"set_header",
"(",
"'Access-Control-Allow-Methods'",
",",
"'OPTIONS'",
")"
] |
Do response processing
|
[
"Do",
"response",
"processing"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/middlewares.py#L26-L45
|
train
|
zetaops/zengine
|
zengine/middlewares.py
|
RequireJSON.process_request
|
def process_request(self, req, resp):
"""
Do response processing
"""
if not req.client_accepts_json:
raise falcon.HTTPNotAcceptable(
'This API only supports responses encoded as JSON.',
href='http://docs.examples.com/api/json')
if req.method in ('POST', 'PUT'):
if req.content_length != 0 and \
'application/json' not in req.content_type and \
'text/plain' not in req.content_type:
raise falcon.HTTPUnsupportedMediaType(
'This API only supports requests encoded as JSON.',
href='http://docs.examples.com/api/json')
|
python
|
def process_request(self, req, resp):
"""
Do response processing
"""
if not req.client_accepts_json:
raise falcon.HTTPNotAcceptable(
'This API only supports responses encoded as JSON.',
href='http://docs.examples.com/api/json')
if req.method in ('POST', 'PUT'):
if req.content_length != 0 and \
'application/json' not in req.content_type and \
'text/plain' not in req.content_type:
raise falcon.HTTPUnsupportedMediaType(
'This API only supports requests encoded as JSON.',
href='http://docs.examples.com/api/json')
|
[
"def",
"process_request",
"(",
"self",
",",
"req",
",",
"resp",
")",
":",
"if",
"not",
"req",
".",
"client_accepts_json",
":",
"raise",
"falcon",
".",
"HTTPNotAcceptable",
"(",
"'This API only supports responses encoded as JSON.'",
",",
"href",
"=",
"'http://docs.examples.com/api/json'",
")",
"if",
"req",
".",
"method",
"in",
"(",
"'POST'",
",",
"'PUT'",
")",
":",
"if",
"req",
".",
"content_length",
"!=",
"0",
"and",
"'application/json'",
"not",
"in",
"req",
".",
"content_type",
"and",
"'text/plain'",
"not",
"in",
"req",
".",
"content_type",
":",
"raise",
"falcon",
".",
"HTTPUnsupportedMediaType",
"(",
"'This API only supports requests encoded as JSON.'",
",",
"href",
"=",
"'http://docs.examples.com/api/json'",
")"
] |
Do response processing
|
[
"Do",
"response",
"processing"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/middlewares.py#L52-L66
|
train
|
zetaops/zengine
|
zengine/middlewares.py
|
JSONTranslator.process_request
|
def process_request(self, req, resp):
"""
Do response processing
"""
# req.stream corresponds to the WSGI wsgi.input environ variable,
# and allows you to read bytes from the request body.
#
# See also: PEP 3333
if req.content_length in (None, 0):
# Nothing to do
req.context['data'] = req.params.copy()
req.context['result'] = {}
return
else:
req.context['result'] = {}
body = req.stream.read()
if not body:
raise falcon.HTTPBadRequest('Empty request body',
'A valid JSON document is required.')
try:
json_data = body.decode('utf-8')
req.context['data'] = json.loads(json_data)
try:
log.info("REQUEST DATA: %s" % json_data)
except:
log.exception("ERR: REQUEST DATA CANT BE LOGGED ")
except (ValueError, UnicodeDecodeError):
raise falcon.HTTPError(falcon.HTTP_753,
'Malformed JSON',
'Could not decode the request body. The '
'JSON was incorrect or not encoded as '
'UTF-8.')
|
python
|
def process_request(self, req, resp):
"""
Do response processing
"""
# req.stream corresponds to the WSGI wsgi.input environ variable,
# and allows you to read bytes from the request body.
#
# See also: PEP 3333
if req.content_length in (None, 0):
# Nothing to do
req.context['data'] = req.params.copy()
req.context['result'] = {}
return
else:
req.context['result'] = {}
body = req.stream.read()
if not body:
raise falcon.HTTPBadRequest('Empty request body',
'A valid JSON document is required.')
try:
json_data = body.decode('utf-8')
req.context['data'] = json.loads(json_data)
try:
log.info("REQUEST DATA: %s" % json_data)
except:
log.exception("ERR: REQUEST DATA CANT BE LOGGED ")
except (ValueError, UnicodeDecodeError):
raise falcon.HTTPError(falcon.HTTP_753,
'Malformed JSON',
'Could not decode the request body. The '
'JSON was incorrect or not encoded as '
'UTF-8.')
|
[
"def",
"process_request",
"(",
"self",
",",
"req",
",",
"resp",
")",
":",
"# req.stream corresponds to the WSGI wsgi.input environ variable,",
"# and allows you to read bytes from the request body.",
"#",
"# See also: PEP 3333",
"if",
"req",
".",
"content_length",
"in",
"(",
"None",
",",
"0",
")",
":",
"# Nothing to do",
"req",
".",
"context",
"[",
"'data'",
"]",
"=",
"req",
".",
"params",
".",
"copy",
"(",
")",
"req",
".",
"context",
"[",
"'result'",
"]",
"=",
"{",
"}",
"return",
"else",
":",
"req",
".",
"context",
"[",
"'result'",
"]",
"=",
"{",
"}",
"body",
"=",
"req",
".",
"stream",
".",
"read",
"(",
")",
"if",
"not",
"body",
":",
"raise",
"falcon",
".",
"HTTPBadRequest",
"(",
"'Empty request body'",
",",
"'A valid JSON document is required.'",
")",
"try",
":",
"json_data",
"=",
"body",
".",
"decode",
"(",
"'utf-8'",
")",
"req",
".",
"context",
"[",
"'data'",
"]",
"=",
"json",
".",
"loads",
"(",
"json_data",
")",
"try",
":",
"log",
".",
"info",
"(",
"\"REQUEST DATA: %s\"",
"%",
"json_data",
")",
"except",
":",
"log",
".",
"exception",
"(",
"\"ERR: REQUEST DATA CANT BE LOGGED \"",
")",
"except",
"(",
"ValueError",
",",
"UnicodeDecodeError",
")",
":",
"raise",
"falcon",
".",
"HTTPError",
"(",
"falcon",
".",
"HTTP_753",
",",
"'Malformed JSON'",
",",
"'Could not decode the request body. The '",
"'JSON was incorrect or not encoded as '",
"'UTF-8.'",
")"
] |
Do response processing
|
[
"Do",
"response",
"processing"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/middlewares.py#L73-L106
|
train
|
zetaops/zengine
|
zengine/middlewares.py
|
JSONTranslator.process_response
|
def process_response(self, req, resp, resource):
"""
Serializes ``req.context['result']`` to resp.body as JSON.
If :attr:`~zengine.settings.DEBUG` is True,
``sys._debug_db_queries`` (set by pyoko) added to response.
"""
if 'result' not in req.context:
return
req.context['result']['is_login'] = 'user_id' in req.env['session']
if settings.DEBUG:
req.context['result']['_debug_queries'] = sys._debug_db_queries
sys._debug_db_queries = []
if resp.body is None and req.context['result']:
resp.body = json.dumps(req.context['result'])
try:
log.debug("RESPONSE: %s" % resp.body)
except:
log.exception("ERR: RESPONSE CANT BE LOGGED ")
|
python
|
def process_response(self, req, resp, resource):
"""
Serializes ``req.context['result']`` to resp.body as JSON.
If :attr:`~zengine.settings.DEBUG` is True,
``sys._debug_db_queries`` (set by pyoko) added to response.
"""
if 'result' not in req.context:
return
req.context['result']['is_login'] = 'user_id' in req.env['session']
if settings.DEBUG:
req.context['result']['_debug_queries'] = sys._debug_db_queries
sys._debug_db_queries = []
if resp.body is None and req.context['result']:
resp.body = json.dumps(req.context['result'])
try:
log.debug("RESPONSE: %s" % resp.body)
except:
log.exception("ERR: RESPONSE CANT BE LOGGED ")
|
[
"def",
"process_response",
"(",
"self",
",",
"req",
",",
"resp",
",",
"resource",
")",
":",
"if",
"'result'",
"not",
"in",
"req",
".",
"context",
":",
"return",
"req",
".",
"context",
"[",
"'result'",
"]",
"[",
"'is_login'",
"]",
"=",
"'user_id'",
"in",
"req",
".",
"env",
"[",
"'session'",
"]",
"if",
"settings",
".",
"DEBUG",
":",
"req",
".",
"context",
"[",
"'result'",
"]",
"[",
"'_debug_queries'",
"]",
"=",
"sys",
".",
"_debug_db_queries",
"sys",
".",
"_debug_db_queries",
"=",
"[",
"]",
"if",
"resp",
".",
"body",
"is",
"None",
"and",
"req",
".",
"context",
"[",
"'result'",
"]",
":",
"resp",
".",
"body",
"=",
"json",
".",
"dumps",
"(",
"req",
".",
"context",
"[",
"'result'",
"]",
")",
"try",
":",
"log",
".",
"debug",
"(",
"\"RESPONSE: %s\"",
"%",
"resp",
".",
"body",
")",
"except",
":",
"log",
".",
"exception",
"(",
"\"ERR: RESPONSE CANT BE LOGGED \"",
")"
] |
Serializes ``req.context['result']`` to resp.body as JSON.
If :attr:`~zengine.settings.DEBUG` is True,
``sys._debug_db_queries`` (set by pyoko) added to response.
|
[
"Serializes",
"req",
".",
"context",
"[",
"result",
"]",
"to",
"resp",
".",
"body",
"as",
"JSON",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/middlewares.py#L108-L128
|
train
|
zetaops/zengine
|
zengine/tornado_server/ws_to_queue.py
|
QueueManager.connect
|
def connect(self):
"""
Creates connection to RabbitMQ server
"""
if self.connecting:
log.info('PikaClient: Already connecting to RabbitMQ')
return
log.info('PikaClient: Connecting to RabbitMQ')
self.connecting = True
self.connection = TornadoConnection(NON_BLOCKING_MQ_PARAMS,
stop_ioloop_on_close=False,
custom_ioloop=self.io_loop,
on_open_callback=self.on_connected)
|
python
|
def connect(self):
"""
Creates connection to RabbitMQ server
"""
if self.connecting:
log.info('PikaClient: Already connecting to RabbitMQ')
return
log.info('PikaClient: Connecting to RabbitMQ')
self.connecting = True
self.connection = TornadoConnection(NON_BLOCKING_MQ_PARAMS,
stop_ioloop_on_close=False,
custom_ioloop=self.io_loop,
on_open_callback=self.on_connected)
|
[
"def",
"connect",
"(",
"self",
")",
":",
"if",
"self",
".",
"connecting",
":",
"log",
".",
"info",
"(",
"'PikaClient: Already connecting to RabbitMQ'",
")",
"return",
"log",
".",
"info",
"(",
"'PikaClient: Connecting to RabbitMQ'",
")",
"self",
".",
"connecting",
"=",
"True",
"self",
".",
"connection",
"=",
"TornadoConnection",
"(",
"NON_BLOCKING_MQ_PARAMS",
",",
"stop_ioloop_on_close",
"=",
"False",
",",
"custom_ioloop",
"=",
"self",
".",
"io_loop",
",",
"on_open_callback",
"=",
"self",
".",
"on_connected",
")"
] |
Creates connection to RabbitMQ server
|
[
"Creates",
"connection",
"to",
"RabbitMQ",
"server"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/tornado_server/ws_to_queue.py#L73-L87
|
train
|
zetaops/zengine
|
zengine/tornado_server/ws_to_queue.py
|
QueueManager.on_connected
|
def on_connected(self, connection):
"""
AMQP connection callback.
Creates input channel.
Args:
connection: AMQP connection
"""
log.info('PikaClient: connected to RabbitMQ')
self.connected = True
self.in_channel = self.connection.channel(self.on_channel_open)
|
python
|
def on_connected(self, connection):
"""
AMQP connection callback.
Creates input channel.
Args:
connection: AMQP connection
"""
log.info('PikaClient: connected to RabbitMQ')
self.connected = True
self.in_channel = self.connection.channel(self.on_channel_open)
|
[
"def",
"on_connected",
"(",
"self",
",",
"connection",
")",
":",
"log",
".",
"info",
"(",
"'PikaClient: connected to RabbitMQ'",
")",
"self",
".",
"connected",
"=",
"True",
"self",
".",
"in_channel",
"=",
"self",
".",
"connection",
".",
"channel",
"(",
"self",
".",
"on_channel_open",
")"
] |
AMQP connection callback.
Creates input channel.
Args:
connection: AMQP connection
|
[
"AMQP",
"connection",
"callback",
".",
"Creates",
"input",
"channel",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/tornado_server/ws_to_queue.py#L89-L99
|
train
|
zetaops/zengine
|
zengine/tornado_server/ws_to_queue.py
|
QueueManager.on_channel_open
|
def on_channel_open(self, channel):
"""
Input channel creation callback
Queue declaration done here
Args:
channel: input channel
"""
self.in_channel.exchange_declare(exchange='input_exc', type='topic', durable=True)
channel.queue_declare(callback=self.on_input_queue_declare, queue=self.INPUT_QUEUE_NAME)
|
python
|
def on_channel_open(self, channel):
"""
Input channel creation callback
Queue declaration done here
Args:
channel: input channel
"""
self.in_channel.exchange_declare(exchange='input_exc', type='topic', durable=True)
channel.queue_declare(callback=self.on_input_queue_declare, queue=self.INPUT_QUEUE_NAME)
|
[
"def",
"on_channel_open",
"(",
"self",
",",
"channel",
")",
":",
"self",
".",
"in_channel",
".",
"exchange_declare",
"(",
"exchange",
"=",
"'input_exc'",
",",
"type",
"=",
"'topic'",
",",
"durable",
"=",
"True",
")",
"channel",
".",
"queue_declare",
"(",
"callback",
"=",
"self",
".",
"on_input_queue_declare",
",",
"queue",
"=",
"self",
".",
"INPUT_QUEUE_NAME",
")"
] |
Input channel creation callback
Queue declaration done here
Args:
channel: input channel
|
[
"Input",
"channel",
"creation",
"callback",
"Queue",
"declaration",
"done",
"here"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/tornado_server/ws_to_queue.py#L101-L110
|
train
|
zetaops/zengine
|
zengine/tornado_server/ws_to_queue.py
|
QueueManager.on_input_queue_declare
|
def on_input_queue_declare(self, queue):
"""
Input queue declaration callback.
Input Queue/Exchange binding done here
Args:
queue: input queue
"""
self.in_channel.queue_bind(callback=None,
exchange='input_exc',
queue=self.INPUT_QUEUE_NAME,
routing_key="#")
|
python
|
def on_input_queue_declare(self, queue):
"""
Input queue declaration callback.
Input Queue/Exchange binding done here
Args:
queue: input queue
"""
self.in_channel.queue_bind(callback=None,
exchange='input_exc',
queue=self.INPUT_QUEUE_NAME,
routing_key="#")
|
[
"def",
"on_input_queue_declare",
"(",
"self",
",",
"queue",
")",
":",
"self",
".",
"in_channel",
".",
"queue_bind",
"(",
"callback",
"=",
"None",
",",
"exchange",
"=",
"'input_exc'",
",",
"queue",
"=",
"self",
".",
"INPUT_QUEUE_NAME",
",",
"routing_key",
"=",
"\"#\"",
")"
] |
Input queue declaration callback.
Input Queue/Exchange binding done here
Args:
queue: input queue
|
[
"Input",
"queue",
"declaration",
"callback",
".",
"Input",
"Queue",
"/",
"Exchange",
"binding",
"done",
"here"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/tornado_server/ws_to_queue.py#L112-L123
|
train
|
erik/alexandra
|
alexandra/wsgi.py
|
WsgiApp.wsgi_app
|
def wsgi_app(self, request):
"""Incoming request handler.
:param request: Werkzeug request object
"""
try:
if request.method != 'POST':
abort(400)
try:
# Python 2.7 compatibility
data = request.data
if isinstance(data, str):
body = json.loads(data)
else:
body = json.loads(data.decode('utf-8'))
except ValueError:
abort(400)
if self.validate:
valid_cert = util.validate_request_certificate(
request.headers, request.data)
valid_ts = util.validate_request_timestamp(body)
if not valid_cert or not valid_ts:
log.error('failed to validate request')
abort(403)
resp_obj = self.alexa.dispatch_request(body)
return Response(response=json.dumps(resp_obj, indent=4),
status=200,
mimetype='application/json')
except HTTPException as exc:
log.exception('Failed to handle request')
return exc
|
python
|
def wsgi_app(self, request):
"""Incoming request handler.
:param request: Werkzeug request object
"""
try:
if request.method != 'POST':
abort(400)
try:
# Python 2.7 compatibility
data = request.data
if isinstance(data, str):
body = json.loads(data)
else:
body = json.loads(data.decode('utf-8'))
except ValueError:
abort(400)
if self.validate:
valid_cert = util.validate_request_certificate(
request.headers, request.data)
valid_ts = util.validate_request_timestamp(body)
if not valid_cert or not valid_ts:
log.error('failed to validate request')
abort(403)
resp_obj = self.alexa.dispatch_request(body)
return Response(response=json.dumps(resp_obj, indent=4),
status=200,
mimetype='application/json')
except HTTPException as exc:
log.exception('Failed to handle request')
return exc
|
[
"def",
"wsgi_app",
"(",
"self",
",",
"request",
")",
":",
"try",
":",
"if",
"request",
".",
"method",
"!=",
"'POST'",
":",
"abort",
"(",
"400",
")",
"try",
":",
"# Python 2.7 compatibility",
"data",
"=",
"request",
".",
"data",
"if",
"isinstance",
"(",
"data",
",",
"str",
")",
":",
"body",
"=",
"json",
".",
"loads",
"(",
"data",
")",
"else",
":",
"body",
"=",
"json",
".",
"loads",
"(",
"data",
".",
"decode",
"(",
"'utf-8'",
")",
")",
"except",
"ValueError",
":",
"abort",
"(",
"400",
")",
"if",
"self",
".",
"validate",
":",
"valid_cert",
"=",
"util",
".",
"validate_request_certificate",
"(",
"request",
".",
"headers",
",",
"request",
".",
"data",
")",
"valid_ts",
"=",
"util",
".",
"validate_request_timestamp",
"(",
"body",
")",
"if",
"not",
"valid_cert",
"or",
"not",
"valid_ts",
":",
"log",
".",
"error",
"(",
"'failed to validate request'",
")",
"abort",
"(",
"403",
")",
"resp_obj",
"=",
"self",
".",
"alexa",
".",
"dispatch_request",
"(",
"body",
")",
"return",
"Response",
"(",
"response",
"=",
"json",
".",
"dumps",
"(",
"resp_obj",
",",
"indent",
"=",
"4",
")",
",",
"status",
"=",
"200",
",",
"mimetype",
"=",
"'application/json'",
")",
"except",
"HTTPException",
"as",
"exc",
":",
"log",
".",
"exception",
"(",
"'Failed to handle request'",
")",
"return",
"exc"
] |
Incoming request handler.
:param request: Werkzeug request object
|
[
"Incoming",
"request",
"handler",
"."
] |
8bea94efa1af465254a553dc4dfea3fa552b18da
|
https://github.com/erik/alexandra/blob/8bea94efa1af465254a553dc4dfea3fa552b18da/alexandra/wsgi.py#L38-L75
|
train
|
cimm-kzn/CGRtools
|
CGRtools/files/_CGRrw.py
|
WithMixin.close
|
def close(self, force=False):
"""
close opened file
:param force: force closing of externally opened file or buffer
"""
if self.__write:
self.write = self.__write_adhoc
self.__write = False
if not self._is_buffer or force:
self._file.close()
|
python
|
def close(self, force=False):
"""
close opened file
:param force: force closing of externally opened file or buffer
"""
if self.__write:
self.write = self.__write_adhoc
self.__write = False
if not self._is_buffer or force:
self._file.close()
|
[
"def",
"close",
"(",
"self",
",",
"force",
"=",
"False",
")",
":",
"if",
"self",
".",
"__write",
":",
"self",
".",
"write",
"=",
"self",
".",
"__write_adhoc",
"self",
".",
"__write",
"=",
"False",
"if",
"not",
"self",
".",
"_is_buffer",
"or",
"force",
":",
"self",
".",
"_file",
".",
"close",
"(",
")"
] |
close opened file
:param force: force closing of externally opened file or buffer
|
[
"close",
"opened",
"file"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/files/_CGRrw.py#L57-L68
|
train
|
cimm-kzn/CGRtools
|
CGRtools/files/_CGRrw.py
|
CGRread._convert_reaction
|
def _convert_reaction(self, reaction):
if not (reaction['reactants'] or reaction['products'] or reaction['reagents']):
raise ValueError('empty reaction')
maps = {'reactants': [], 'products': [], 'reagents': []}
for i, tmp in maps.items():
for molecule in reaction[i]:
used = set()
for atom in molecule['atoms']:
m = atom['mapping']
if m:
if m in used:
if not self._ignore:
raise MappingError('mapping in molecules should be unique')
warning(f'non-unique mapping in molecule: {m}')
else:
used.add(m)
tmp.append(m)
length = count(max(max(maps['products'], default=0), max(maps['reactants'], default=0),
max(maps['reagents'], default=0)) + 1)
''' map unmapped atoms.
'''
for i, tmp in maps.items():
used = set()
maps[i] = remap = []
for m in tmp:
if not m:
remap.append(next(length))
elif m in used:
if not self._ignore:
raise MappingError('mapping in reagents or products or reactants should be unique')
# force remap non unique atoms in molecules.
remap.append(next(length))
warning(f'mapping changed: {m} to {remap[-1]}')
else:
remap.append(m)
used.add(m)
if maps['reagents']:
tmp = (set(maps['reactants']) | set(maps['products'])) & set(maps['reagents'])
if tmp:
e = f'reagents has map intersection with reactants or products: {tmp}'
if not self._ignore:
raise MappingError(e)
warning(e)
maps['reagents'] = [x if x not in tmp else next(length) for x in maps['reagents']]
''' find breaks in map. e.g. 1,2,5,6. 3,4 - skipped
'''
if self.__remap:
lose = sorted(set(range(1, next(length))) - set(maps['reactants']) - set(maps['products']) -
set(maps['reagents']), reverse=True)
if lose:
for i, tmp in maps.items():
if not tmp:
continue
for j in lose:
maps[i] = tmp = [x if x < j else x - 1 for x in tmp]
''' end
'''
rc = ReactionContainer(meta=reaction['meta'])
for i, tmp in maps.items():
shift = 0
for j in reaction[i]:
atom_len = len(j['atoms'])
remapped = {x: y for x, y in enumerate(tmp[shift: atom_len + shift])}
shift += atom_len
g = self.__convert_structure(j, remapped)
rc[i].append(g)
return rc
|
python
|
def _convert_reaction(self, reaction):
if not (reaction['reactants'] or reaction['products'] or reaction['reagents']):
raise ValueError('empty reaction')
maps = {'reactants': [], 'products': [], 'reagents': []}
for i, tmp in maps.items():
for molecule in reaction[i]:
used = set()
for atom in molecule['atoms']:
m = atom['mapping']
if m:
if m in used:
if not self._ignore:
raise MappingError('mapping in molecules should be unique')
warning(f'non-unique mapping in molecule: {m}')
else:
used.add(m)
tmp.append(m)
length = count(max(max(maps['products'], default=0), max(maps['reactants'], default=0),
max(maps['reagents'], default=0)) + 1)
''' map unmapped atoms.
'''
for i, tmp in maps.items():
used = set()
maps[i] = remap = []
for m in tmp:
if not m:
remap.append(next(length))
elif m in used:
if not self._ignore:
raise MappingError('mapping in reagents or products or reactants should be unique')
# force remap non unique atoms in molecules.
remap.append(next(length))
warning(f'mapping changed: {m} to {remap[-1]}')
else:
remap.append(m)
used.add(m)
if maps['reagents']:
tmp = (set(maps['reactants']) | set(maps['products'])) & set(maps['reagents'])
if tmp:
e = f'reagents has map intersection with reactants or products: {tmp}'
if not self._ignore:
raise MappingError(e)
warning(e)
maps['reagents'] = [x if x not in tmp else next(length) for x in maps['reagents']]
''' find breaks in map. e.g. 1,2,5,6. 3,4 - skipped
'''
if self.__remap:
lose = sorted(set(range(1, next(length))) - set(maps['reactants']) - set(maps['products']) -
set(maps['reagents']), reverse=True)
if lose:
for i, tmp in maps.items():
if not tmp:
continue
for j in lose:
maps[i] = tmp = [x if x < j else x - 1 for x in tmp]
''' end
'''
rc = ReactionContainer(meta=reaction['meta'])
for i, tmp in maps.items():
shift = 0
for j in reaction[i]:
atom_len = len(j['atoms'])
remapped = {x: y for x, y in enumerate(tmp[shift: atom_len + shift])}
shift += atom_len
g = self.__convert_structure(j, remapped)
rc[i].append(g)
return rc
|
[
"def",
"_convert_reaction",
"(",
"self",
",",
"reaction",
")",
":",
"if",
"not",
"(",
"reaction",
"[",
"'reactants'",
"]",
"or",
"reaction",
"[",
"'products'",
"]",
"or",
"reaction",
"[",
"'reagents'",
"]",
")",
":",
"raise",
"ValueError",
"(",
"'empty reaction'",
")",
"maps",
"=",
"{",
"'reactants'",
":",
"[",
"]",
",",
"'products'",
":",
"[",
"]",
",",
"'reagents'",
":",
"[",
"]",
"}",
"for",
"i",
",",
"tmp",
"in",
"maps",
".",
"items",
"(",
")",
":",
"for",
"molecule",
"in",
"reaction",
"[",
"i",
"]",
":",
"used",
"=",
"set",
"(",
")",
"for",
"atom",
"in",
"molecule",
"[",
"'atoms'",
"]",
":",
"m",
"=",
"atom",
"[",
"'mapping'",
"]",
"if",
"m",
":",
"if",
"m",
"in",
"used",
":",
"if",
"not",
"self",
".",
"_ignore",
":",
"raise",
"MappingError",
"(",
"'mapping in molecules should be unique'",
")",
"warning",
"(",
"f'non-unique mapping in molecule: {m}'",
")",
"else",
":",
"used",
".",
"add",
"(",
"m",
")",
"tmp",
".",
"append",
"(",
"m",
")",
"length",
"=",
"count",
"(",
"max",
"(",
"max",
"(",
"maps",
"[",
"'products'",
"]",
",",
"default",
"=",
"0",
")",
",",
"max",
"(",
"maps",
"[",
"'reactants'",
"]",
",",
"default",
"=",
"0",
")",
",",
"max",
"(",
"maps",
"[",
"'reagents'",
"]",
",",
"default",
"=",
"0",
")",
")",
"+",
"1",
")",
"for",
"i",
",",
"tmp",
"in",
"maps",
".",
"items",
"(",
")",
":",
"used",
"=",
"set",
"(",
")",
"maps",
"[",
"i",
"]",
"=",
"remap",
"=",
"[",
"]",
"for",
"m",
"in",
"tmp",
":",
"if",
"not",
"m",
":",
"remap",
".",
"append",
"(",
"next",
"(",
"length",
")",
")",
"elif",
"m",
"in",
"used",
":",
"if",
"not",
"self",
".",
"_ignore",
":",
"raise",
"MappingError",
"(",
"'mapping in reagents or products or reactants should be unique'",
")",
"# force remap non unique atoms in molecules.",
"remap",
".",
"append",
"(",
"next",
"(",
"length",
")",
")",
"warning",
"(",
"f'mapping changed: {m} to {remap[-1]}'",
")",
"else",
":",
"remap",
".",
"append",
"(",
"m",
")",
"used",
".",
"add",
"(",
"m",
")",
"if",
"maps",
"[",
"'reagents'",
"]",
":",
"tmp",
"=",
"(",
"set",
"(",
"maps",
"[",
"'reactants'",
"]",
")",
"|",
"set",
"(",
"maps",
"[",
"'products'",
"]",
")",
")",
"&",
"set",
"(",
"maps",
"[",
"'reagents'",
"]",
")",
"if",
"tmp",
":",
"e",
"=",
"f'reagents has map intersection with reactants or products: {tmp}'",
"if",
"not",
"self",
".",
"_ignore",
":",
"raise",
"MappingError",
"(",
"e",
")",
"warning",
"(",
"e",
")",
"maps",
"[",
"'reagents'",
"]",
"=",
"[",
"x",
"if",
"x",
"not",
"in",
"tmp",
"else",
"next",
"(",
"length",
")",
"for",
"x",
"in",
"maps",
"[",
"'reagents'",
"]",
"]",
"''' find breaks in map. e.g. 1,2,5,6. 3,4 - skipped\n '''",
"if",
"self",
".",
"__remap",
":",
"lose",
"=",
"sorted",
"(",
"set",
"(",
"range",
"(",
"1",
",",
"next",
"(",
"length",
")",
")",
")",
"-",
"set",
"(",
"maps",
"[",
"'reactants'",
"]",
")",
"-",
"set",
"(",
"maps",
"[",
"'products'",
"]",
")",
"-",
"set",
"(",
"maps",
"[",
"'reagents'",
"]",
")",
",",
"reverse",
"=",
"True",
")",
"if",
"lose",
":",
"for",
"i",
",",
"tmp",
"in",
"maps",
".",
"items",
"(",
")",
":",
"if",
"not",
"tmp",
":",
"continue",
"for",
"j",
"in",
"lose",
":",
"maps",
"[",
"i",
"]",
"=",
"tmp",
"=",
"[",
"x",
"if",
"x",
"<",
"j",
"else",
"x",
"-",
"1",
"for",
"x",
"in",
"tmp",
"]",
"''' end\n '''",
"rc",
"=",
"ReactionContainer",
"(",
"meta",
"=",
"reaction",
"[",
"'meta'",
"]",
")",
"for",
"i",
",",
"tmp",
"in",
"maps",
".",
"items",
"(",
")",
":",
"shift",
"=",
"0",
"for",
"j",
"in",
"reaction",
"[",
"i",
"]",
":",
"atom_len",
"=",
"len",
"(",
"j",
"[",
"'atoms'",
"]",
")",
"remapped",
"=",
"{",
"x",
":",
"y",
"for",
"x",
",",
"y",
"in",
"enumerate",
"(",
"tmp",
"[",
"shift",
":",
"atom_len",
"+",
"shift",
"]",
")",
"}",
"shift",
"+=",
"atom_len",
"g",
"=",
"self",
".",
"__convert_structure",
"(",
"j",
",",
"remapped",
")",
"rc",
"[",
"i",
"]",
".",
"append",
"(",
"g",
")",
"return",
"rc"
] |
map unmapped atoms.
|
[
"map",
"unmapped",
"atoms",
"."
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/files/_CGRrw.py#L88-L158
|
train
|
cimm-kzn/CGRtools
|
CGRtools/algorithms/aromatics.py
|
Aromatize.aromatize
|
def aromatize(self):
"""
convert structure to aromatic form
:return: number of processed rings
"""
rings = [x for x in self.sssr if 4 < len(x) < 7]
if not rings:
return 0
total = 0
while True:
c = self._quinonize(rings, 'order')
if c:
total += c
elif total:
break
c = self._aromatize(rings, 'order')
if not c:
break
total += c
if total:
self.flush_cache()
return total
|
python
|
def aromatize(self):
"""
convert structure to aromatic form
:return: number of processed rings
"""
rings = [x for x in self.sssr if 4 < len(x) < 7]
if not rings:
return 0
total = 0
while True:
c = self._quinonize(rings, 'order')
if c:
total += c
elif total:
break
c = self._aromatize(rings, 'order')
if not c:
break
total += c
if total:
self.flush_cache()
return total
|
[
"def",
"aromatize",
"(",
"self",
")",
":",
"rings",
"=",
"[",
"x",
"for",
"x",
"in",
"self",
".",
"sssr",
"if",
"4",
"<",
"len",
"(",
"x",
")",
"<",
"7",
"]",
"if",
"not",
"rings",
":",
"return",
"0",
"total",
"=",
"0",
"while",
"True",
":",
"c",
"=",
"self",
".",
"_quinonize",
"(",
"rings",
",",
"'order'",
")",
"if",
"c",
":",
"total",
"+=",
"c",
"elif",
"total",
":",
"break",
"c",
"=",
"self",
".",
"_aromatize",
"(",
"rings",
",",
"'order'",
")",
"if",
"not",
"c",
":",
"break",
"total",
"+=",
"c",
"if",
"total",
":",
"self",
".",
"flush_cache",
"(",
")",
"return",
"total"
] |
convert structure to aromatic form
:return: number of processed rings
|
[
"convert",
"structure",
"to",
"aromatic",
"form"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/algorithms/aromatics.py#L25-L49
|
train
|
chrismattmann/nutch-python
|
nutch/crawl.py
|
Crawler.crawl_cmd
|
def crawl_cmd(self, seed_list, n):
'''
Runs the crawl job for n rounds
:param seed_list: lines of seed URLs
:param n: number of rounds
:return: number of successful rounds
'''
print("Num Rounds "+str(n))
cc = self.proxy.Crawl(seed=seed_list, rounds=n)
rounds = cc.waitAll()
print("Completed %d rounds" % len(rounds))
return len(rounds)
|
python
|
def crawl_cmd(self, seed_list, n):
'''
Runs the crawl job for n rounds
:param seed_list: lines of seed URLs
:param n: number of rounds
:return: number of successful rounds
'''
print("Num Rounds "+str(n))
cc = self.proxy.Crawl(seed=seed_list, rounds=n)
rounds = cc.waitAll()
print("Completed %d rounds" % len(rounds))
return len(rounds)
|
[
"def",
"crawl_cmd",
"(",
"self",
",",
"seed_list",
",",
"n",
")",
":",
"print",
"(",
"\"Num Rounds \"",
"+",
"str",
"(",
"n",
")",
")",
"cc",
"=",
"self",
".",
"proxy",
".",
"Crawl",
"(",
"seed",
"=",
"seed_list",
",",
"rounds",
"=",
"n",
")",
"rounds",
"=",
"cc",
".",
"waitAll",
"(",
")",
"print",
"(",
"\"Completed %d rounds\"",
"%",
"len",
"(",
"rounds",
")",
")",
"return",
"len",
"(",
"rounds",
")"
] |
Runs the crawl job for n rounds
:param seed_list: lines of seed URLs
:param n: number of rounds
:return: number of successful rounds
|
[
"Runs",
"the",
"crawl",
"job",
"for",
"n",
"rounds",
":",
"param",
"seed_list",
":",
"lines",
"of",
"seed",
"URLs",
":",
"param",
"n",
":",
"number",
"of",
"rounds",
":",
"return",
":",
"number",
"of",
"successful",
"rounds"
] |
07ae182e283b2f74ef062ddfa20a690a59ab6f5a
|
https://github.com/chrismattmann/nutch-python/blob/07ae182e283b2f74ef062ddfa20a690a59ab6f5a/nutch/crawl.py#L38-L51
|
train
|
chrismattmann/nutch-python
|
nutch/crawl.py
|
Crawler.load_xml_conf
|
def load_xml_conf(self, xml_file, id):
'''
Creates a new config from xml file.
:param xml_file: path to xml file. Format : nutch-site.xml or nutch-default.xml
:param id:
:return: config object
'''
# converting nutch-site.xml to key:value pairs
import xml.etree.ElementTree as ET
tree = ET.parse(xml_file)
params = {}
for prop in tree.getroot().findall(".//property"):
params[prop.find('./name').text.strip()] = prop.find('./value').text.strip()
return self.proxy.Configs().create(id, configData=params)
|
python
|
def load_xml_conf(self, xml_file, id):
'''
Creates a new config from xml file.
:param xml_file: path to xml file. Format : nutch-site.xml or nutch-default.xml
:param id:
:return: config object
'''
# converting nutch-site.xml to key:value pairs
import xml.etree.ElementTree as ET
tree = ET.parse(xml_file)
params = {}
for prop in tree.getroot().findall(".//property"):
params[prop.find('./name').text.strip()] = prop.find('./value').text.strip()
return self.proxy.Configs().create(id, configData=params)
|
[
"def",
"load_xml_conf",
"(",
"self",
",",
"xml_file",
",",
"id",
")",
":",
"# converting nutch-site.xml to key:value pairs",
"import",
"xml",
".",
"etree",
".",
"ElementTree",
"as",
"ET",
"tree",
"=",
"ET",
".",
"parse",
"(",
"xml_file",
")",
"params",
"=",
"{",
"}",
"for",
"prop",
"in",
"tree",
".",
"getroot",
"(",
")",
".",
"findall",
"(",
"\".//property\"",
")",
":",
"params",
"[",
"prop",
".",
"find",
"(",
"'./name'",
")",
".",
"text",
".",
"strip",
"(",
")",
"]",
"=",
"prop",
".",
"find",
"(",
"'./value'",
")",
".",
"text",
".",
"strip",
"(",
")",
"return",
"self",
".",
"proxy",
".",
"Configs",
"(",
")",
".",
"create",
"(",
"id",
",",
"configData",
"=",
"params",
")"
] |
Creates a new config from xml file.
:param xml_file: path to xml file. Format : nutch-site.xml or nutch-default.xml
:param id:
:return: config object
|
[
"Creates",
"a",
"new",
"config",
"from",
"xml",
"file",
".",
":",
"param",
"xml_file",
":",
"path",
"to",
"xml",
"file",
".",
"Format",
":",
"nutch",
"-",
"site",
".",
"xml",
"or",
"nutch",
"-",
"default",
".",
"xml",
":",
"param",
"id",
":",
":",
"return",
":",
"config",
"object"
] |
07ae182e283b2f74ef062ddfa20a690a59ab6f5a
|
https://github.com/chrismattmann/nutch-python/blob/07ae182e283b2f74ef062ddfa20a690a59ab6f5a/nutch/crawl.py#L53-L67
|
train
|
chrismattmann/nutch-python
|
nutch/crawl.py
|
Crawler.create_cmd
|
def create_cmd(self, args):
'''
'create' sub-command
:param args: cli arguments
:return:
'''
cmd = args.get('cmd_create')
if cmd == 'conf':
conf_file = args['conf_file']
conf_id = args['id']
return self.load_xml_conf(conf_file, conf_id)
else:
print("Error: Create %s is invalid or not implemented" % cmd)
|
python
|
def create_cmd(self, args):
'''
'create' sub-command
:param args: cli arguments
:return:
'''
cmd = args.get('cmd_create')
if cmd == 'conf':
conf_file = args['conf_file']
conf_id = args['id']
return self.load_xml_conf(conf_file, conf_id)
else:
print("Error: Create %s is invalid or not implemented" % cmd)
|
[
"def",
"create_cmd",
"(",
"self",
",",
"args",
")",
":",
"cmd",
"=",
"args",
".",
"get",
"(",
"'cmd_create'",
")",
"if",
"cmd",
"==",
"'conf'",
":",
"conf_file",
"=",
"args",
"[",
"'conf_file'",
"]",
"conf_id",
"=",
"args",
"[",
"'id'",
"]",
"return",
"self",
".",
"load_xml_conf",
"(",
"conf_file",
",",
"conf_id",
")",
"else",
":",
"print",
"(",
"\"Error: Create %s is invalid or not implemented\"",
"%",
"cmd",
")"
] |
'create' sub-command
:param args: cli arguments
:return:
|
[
"create",
"sub",
"-",
"command",
":",
"param",
"args",
":",
"cli",
"arguments",
":",
"return",
":"
] |
07ae182e283b2f74ef062ddfa20a690a59ab6f5a
|
https://github.com/chrismattmann/nutch-python/blob/07ae182e283b2f74ef062ddfa20a690a59ab6f5a/nutch/crawl.py#L70-L82
|
train
|
cimm-kzn/CGRtools
|
CGRtools/files/MRVrw.py
|
MRVwrite.close
|
def close(self, *args, **kwargs):
"""
write close tag of MRV file and close opened file
:param force: force closing of externally opened file or buffer
"""
if not self.__finalized:
self._file.write('</cml>')
self.__finalized = True
super().close(*args, **kwargs)
|
python
|
def close(self, *args, **kwargs):
"""
write close tag of MRV file and close opened file
:param force: force closing of externally opened file or buffer
"""
if not self.__finalized:
self._file.write('</cml>')
self.__finalized = True
super().close(*args, **kwargs)
|
[
"def",
"close",
"(",
"self",
",",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"if",
"not",
"self",
".",
"__finalized",
":",
"self",
".",
"_file",
".",
"write",
"(",
"'</cml>'",
")",
"self",
".",
"__finalized",
"=",
"True",
"super",
"(",
")",
".",
"close",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")"
] |
write close tag of MRV file and close opened file
:param force: force closing of externally opened file or buffer
|
[
"write",
"close",
"tag",
"of",
"MRV",
"file",
"and",
"close",
"opened",
"file"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/files/MRVrw.py#L283-L292
|
train
|
cimm-kzn/CGRtools
|
CGRtools/files/MRVrw.py
|
MRVwrite.write
|
def write(self, data):
"""
write single molecule or reaction into file
"""
self._file.write('<cml>')
self.__write(data)
self.write = self.__write
|
python
|
def write(self, data):
"""
write single molecule or reaction into file
"""
self._file.write('<cml>')
self.__write(data)
self.write = self.__write
|
[
"def",
"write",
"(",
"self",
",",
"data",
")",
":",
"self",
".",
"_file",
".",
"write",
"(",
"'<cml>'",
")",
"self",
".",
"__write",
"(",
"data",
")",
"self",
".",
"write",
"=",
"self",
".",
"__write"
] |
write single molecule or reaction into file
|
[
"write",
"single",
"molecule",
"or",
"reaction",
"into",
"file"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/files/MRVrw.py#L294-L300
|
train
|
cimm-kzn/CGRtools
|
CGRtools/files/_MDLrw.py
|
MDLread._load_cache
|
def _load_cache(self):
"""
the method is implemented for the purpose of optimization, byte positions will not be re-read from a file
that has already been used, if the content of the file has changed, and the name has been left the same,
the old version of byte offsets will be loaded
:return: list of byte offsets from existing file
"""
try:
with open(self.__cache_path, 'rb') as f:
return load(f)
except FileNotFoundError:
return
except IsADirectoryError as e:
raise IsADirectoryError(f'Please delete {self.__cache_path} directory') from e
except (UnpicklingError, EOFError) as e:
raise UnpicklingError(f'Invalid cache file {self.__cache_path}. Please delete it') from e
|
python
|
def _load_cache(self):
"""
the method is implemented for the purpose of optimization, byte positions will not be re-read from a file
that has already been used, if the content of the file has changed, and the name has been left the same,
the old version of byte offsets will be loaded
:return: list of byte offsets from existing file
"""
try:
with open(self.__cache_path, 'rb') as f:
return load(f)
except FileNotFoundError:
return
except IsADirectoryError as e:
raise IsADirectoryError(f'Please delete {self.__cache_path} directory') from e
except (UnpicklingError, EOFError) as e:
raise UnpicklingError(f'Invalid cache file {self.__cache_path}. Please delete it') from e
|
[
"def",
"_load_cache",
"(",
"self",
")",
":",
"try",
":",
"with",
"open",
"(",
"self",
".",
"__cache_path",
",",
"'rb'",
")",
"as",
"f",
":",
"return",
"load",
"(",
"f",
")",
"except",
"FileNotFoundError",
":",
"return",
"except",
"IsADirectoryError",
"as",
"e",
":",
"raise",
"IsADirectoryError",
"(",
"f'Please delete {self.__cache_path} directory'",
")",
"from",
"e",
"except",
"(",
"UnpicklingError",
",",
"EOFError",
")",
"as",
"e",
":",
"raise",
"UnpicklingError",
"(",
"f'Invalid cache file {self.__cache_path}. Please delete it'",
")",
"from",
"e"
] |
the method is implemented for the purpose of optimization, byte positions will not be re-read from a file
that has already been used, if the content of the file has changed, and the name has been left the same,
the old version of byte offsets will be loaded
:return: list of byte offsets from existing file
|
[
"the",
"method",
"is",
"implemented",
"for",
"the",
"purpose",
"of",
"optimization",
"byte",
"positions",
"will",
"not",
"be",
"re",
"-",
"read",
"from",
"a",
"file",
"that",
"has",
"already",
"been",
"used",
"if",
"the",
"content",
"of",
"the",
"file",
"has",
"changed",
"and",
"the",
"name",
"has",
"been",
"left",
"the",
"same",
"the",
"old",
"version",
"of",
"byte",
"offsets",
"will",
"be",
"loaded",
":",
"return",
":",
"list",
"of",
"byte",
"offsets",
"from",
"existing",
"file"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/files/_MDLrw.py#L442-L457
|
train
|
cimm-kzn/CGRtools
|
CGRtools/files/_MDLrw.py
|
MDLread._dump_cache
|
def _dump_cache(self, _shifts):
"""
_shifts dumps in /tmp directory after reboot it will drop
"""
with open(self.__cache_path, 'wb') as f:
dump(_shifts, f)
|
python
|
def _dump_cache(self, _shifts):
"""
_shifts dumps in /tmp directory after reboot it will drop
"""
with open(self.__cache_path, 'wb') as f:
dump(_shifts, f)
|
[
"def",
"_dump_cache",
"(",
"self",
",",
"_shifts",
")",
":",
"with",
"open",
"(",
"self",
".",
"__cache_path",
",",
"'wb'",
")",
"as",
"f",
":",
"dump",
"(",
"_shifts",
",",
"f",
")"
] |
_shifts dumps in /tmp directory after reboot it will drop
|
[
"_shifts",
"dumps",
"in",
"/",
"tmp",
"directory",
"after",
"reboot",
"it",
"will",
"drop"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/files/_MDLrw.py#L463-L468
|
train
|
zetaops/zengine
|
zengine/views/system.py
|
get_task_types
|
def get_task_types(current):
"""
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_types',
}
# response:
{
'task_types': [
{'name': string, # wf name
'title': string, # title of workflow
},]
}
"""
current.output['task_types'] = [{'name': bpmn_wf.name,
'title': bpmn_wf.title}
for bpmn_wf in BPMNWorkflow.objects.all()
if current.has_permission(bpmn_wf.name)]
|
python
|
def get_task_types(current):
"""
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_types',
}
# response:
{
'task_types': [
{'name': string, # wf name
'title': string, # title of workflow
},]
}
"""
current.output['task_types'] = [{'name': bpmn_wf.name,
'title': bpmn_wf.title}
for bpmn_wf in BPMNWorkflow.objects.all()
if current.has_permission(bpmn_wf.name)]
|
[
"def",
"get_task_types",
"(",
"current",
")",
":",
"current",
".",
"output",
"[",
"'task_types'",
"]",
"=",
"[",
"{",
"'name'",
":",
"bpmn_wf",
".",
"name",
",",
"'title'",
":",
"bpmn_wf",
".",
"title",
"}",
"for",
"bpmn_wf",
"in",
"BPMNWorkflow",
".",
"objects",
".",
"all",
"(",
")",
"if",
"current",
".",
"has_permission",
"(",
"bpmn_wf",
".",
"name",
")",
"]"
] |
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_types',
}
# response:
{
'task_types': [
{'name': string, # wf name
'title': string, # title of workflow
},]
}
|
[
"List",
"task",
"types",
"for",
"current",
"user"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/system.py#L23-L46
|
train
|
zetaops/zengine
|
zengine/views/system.py
|
get_task_detail
|
def get_task_detail(current):
"""
Show task details
.. code-block:: python
# request:
{
'view': '_zops_get_task_detail',
'key': key,
}
# response:
{
'task_title': string,
'task_detail': string, # markdown formatted text
}
"""
task_inv = TaskInvitation.objects.get(current.input['key'])
obj = task_inv.instance.get_object()
current.output['task_title'] = task_inv.instance.task.name
current.output['task_detail'] = """Explain: %s
State: %s""" % (obj.__unicode__() if obj else '', task_inv.progress)
|
python
|
def get_task_detail(current):
"""
Show task details
.. code-block:: python
# request:
{
'view': '_zops_get_task_detail',
'key': key,
}
# response:
{
'task_title': string,
'task_detail': string, # markdown formatted text
}
"""
task_inv = TaskInvitation.objects.get(current.input['key'])
obj = task_inv.instance.get_object()
current.output['task_title'] = task_inv.instance.task.name
current.output['task_detail'] = """Explain: %s
State: %s""" % (obj.__unicode__() if obj else '', task_inv.progress)
|
[
"def",
"get_task_detail",
"(",
"current",
")",
":",
"task_inv",
"=",
"TaskInvitation",
".",
"objects",
".",
"get",
"(",
"current",
".",
"input",
"[",
"'key'",
"]",
")",
"obj",
"=",
"task_inv",
".",
"instance",
".",
"get_object",
"(",
")",
"current",
".",
"output",
"[",
"'task_title'",
"]",
"=",
"task_inv",
".",
"instance",
".",
"task",
".",
"name",
"current",
".",
"output",
"[",
"'task_detail'",
"]",
"=",
"\"\"\"Explain: %s\n State: %s\"\"\"",
"%",
"(",
"obj",
".",
"__unicode__",
"(",
")",
"if",
"obj",
"else",
"''",
",",
"task_inv",
".",
"progress",
")"
] |
Show task details
.. code-block:: python
# request:
{
'view': '_zops_get_task_detail',
'key': key,
}
# response:
{
'task_title': string,
'task_detail': string, # markdown formatted text
}
|
[
"Show",
"task",
"details"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/system.py#L50-L72
|
train
|
zetaops/zengine
|
zengine/views/system.py
|
get_task_actions
|
def get_task_actions(current):
"""
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_actions',
'key': key,
}
# response:
{
'key': key,
'actions': [{"title":':'Action Title', "wf": "workflow_name"},]
}
"""
task_inv = TaskInvitation.objects.get(current.input['key'])
actions = [{"title": __(u"Assign Someone Else"), "wf": "assign_same_abstract_role"},
{"title": __(u"Suspend"), "wf": "suspend_workflow"},
{"title": __(u"Postpone"), "wf": "postpone_workflow"}]
if task_inv.instance.current_actor != current.role:
actions.append({"title": __(u"Assign Yourself"), "wf": "task_assign_yourself"})
current.output['key'] = task_inv.key
current.output['actions'] = actions
|
python
|
def get_task_actions(current):
"""
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_actions',
'key': key,
}
# response:
{
'key': key,
'actions': [{"title":':'Action Title', "wf": "workflow_name"},]
}
"""
task_inv = TaskInvitation.objects.get(current.input['key'])
actions = [{"title": __(u"Assign Someone Else"), "wf": "assign_same_abstract_role"},
{"title": __(u"Suspend"), "wf": "suspend_workflow"},
{"title": __(u"Postpone"), "wf": "postpone_workflow"}]
if task_inv.instance.current_actor != current.role:
actions.append({"title": __(u"Assign Yourself"), "wf": "task_assign_yourself"})
current.output['key'] = task_inv.key
current.output['actions'] = actions
|
[
"def",
"get_task_actions",
"(",
"current",
")",
":",
"task_inv",
"=",
"TaskInvitation",
".",
"objects",
".",
"get",
"(",
"current",
".",
"input",
"[",
"'key'",
"]",
")",
"actions",
"=",
"[",
"{",
"\"title\"",
":",
"__",
"(",
"u\"Assign Someone Else\"",
")",
",",
"\"wf\"",
":",
"\"assign_same_abstract_role\"",
"}",
",",
"{",
"\"title\"",
":",
"__",
"(",
"u\"Suspend\"",
")",
",",
"\"wf\"",
":",
"\"suspend_workflow\"",
"}",
",",
"{",
"\"title\"",
":",
"__",
"(",
"u\"Postpone\"",
")",
",",
"\"wf\"",
":",
"\"postpone_workflow\"",
"}",
"]",
"if",
"task_inv",
".",
"instance",
".",
"current_actor",
"!=",
"current",
".",
"role",
":",
"actions",
".",
"append",
"(",
"{",
"\"title\"",
":",
"__",
"(",
"u\"Assign Yourself\"",
")",
",",
"\"wf\"",
":",
"\"task_assign_yourself\"",
"}",
")",
"current",
".",
"output",
"[",
"'key'",
"]",
"=",
"task_inv",
".",
"key",
"current",
".",
"output",
"[",
"'actions'",
"]",
"=",
"actions"
] |
List task types for current user
.. code-block:: python
# request:
{
'view': '_zops_get_task_actions',
'key': key,
}
# response:
{
'key': key,
'actions': [{"title":':'Action Title', "wf": "workflow_name"},]
}
|
[
"List",
"task",
"types",
"for",
"current",
"user"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/system.py#L76-L103
|
train
|
zetaops/zengine
|
zengine/views/system.py
|
get_tasks
|
def get_tasks(current):
"""
List task invitations of current user
.. code-block:: python
# request:
{
'view': '_zops_get_tasks',
'state': string, # one of these:
# "active", "future", "finished", "expired"
'inverted': boolean, # search on other people's tasks
'query': string, # optional. for searching on user's tasks
'wf_type': string, # optional. only show tasks of selected wf_type
'start_date': datetime, # optional. only show tasks starts after this date
'finish_date': datetime, # optional. only show tasks should end before this date
}
# response:
{
'task_list': [
{'token': key, # wf token (key of WFInstance)
{'key': key, # wf token (key of TaskInvitation)
'title': string, # name of workflow
'wf_type': string, # unread message count
'title': string, # task title
'state': int, # state of invitation
# zengine.models.workflow_manager.TASK_STATES
'start_date': string, # start date
'finish_date': string, # end date
},],
'active_task_count': int,
'future_task_count': int,
'finished_task_count': int,
'expired_task_count': int,
}
"""
# TODO: Also return invitations for user's other roles
# TODO: Handle automatic role switching
STATE_DICT = {
'active': [20, 30],
'future': 10,
'finished': 40,
'expired': 90
}
state = STATE_DICT[current.input['state']]
if isinstance(state, list):
queryset = TaskInvitation.objects.filter(progress__in=state)
else:
queryset = TaskInvitation.objects.filter(progress=state)
if 'inverted' in current.input:
# show other user's tasks
allowed_workflows = [bpmn_wf.name for bpmn_wf in BPMNWorkflow.objects.all()
if current.has_permission(bpmn_wf.name)]
queryset = queryset.exclude(role_id=current.role_id).filter(wf_name__in=allowed_workflows)
else:
# show current user's tasks
queryset = queryset.filter(role_id=current.role_id)
if 'query' in current.input:
queryset = queryset.filter(search_data__contains=current.input['query'].lower())
if 'wf_type' in current.input:
queryset = queryset.filter(wf_name=current.input['wf_type'])
if 'start_date' in current.input:
queryset = queryset.filter(start_date__gte=datetime.strptime(current.input['start_date'], "%d.%m.%Y"))
if 'finish_date' in current.input:
queryset = queryset.filter(finish_date__lte=datetime.strptime(current.input['finish_date'], "%d.%m.%Y"))
current.output['task_list'] = [
{
'token': inv.instance.key,
'key': inv.key,
'title': inv.title,
'wf_type': inv.wf_name,
'state': inv.progress,
'start_date': format_date(inv.start_date),
'finish_date': format_date(inv.finish_date),
'description': inv.instance.wf.description,
'status': inv.ownership}
for inv in queryset
]
task_inv_list = TaskInvitation.objects.filter(role_id=current.role_id)
current.output['task_count']= {
'active': task_inv_list.filter(progress__in=STATE_DICT['active']).count(),
'future' : task_inv_list.filter(progress=STATE_DICT['future']).count(),
'finished' : task_inv_list.filter(progress=STATE_DICT['finished']).count(),
'expired' : task_inv_list.filter(progress=STATE_DICT['expired']).count()
}
|
python
|
def get_tasks(current):
"""
List task invitations of current user
.. code-block:: python
# request:
{
'view': '_zops_get_tasks',
'state': string, # one of these:
# "active", "future", "finished", "expired"
'inverted': boolean, # search on other people's tasks
'query': string, # optional. for searching on user's tasks
'wf_type': string, # optional. only show tasks of selected wf_type
'start_date': datetime, # optional. only show tasks starts after this date
'finish_date': datetime, # optional. only show tasks should end before this date
}
# response:
{
'task_list': [
{'token': key, # wf token (key of WFInstance)
{'key': key, # wf token (key of TaskInvitation)
'title': string, # name of workflow
'wf_type': string, # unread message count
'title': string, # task title
'state': int, # state of invitation
# zengine.models.workflow_manager.TASK_STATES
'start_date': string, # start date
'finish_date': string, # end date
},],
'active_task_count': int,
'future_task_count': int,
'finished_task_count': int,
'expired_task_count': int,
}
"""
# TODO: Also return invitations for user's other roles
# TODO: Handle automatic role switching
STATE_DICT = {
'active': [20, 30],
'future': 10,
'finished': 40,
'expired': 90
}
state = STATE_DICT[current.input['state']]
if isinstance(state, list):
queryset = TaskInvitation.objects.filter(progress__in=state)
else:
queryset = TaskInvitation.objects.filter(progress=state)
if 'inverted' in current.input:
# show other user's tasks
allowed_workflows = [bpmn_wf.name for bpmn_wf in BPMNWorkflow.objects.all()
if current.has_permission(bpmn_wf.name)]
queryset = queryset.exclude(role_id=current.role_id).filter(wf_name__in=allowed_workflows)
else:
# show current user's tasks
queryset = queryset.filter(role_id=current.role_id)
if 'query' in current.input:
queryset = queryset.filter(search_data__contains=current.input['query'].lower())
if 'wf_type' in current.input:
queryset = queryset.filter(wf_name=current.input['wf_type'])
if 'start_date' in current.input:
queryset = queryset.filter(start_date__gte=datetime.strptime(current.input['start_date'], "%d.%m.%Y"))
if 'finish_date' in current.input:
queryset = queryset.filter(finish_date__lte=datetime.strptime(current.input['finish_date'], "%d.%m.%Y"))
current.output['task_list'] = [
{
'token': inv.instance.key,
'key': inv.key,
'title': inv.title,
'wf_type': inv.wf_name,
'state': inv.progress,
'start_date': format_date(inv.start_date),
'finish_date': format_date(inv.finish_date),
'description': inv.instance.wf.description,
'status': inv.ownership}
for inv in queryset
]
task_inv_list = TaskInvitation.objects.filter(role_id=current.role_id)
current.output['task_count']= {
'active': task_inv_list.filter(progress__in=STATE_DICT['active']).count(),
'future' : task_inv_list.filter(progress=STATE_DICT['future']).count(),
'finished' : task_inv_list.filter(progress=STATE_DICT['finished']).count(),
'expired' : task_inv_list.filter(progress=STATE_DICT['expired']).count()
}
|
[
"def",
"get_tasks",
"(",
"current",
")",
":",
"# TODO: Also return invitations for user's other roles",
"# TODO: Handle automatic role switching",
"STATE_DICT",
"=",
"{",
"'active'",
":",
"[",
"20",
",",
"30",
"]",
",",
"'future'",
":",
"10",
",",
"'finished'",
":",
"40",
",",
"'expired'",
":",
"90",
"}",
"state",
"=",
"STATE_DICT",
"[",
"current",
".",
"input",
"[",
"'state'",
"]",
"]",
"if",
"isinstance",
"(",
"state",
",",
"list",
")",
":",
"queryset",
"=",
"TaskInvitation",
".",
"objects",
".",
"filter",
"(",
"progress__in",
"=",
"state",
")",
"else",
":",
"queryset",
"=",
"TaskInvitation",
".",
"objects",
".",
"filter",
"(",
"progress",
"=",
"state",
")",
"if",
"'inverted'",
"in",
"current",
".",
"input",
":",
"# show other user's tasks",
"allowed_workflows",
"=",
"[",
"bpmn_wf",
".",
"name",
"for",
"bpmn_wf",
"in",
"BPMNWorkflow",
".",
"objects",
".",
"all",
"(",
")",
"if",
"current",
".",
"has_permission",
"(",
"bpmn_wf",
".",
"name",
")",
"]",
"queryset",
"=",
"queryset",
".",
"exclude",
"(",
"role_id",
"=",
"current",
".",
"role_id",
")",
".",
"filter",
"(",
"wf_name__in",
"=",
"allowed_workflows",
")",
"else",
":",
"# show current user's tasks",
"queryset",
"=",
"queryset",
".",
"filter",
"(",
"role_id",
"=",
"current",
".",
"role_id",
")",
"if",
"'query'",
"in",
"current",
".",
"input",
":",
"queryset",
"=",
"queryset",
".",
"filter",
"(",
"search_data__contains",
"=",
"current",
".",
"input",
"[",
"'query'",
"]",
".",
"lower",
"(",
")",
")",
"if",
"'wf_type'",
"in",
"current",
".",
"input",
":",
"queryset",
"=",
"queryset",
".",
"filter",
"(",
"wf_name",
"=",
"current",
".",
"input",
"[",
"'wf_type'",
"]",
")",
"if",
"'start_date'",
"in",
"current",
".",
"input",
":",
"queryset",
"=",
"queryset",
".",
"filter",
"(",
"start_date__gte",
"=",
"datetime",
".",
"strptime",
"(",
"current",
".",
"input",
"[",
"'start_date'",
"]",
",",
"\"%d.%m.%Y\"",
")",
")",
"if",
"'finish_date'",
"in",
"current",
".",
"input",
":",
"queryset",
"=",
"queryset",
".",
"filter",
"(",
"finish_date__lte",
"=",
"datetime",
".",
"strptime",
"(",
"current",
".",
"input",
"[",
"'finish_date'",
"]",
",",
"\"%d.%m.%Y\"",
")",
")",
"current",
".",
"output",
"[",
"'task_list'",
"]",
"=",
"[",
"{",
"'token'",
":",
"inv",
".",
"instance",
".",
"key",
",",
"'key'",
":",
"inv",
".",
"key",
",",
"'title'",
":",
"inv",
".",
"title",
",",
"'wf_type'",
":",
"inv",
".",
"wf_name",
",",
"'state'",
":",
"inv",
".",
"progress",
",",
"'start_date'",
":",
"format_date",
"(",
"inv",
".",
"start_date",
")",
",",
"'finish_date'",
":",
"format_date",
"(",
"inv",
".",
"finish_date",
")",
",",
"'description'",
":",
"inv",
".",
"instance",
".",
"wf",
".",
"description",
",",
"'status'",
":",
"inv",
".",
"ownership",
"}",
"for",
"inv",
"in",
"queryset",
"]",
"task_inv_list",
"=",
"TaskInvitation",
".",
"objects",
".",
"filter",
"(",
"role_id",
"=",
"current",
".",
"role_id",
")",
"current",
".",
"output",
"[",
"'task_count'",
"]",
"=",
"{",
"'active'",
":",
"task_inv_list",
".",
"filter",
"(",
"progress__in",
"=",
"STATE_DICT",
"[",
"'active'",
"]",
")",
".",
"count",
"(",
")",
",",
"'future'",
":",
"task_inv_list",
".",
"filter",
"(",
"progress",
"=",
"STATE_DICT",
"[",
"'future'",
"]",
")",
".",
"count",
"(",
")",
",",
"'finished'",
":",
"task_inv_list",
".",
"filter",
"(",
"progress",
"=",
"STATE_DICT",
"[",
"'finished'",
"]",
")",
".",
"count",
"(",
")",
",",
"'expired'",
":",
"task_inv_list",
".",
"filter",
"(",
"progress",
"=",
"STATE_DICT",
"[",
"'expired'",
"]",
")",
".",
"count",
"(",
")",
"}"
] |
List task invitations of current user
.. code-block:: python
# request:
{
'view': '_zops_get_tasks',
'state': string, # one of these:
# "active", "future", "finished", "expired"
'inverted': boolean, # search on other people's tasks
'query': string, # optional. for searching on user's tasks
'wf_type': string, # optional. only show tasks of selected wf_type
'start_date': datetime, # optional. only show tasks starts after this date
'finish_date': datetime, # optional. only show tasks should end before this date
}
# response:
{
'task_list': [
{'token': key, # wf token (key of WFInstance)
{'key': key, # wf token (key of TaskInvitation)
'title': string, # name of workflow
'wf_type': string, # unread message count
'title': string, # task title
'state': int, # state of invitation
# zengine.models.workflow_manager.TASK_STATES
'start_date': string, # start date
'finish_date': string, # end date
},],
'active_task_count': int,
'future_task_count': int,
'finished_task_count': int,
'expired_task_count': int,
}
|
[
"List",
"task",
"invitations",
"of",
"current",
"user"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/system.py#L107-L197
|
train
|
wdecoster/nanoget
|
nanoget/utils.py
|
reduce_memory_usage
|
def reduce_memory_usage(df):
"""reduce memory usage of the dataframe
- convert runIDs to categorical
- downcast ints and floats
"""
usage_pre = df.memory_usage(deep=True).sum()
if "runIDs" in df:
df.loc[:, "runIDs"] = df.loc[:, "runIDs"].astype("category")
df_int = df.select_dtypes(include=['int'])
df_float = df.select_dtypes(include=['float'])
df.loc[:, df_int.columns] = df_int.apply(pd.to_numeric, downcast='unsigned')
df.loc[:, df_float.columns] = df_float.apply(pd.to_numeric, downcast='float')
usage_post = df.memory_usage(deep=True).sum()
logging.info("Reduced DataFrame memory usage from {}Mb to {}Mb".format(
usage_pre / 1024**2, usage_post / 1024**2))
if usage_post > 4e9 and "readIDs" in df:
logging.info("DataFrame of features is too big, dropping read identifiers.")
return df.drop(["readIDs"], axis=1, errors="ignore")
else:
return df
|
python
|
def reduce_memory_usage(df):
"""reduce memory usage of the dataframe
- convert runIDs to categorical
- downcast ints and floats
"""
usage_pre = df.memory_usage(deep=True).sum()
if "runIDs" in df:
df.loc[:, "runIDs"] = df.loc[:, "runIDs"].astype("category")
df_int = df.select_dtypes(include=['int'])
df_float = df.select_dtypes(include=['float'])
df.loc[:, df_int.columns] = df_int.apply(pd.to_numeric, downcast='unsigned')
df.loc[:, df_float.columns] = df_float.apply(pd.to_numeric, downcast='float')
usage_post = df.memory_usage(deep=True).sum()
logging.info("Reduced DataFrame memory usage from {}Mb to {}Mb".format(
usage_pre / 1024**2, usage_post / 1024**2))
if usage_post > 4e9 and "readIDs" in df:
logging.info("DataFrame of features is too big, dropping read identifiers.")
return df.drop(["readIDs"], axis=1, errors="ignore")
else:
return df
|
[
"def",
"reduce_memory_usage",
"(",
"df",
")",
":",
"usage_pre",
"=",
"df",
".",
"memory_usage",
"(",
"deep",
"=",
"True",
")",
".",
"sum",
"(",
")",
"if",
"\"runIDs\"",
"in",
"df",
":",
"df",
".",
"loc",
"[",
":",
",",
"\"runIDs\"",
"]",
"=",
"df",
".",
"loc",
"[",
":",
",",
"\"runIDs\"",
"]",
".",
"astype",
"(",
"\"category\"",
")",
"df_int",
"=",
"df",
".",
"select_dtypes",
"(",
"include",
"=",
"[",
"'int'",
"]",
")",
"df_float",
"=",
"df",
".",
"select_dtypes",
"(",
"include",
"=",
"[",
"'float'",
"]",
")",
"df",
".",
"loc",
"[",
":",
",",
"df_int",
".",
"columns",
"]",
"=",
"df_int",
".",
"apply",
"(",
"pd",
".",
"to_numeric",
",",
"downcast",
"=",
"'unsigned'",
")",
"df",
".",
"loc",
"[",
":",
",",
"df_float",
".",
"columns",
"]",
"=",
"df_float",
".",
"apply",
"(",
"pd",
".",
"to_numeric",
",",
"downcast",
"=",
"'float'",
")",
"usage_post",
"=",
"df",
".",
"memory_usage",
"(",
"deep",
"=",
"True",
")",
".",
"sum",
"(",
")",
"logging",
".",
"info",
"(",
"\"Reduced DataFrame memory usage from {}Mb to {}Mb\"",
".",
"format",
"(",
"usage_pre",
"/",
"1024",
"**",
"2",
",",
"usage_post",
"/",
"1024",
"**",
"2",
")",
")",
"if",
"usage_post",
">",
"4e9",
"and",
"\"readIDs\"",
"in",
"df",
":",
"logging",
".",
"info",
"(",
"\"DataFrame of features is too big, dropping read identifiers.\"",
")",
"return",
"df",
".",
"drop",
"(",
"[",
"\"readIDs\"",
"]",
",",
"axis",
"=",
"1",
",",
"errors",
"=",
"\"ignore\"",
")",
"else",
":",
"return",
"df"
] |
reduce memory usage of the dataframe
- convert runIDs to categorical
- downcast ints and floats
|
[
"reduce",
"memory",
"usage",
"of",
"the",
"dataframe"
] |
fb7306220e261849b96785fab02dd2f35a0e3b60
|
https://github.com/wdecoster/nanoget/blob/fb7306220e261849b96785fab02dd2f35a0e3b60/nanoget/utils.py#L7-L27
|
train
|
wdecoster/nanoget
|
nanoget/utils.py
|
check_existance
|
def check_existance(f):
"""Check if the file supplied as input exists."""
if not opath.isfile(f):
logging.error("Nanoget: File provided doesn't exist or the path is incorrect: {}".format(f))
sys.exit("File provided doesn't exist or the path is incorrect: {}".format(f))
|
python
|
def check_existance(f):
"""Check if the file supplied as input exists."""
if not opath.isfile(f):
logging.error("Nanoget: File provided doesn't exist or the path is incorrect: {}".format(f))
sys.exit("File provided doesn't exist or the path is incorrect: {}".format(f))
|
[
"def",
"check_existance",
"(",
"f",
")",
":",
"if",
"not",
"opath",
".",
"isfile",
"(",
"f",
")",
":",
"logging",
".",
"error",
"(",
"\"Nanoget: File provided doesn't exist or the path is incorrect: {}\"",
".",
"format",
"(",
"f",
")",
")",
"sys",
".",
"exit",
"(",
"\"File provided doesn't exist or the path is incorrect: {}\"",
".",
"format",
"(",
"f",
")",
")"
] |
Check if the file supplied as input exists.
|
[
"Check",
"if",
"the",
"file",
"supplied",
"as",
"input",
"exists",
"."
] |
fb7306220e261849b96785fab02dd2f35a0e3b60
|
https://github.com/wdecoster/nanoget/blob/fb7306220e261849b96785fab02dd2f35a0e3b60/nanoget/utils.py#L30-L34
|
train
|
zetaops/zengine
|
zengine/views/role_switching.py
|
RoleSwitching.list_user_roles
|
def list_user_roles(self):
"""
Lists user roles as selectable except user's current role.
"""
_form = JsonForm(current=self.current, title=_(u"Switch Role"))
_form.help_text = "Your current role: %s %s" % (self.current.role.unit.name,
self.current.role.abstract_role.name)
switch_roles = self.get_user_switchable_roles()
_form.role_options = fields.Integer(_(u"Please, choose the role you want to switch:")
, choices=switch_roles, default=switch_roles[0][0],
required=True)
_form.switch = fields.Button(_(u"Switch"))
self.form_out(_form)
|
python
|
def list_user_roles(self):
"""
Lists user roles as selectable except user's current role.
"""
_form = JsonForm(current=self.current, title=_(u"Switch Role"))
_form.help_text = "Your current role: %s %s" % (self.current.role.unit.name,
self.current.role.abstract_role.name)
switch_roles = self.get_user_switchable_roles()
_form.role_options = fields.Integer(_(u"Please, choose the role you want to switch:")
, choices=switch_roles, default=switch_roles[0][0],
required=True)
_form.switch = fields.Button(_(u"Switch"))
self.form_out(_form)
|
[
"def",
"list_user_roles",
"(",
"self",
")",
":",
"_form",
"=",
"JsonForm",
"(",
"current",
"=",
"self",
".",
"current",
",",
"title",
"=",
"_",
"(",
"u\"Switch Role\"",
")",
")",
"_form",
".",
"help_text",
"=",
"\"Your current role: %s %s\"",
"%",
"(",
"self",
".",
"current",
".",
"role",
".",
"unit",
".",
"name",
",",
"self",
".",
"current",
".",
"role",
".",
"abstract_role",
".",
"name",
")",
"switch_roles",
"=",
"self",
".",
"get_user_switchable_roles",
"(",
")",
"_form",
".",
"role_options",
"=",
"fields",
".",
"Integer",
"(",
"_",
"(",
"u\"Please, choose the role you want to switch:\"",
")",
",",
"choices",
"=",
"switch_roles",
",",
"default",
"=",
"switch_roles",
"[",
"0",
"]",
"[",
"0",
"]",
",",
"required",
"=",
"True",
")",
"_form",
".",
"switch",
"=",
"fields",
".",
"Button",
"(",
"_",
"(",
"u\"Switch\"",
")",
")",
"self",
".",
"form_out",
"(",
"_form",
")"
] |
Lists user roles as selectable except user's current role.
|
[
"Lists",
"user",
"roles",
"as",
"selectable",
"except",
"user",
"s",
"current",
"role",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/role_switching.py#L22-L34
|
train
|
zetaops/zengine
|
zengine/views/role_switching.py
|
RoleSwitching.change_user_role
|
def change_user_role(self):
"""
Changes user's role from current role to chosen role.
"""
# Get chosen role_key from user form.
role_key = self.input['form']['role_options']
# Assign chosen switch role key to user's last_login_role_key field
self.current.user.last_login_role_key = role_key
self.current.user.save()
auth = AuthBackend(self.current)
# According to user's new role, user's session set again.
auth.set_user(self.current.user)
# Dashboard is reloaded according to user's new role.
self.current.output['cmd'] = 'reload'
|
python
|
def change_user_role(self):
"""
Changes user's role from current role to chosen role.
"""
# Get chosen role_key from user form.
role_key = self.input['form']['role_options']
# Assign chosen switch role key to user's last_login_role_key field
self.current.user.last_login_role_key = role_key
self.current.user.save()
auth = AuthBackend(self.current)
# According to user's new role, user's session set again.
auth.set_user(self.current.user)
# Dashboard is reloaded according to user's new role.
self.current.output['cmd'] = 'reload'
|
[
"def",
"change_user_role",
"(",
"self",
")",
":",
"# Get chosen role_key from user form.",
"role_key",
"=",
"self",
".",
"input",
"[",
"'form'",
"]",
"[",
"'role_options'",
"]",
"# Assign chosen switch role key to user's last_login_role_key field",
"self",
".",
"current",
".",
"user",
".",
"last_login_role_key",
"=",
"role_key",
"self",
".",
"current",
".",
"user",
".",
"save",
"(",
")",
"auth",
"=",
"AuthBackend",
"(",
"self",
".",
"current",
")",
"# According to user's new role, user's session set again.",
"auth",
".",
"set_user",
"(",
"self",
".",
"current",
".",
"user",
")",
"# Dashboard is reloaded according to user's new role.",
"self",
".",
"current",
".",
"output",
"[",
"'cmd'",
"]",
"=",
"'reload'"
] |
Changes user's role from current role to chosen role.
|
[
"Changes",
"user",
"s",
"role",
"from",
"current",
"role",
"to",
"chosen",
"role",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/role_switching.py#L36-L50
|
train
|
zetaops/zengine
|
zengine/views/role_switching.py
|
RoleSwitching.get_user_switchable_roles
|
def get_user_switchable_roles(self):
"""
Returns user's role list except current role as a tuple
(role.key, role.name)
Returns:
(list): list of tuples, user's role list except current role
"""
roles = []
for rs in self.current.user.role_set:
# rs.role != self.current.role is not True after python version 2.7.12
if rs.role.key != self.current.role.key:
roles.append((rs.role.key, '%s %s' % (rs.role.unit.name,
rs.role.abstract_role.name)))
return roles
|
python
|
def get_user_switchable_roles(self):
"""
Returns user's role list except current role as a tuple
(role.key, role.name)
Returns:
(list): list of tuples, user's role list except current role
"""
roles = []
for rs in self.current.user.role_set:
# rs.role != self.current.role is not True after python version 2.7.12
if rs.role.key != self.current.role.key:
roles.append((rs.role.key, '%s %s' % (rs.role.unit.name,
rs.role.abstract_role.name)))
return roles
|
[
"def",
"get_user_switchable_roles",
"(",
"self",
")",
":",
"roles",
"=",
"[",
"]",
"for",
"rs",
"in",
"self",
".",
"current",
".",
"user",
".",
"role_set",
":",
"# rs.role != self.current.role is not True after python version 2.7.12",
"if",
"rs",
".",
"role",
".",
"key",
"!=",
"self",
".",
"current",
".",
"role",
".",
"key",
":",
"roles",
".",
"append",
"(",
"(",
"rs",
".",
"role",
".",
"key",
",",
"'%s %s'",
"%",
"(",
"rs",
".",
"role",
".",
"unit",
".",
"name",
",",
"rs",
".",
"role",
".",
"abstract_role",
".",
"name",
")",
")",
")",
"return",
"roles"
] |
Returns user's role list except current role as a tuple
(role.key, role.name)
Returns:
(list): list of tuples, user's role list except current role
|
[
"Returns",
"user",
"s",
"role",
"list",
"except",
"current",
"role",
"as",
"a",
"tuple",
"(",
"role",
".",
"key",
"role",
".",
"name",
")"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/views/role_switching.py#L52-L67
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.put_object
|
def put_object(self, obj):
# TODO consider putting into a ES class
self.pr_dbg('put_obj: %s' % self.json_dumps(obj))
"""
Wrapper for es.index, determines metadata needed to index from obj.
If you have a raw object json string you can hard code these:
index is .kibana (as of kibana4);
id can be A-Za-z0-9\- and must be unique;
doc_type is either visualization, dashboard, search
or for settings docs: config, or index-pattern.
"""
if obj['_index'] is None or obj['_index'] == "":
raise Exception("Invalid Object, no index")
if obj['_id'] is None or obj['_id'] == "":
raise Exception("Invalid Object, no _id")
if obj['_type'] is None or obj['_type'] == "":
raise Exception("Invalid Object, no _type")
if obj['_source'] is None or obj['_source'] == "":
raise Exception("Invalid Object, no _source")
self.connect_es()
self.es.indices.create(index=obj['_index'], ignore=400, timeout="2m")
try:
resp = self.es.index(index=obj['_index'],
id=obj['_id'],
doc_type=obj['_type'],
body=obj['_source'], timeout="2m")
except RequestError as e:
self.pr_err('RequestError: %s, info: %s' % (e.error, e.info))
raise
return resp
|
python
|
def put_object(self, obj):
# TODO consider putting into a ES class
self.pr_dbg('put_obj: %s' % self.json_dumps(obj))
"""
Wrapper for es.index, determines metadata needed to index from obj.
If you have a raw object json string you can hard code these:
index is .kibana (as of kibana4);
id can be A-Za-z0-9\- and must be unique;
doc_type is either visualization, dashboard, search
or for settings docs: config, or index-pattern.
"""
if obj['_index'] is None or obj['_index'] == "":
raise Exception("Invalid Object, no index")
if obj['_id'] is None or obj['_id'] == "":
raise Exception("Invalid Object, no _id")
if obj['_type'] is None or obj['_type'] == "":
raise Exception("Invalid Object, no _type")
if obj['_source'] is None or obj['_source'] == "":
raise Exception("Invalid Object, no _source")
self.connect_es()
self.es.indices.create(index=obj['_index'], ignore=400, timeout="2m")
try:
resp = self.es.index(index=obj['_index'],
id=obj['_id'],
doc_type=obj['_type'],
body=obj['_source'], timeout="2m")
except RequestError as e:
self.pr_err('RequestError: %s, info: %s' % (e.error, e.info))
raise
return resp
|
[
"def",
"put_object",
"(",
"self",
",",
"obj",
")",
":",
"# TODO consider putting into a ES class",
"self",
".",
"pr_dbg",
"(",
"'put_obj: %s'",
"%",
"self",
".",
"json_dumps",
"(",
"obj",
")",
")",
"if",
"obj",
"[",
"'_index'",
"]",
"is",
"None",
"or",
"obj",
"[",
"'_index'",
"]",
"==",
"\"\"",
":",
"raise",
"Exception",
"(",
"\"Invalid Object, no index\"",
")",
"if",
"obj",
"[",
"'_id'",
"]",
"is",
"None",
"or",
"obj",
"[",
"'_id'",
"]",
"==",
"\"\"",
":",
"raise",
"Exception",
"(",
"\"Invalid Object, no _id\"",
")",
"if",
"obj",
"[",
"'_type'",
"]",
"is",
"None",
"or",
"obj",
"[",
"'_type'",
"]",
"==",
"\"\"",
":",
"raise",
"Exception",
"(",
"\"Invalid Object, no _type\"",
")",
"if",
"obj",
"[",
"'_source'",
"]",
"is",
"None",
"or",
"obj",
"[",
"'_source'",
"]",
"==",
"\"\"",
":",
"raise",
"Exception",
"(",
"\"Invalid Object, no _source\"",
")",
"self",
".",
"connect_es",
"(",
")",
"self",
".",
"es",
".",
"indices",
".",
"create",
"(",
"index",
"=",
"obj",
"[",
"'_index'",
"]",
",",
"ignore",
"=",
"400",
",",
"timeout",
"=",
"\"2m\"",
")",
"try",
":",
"resp",
"=",
"self",
".",
"es",
".",
"index",
"(",
"index",
"=",
"obj",
"[",
"'_index'",
"]",
",",
"id",
"=",
"obj",
"[",
"'_id'",
"]",
",",
"doc_type",
"=",
"obj",
"[",
"'_type'",
"]",
",",
"body",
"=",
"obj",
"[",
"'_source'",
"]",
",",
"timeout",
"=",
"\"2m\"",
")",
"except",
"RequestError",
"as",
"e",
":",
"self",
".",
"pr_err",
"(",
"'RequestError: %s, info: %s'",
"%",
"(",
"e",
".",
"error",
",",
"e",
".",
"info",
")",
")",
"raise",
"return",
"resp"
] |
Wrapper for es.index, determines metadata needed to index from obj.
If you have a raw object json string you can hard code these:
index is .kibana (as of kibana4);
id can be A-Za-z0-9\- and must be unique;
doc_type is either visualization, dashboard, search
or for settings docs: config, or index-pattern.
|
[
"Wrapper",
"for",
"es",
".",
"index",
"determines",
"metadata",
"needed",
"to",
"index",
"from",
"obj",
".",
"If",
"you",
"have",
"a",
"raw",
"object",
"json",
"string",
"you",
"can",
"hard",
"code",
"these",
":",
"index",
"is",
".",
"kibana",
"(",
"as",
"of",
"kibana4",
")",
";",
"id",
"can",
"be",
"A",
"-",
"Za",
"-",
"z0",
"-",
"9",
"\\",
"-",
"and",
"must",
"be",
"unique",
";",
"doc_type",
"is",
"either",
"visualization",
"dashboard",
"search",
"or",
"for",
"settings",
"docs",
":",
"config",
"or",
"index",
"-",
"pattern",
"."
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L105-L134
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.del_object
|
def del_object(self, obj):
"""Debug deletes obj of obj[_type] with id of obj['_id']"""
if obj['_index'] is None or obj['_index'] == "":
raise Exception("Invalid Object")
if obj['_id'] is None or obj['_id'] == "":
raise Exception("Invalid Object")
if obj['_type'] is None or obj['_type'] == "":
raise Exception("Invalid Object")
self.connect_es()
self.es.delete(index=obj['_index'],
id=obj['_id'],
doc_type=obj['_type'])
|
python
|
def del_object(self, obj):
"""Debug deletes obj of obj[_type] with id of obj['_id']"""
if obj['_index'] is None or obj['_index'] == "":
raise Exception("Invalid Object")
if obj['_id'] is None or obj['_id'] == "":
raise Exception("Invalid Object")
if obj['_type'] is None or obj['_type'] == "":
raise Exception("Invalid Object")
self.connect_es()
self.es.delete(index=obj['_index'],
id=obj['_id'],
doc_type=obj['_type'])
|
[
"def",
"del_object",
"(",
"self",
",",
"obj",
")",
":",
"if",
"obj",
"[",
"'_index'",
"]",
"is",
"None",
"or",
"obj",
"[",
"'_index'",
"]",
"==",
"\"\"",
":",
"raise",
"Exception",
"(",
"\"Invalid Object\"",
")",
"if",
"obj",
"[",
"'_id'",
"]",
"is",
"None",
"or",
"obj",
"[",
"'_id'",
"]",
"==",
"\"\"",
":",
"raise",
"Exception",
"(",
"\"Invalid Object\"",
")",
"if",
"obj",
"[",
"'_type'",
"]",
"is",
"None",
"or",
"obj",
"[",
"'_type'",
"]",
"==",
"\"\"",
":",
"raise",
"Exception",
"(",
"\"Invalid Object\"",
")",
"self",
".",
"connect_es",
"(",
")",
"self",
".",
"es",
".",
"delete",
"(",
"index",
"=",
"obj",
"[",
"'_index'",
"]",
",",
"id",
"=",
"obj",
"[",
"'_id'",
"]",
",",
"doc_type",
"=",
"obj",
"[",
"'_type'",
"]",
")"
] |
Debug deletes obj of obj[_type] with id of obj['_id']
|
[
"Debug",
"deletes",
"obj",
"of",
"obj",
"[",
"_type",
"]",
"with",
"id",
"of",
"obj",
"[",
"_id",
"]"
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L144-L155
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.json_dumps
|
def json_dumps(self, obj):
"""Serializer for consistency"""
return json.dumps(obj, sort_keys=True, indent=4, separators=(',', ': '))
|
python
|
def json_dumps(self, obj):
"""Serializer for consistency"""
return json.dumps(obj, sort_keys=True, indent=4, separators=(',', ': '))
|
[
"def",
"json_dumps",
"(",
"self",
",",
"obj",
")",
":",
"return",
"json",
".",
"dumps",
"(",
"obj",
",",
"sort_keys",
"=",
"True",
",",
"indent",
"=",
"4",
",",
"separators",
"=",
"(",
"','",
",",
"': '",
")",
")"
] |
Serializer for consistency
|
[
"Serializer",
"for",
"consistency"
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L161-L163
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.safe_filename
|
def safe_filename(self, otype, oid):
"""Santize obj name into fname and verify doesn't already exist"""
permitted = set(['_', '-', '(', ')'])
oid = ''.join([c for c in oid if c.isalnum() or c in permitted])
while oid.find('--') != -1:
oid = oid.replace('--', '-')
ext = 'json'
ts = datetime.now().strftime("%Y%m%dT%H%M%S")
fname = ''
is_new = False
while not is_new:
oid_len = 255 - len('%s--%s.%s' % (otype, ts, ext))
fname = '%s-%s-%s.%s' % (otype, oid[:oid_len], ts, ext)
is_new = True
if os.path.exists(fname):
is_new = False
ts += '-bck'
return fname
|
python
|
def safe_filename(self, otype, oid):
"""Santize obj name into fname and verify doesn't already exist"""
permitted = set(['_', '-', '(', ')'])
oid = ''.join([c for c in oid if c.isalnum() or c in permitted])
while oid.find('--') != -1:
oid = oid.replace('--', '-')
ext = 'json'
ts = datetime.now().strftime("%Y%m%dT%H%M%S")
fname = ''
is_new = False
while not is_new:
oid_len = 255 - len('%s--%s.%s' % (otype, ts, ext))
fname = '%s-%s-%s.%s' % (otype, oid[:oid_len], ts, ext)
is_new = True
if os.path.exists(fname):
is_new = False
ts += '-bck'
return fname
|
[
"def",
"safe_filename",
"(",
"self",
",",
"otype",
",",
"oid",
")",
":",
"permitted",
"=",
"set",
"(",
"[",
"'_'",
",",
"'-'",
",",
"'('",
",",
"')'",
"]",
")",
"oid",
"=",
"''",
".",
"join",
"(",
"[",
"c",
"for",
"c",
"in",
"oid",
"if",
"c",
".",
"isalnum",
"(",
")",
"or",
"c",
"in",
"permitted",
"]",
")",
"while",
"oid",
".",
"find",
"(",
"'--'",
")",
"!=",
"-",
"1",
":",
"oid",
"=",
"oid",
".",
"replace",
"(",
"'--'",
",",
"'-'",
")",
"ext",
"=",
"'json'",
"ts",
"=",
"datetime",
".",
"now",
"(",
")",
".",
"strftime",
"(",
"\"%Y%m%dT%H%M%S\"",
")",
"fname",
"=",
"''",
"is_new",
"=",
"False",
"while",
"not",
"is_new",
":",
"oid_len",
"=",
"255",
"-",
"len",
"(",
"'%s--%s.%s'",
"%",
"(",
"otype",
",",
"ts",
",",
"ext",
")",
")",
"fname",
"=",
"'%s-%s-%s.%s'",
"%",
"(",
"otype",
",",
"oid",
"[",
":",
"oid_len",
"]",
",",
"ts",
",",
"ext",
")",
"is_new",
"=",
"True",
"if",
"os",
".",
"path",
".",
"exists",
"(",
"fname",
")",
":",
"is_new",
"=",
"False",
"ts",
"+=",
"'-bck'",
"return",
"fname"
] |
Santize obj name into fname and verify doesn't already exist
|
[
"Santize",
"obj",
"name",
"into",
"fname",
"and",
"verify",
"doesn",
"t",
"already",
"exist"
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L165-L182
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.write_object_to_file
|
def write_object_to_file(self, obj, path='.', filename=None):
"""Convert obj (dict) to json string and write to file"""
output = self.json_dumps(obj) + '\n'
if filename is None:
filename = self.safe_filename(obj['_type'], obj['_id'])
filename = os.path.join(path, filename)
self.pr_inf("Writing to file: " + filename)
with open(filename, 'w') as f:
f.write(output)
# self.pr_dbg("Contents: " + output)
return filename
|
python
|
def write_object_to_file(self, obj, path='.', filename=None):
"""Convert obj (dict) to json string and write to file"""
output = self.json_dumps(obj) + '\n'
if filename is None:
filename = self.safe_filename(obj['_type'], obj['_id'])
filename = os.path.join(path, filename)
self.pr_inf("Writing to file: " + filename)
with open(filename, 'w') as f:
f.write(output)
# self.pr_dbg("Contents: " + output)
return filename
|
[
"def",
"write_object_to_file",
"(",
"self",
",",
"obj",
",",
"path",
"=",
"'.'",
",",
"filename",
"=",
"None",
")",
":",
"output",
"=",
"self",
".",
"json_dumps",
"(",
"obj",
")",
"+",
"'\\n'",
"if",
"filename",
"is",
"None",
":",
"filename",
"=",
"self",
".",
"safe_filename",
"(",
"obj",
"[",
"'_type'",
"]",
",",
"obj",
"[",
"'_id'",
"]",
")",
"filename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"filename",
")",
"self",
".",
"pr_inf",
"(",
"\"Writing to file: \"",
"+",
"filename",
")",
"with",
"open",
"(",
"filename",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"output",
")",
"# self.pr_dbg(\"Contents: \" + output)",
"return",
"filename"
] |
Convert obj (dict) to json string and write to file
|
[
"Convert",
"obj",
"(",
"dict",
")",
"to",
"json",
"string",
"and",
"write",
"to",
"file"
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L184-L194
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.write_pkg_to_file
|
def write_pkg_to_file(self, name, objects, path='.', filename=None):
"""Write a list of related objs to file"""
# Kibana uses an array of docs, do the same
# as opposed to a dict of docs
pkg_objs = []
for _, obj in iteritems(objects):
pkg_objs.append(obj)
sorted_pkg = sorted(pkg_objs, key=lambda k: k['_id'])
output = self.json_dumps(sorted_pkg) + '\n'
if filename is None:
filename = self.safe_filename('Pkg', name)
filename = os.path.join(path, filename)
self.pr_inf("Writing to file: " + filename)
with open(filename, 'w') as f:
f.write(output)
return filename
|
python
|
def write_pkg_to_file(self, name, objects, path='.', filename=None):
"""Write a list of related objs to file"""
# Kibana uses an array of docs, do the same
# as opposed to a dict of docs
pkg_objs = []
for _, obj in iteritems(objects):
pkg_objs.append(obj)
sorted_pkg = sorted(pkg_objs, key=lambda k: k['_id'])
output = self.json_dumps(sorted_pkg) + '\n'
if filename is None:
filename = self.safe_filename('Pkg', name)
filename = os.path.join(path, filename)
self.pr_inf("Writing to file: " + filename)
with open(filename, 'w') as f:
f.write(output)
return filename
|
[
"def",
"write_pkg_to_file",
"(",
"self",
",",
"name",
",",
"objects",
",",
"path",
"=",
"'.'",
",",
"filename",
"=",
"None",
")",
":",
"# Kibana uses an array of docs, do the same",
"# as opposed to a dict of docs",
"pkg_objs",
"=",
"[",
"]",
"for",
"_",
",",
"obj",
"in",
"iteritems",
"(",
"objects",
")",
":",
"pkg_objs",
".",
"append",
"(",
"obj",
")",
"sorted_pkg",
"=",
"sorted",
"(",
"pkg_objs",
",",
"key",
"=",
"lambda",
"k",
":",
"k",
"[",
"'_id'",
"]",
")",
"output",
"=",
"self",
".",
"json_dumps",
"(",
"sorted_pkg",
")",
"+",
"'\\n'",
"if",
"filename",
"is",
"None",
":",
"filename",
"=",
"self",
".",
"safe_filename",
"(",
"'Pkg'",
",",
"name",
")",
"filename",
"=",
"os",
".",
"path",
".",
"join",
"(",
"path",
",",
"filename",
")",
"self",
".",
"pr_inf",
"(",
"\"Writing to file: \"",
"+",
"filename",
")",
"with",
"open",
"(",
"filename",
",",
"'w'",
")",
"as",
"f",
":",
"f",
".",
"write",
"(",
"output",
")",
"return",
"filename"
] |
Write a list of related objs to file
|
[
"Write",
"a",
"list",
"of",
"related",
"objs",
"to",
"file"
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L200-L215
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.get_objects
|
def get_objects(self, search_field, search_val):
"""Return all objects of type (assumes < MAX_HITS)"""
query = ("{ size: " + str(self.max_hits) + ", " +
"query: { filtered: { filter: { " +
search_field + ": { value: \"" + search_val + "\"" +
" } } } } } }")
self.connect_es()
res = self.es.search(index=self.index, body=query)
# self.pr_dbg("%d Hits:" % res['hits']['total'])
objects = {}
for doc in res['hits']['hits']:
objects[doc['_id']] = {}
# To make uploading easier in the future:
# Record all those bits into the backup.
# Mimics how ES returns the result.
# Prevents having to store this in some external, contrived, format
objects[doc['_id']]['_index'] = self.index # also in doc['_index']
objects[doc['_id']]['_type'] = doc['_type']
objects[doc['_id']]['_id'] = doc['_id']
objects[doc['_id']]['_source'] = doc['_source'] # the actual result
return objects
|
python
|
def get_objects(self, search_field, search_val):
"""Return all objects of type (assumes < MAX_HITS)"""
query = ("{ size: " + str(self.max_hits) + ", " +
"query: { filtered: { filter: { " +
search_field + ": { value: \"" + search_val + "\"" +
" } } } } } }")
self.connect_es()
res = self.es.search(index=self.index, body=query)
# self.pr_dbg("%d Hits:" % res['hits']['total'])
objects = {}
for doc in res['hits']['hits']:
objects[doc['_id']] = {}
# To make uploading easier in the future:
# Record all those bits into the backup.
# Mimics how ES returns the result.
# Prevents having to store this in some external, contrived, format
objects[doc['_id']]['_index'] = self.index # also in doc['_index']
objects[doc['_id']]['_type'] = doc['_type']
objects[doc['_id']]['_id'] = doc['_id']
objects[doc['_id']]['_source'] = doc['_source'] # the actual result
return objects
|
[
"def",
"get_objects",
"(",
"self",
",",
"search_field",
",",
"search_val",
")",
":",
"query",
"=",
"(",
"\"{ size: \"",
"+",
"str",
"(",
"self",
".",
"max_hits",
")",
"+",
"\", \"",
"+",
"\"query: { filtered: { filter: { \"",
"+",
"search_field",
"+",
"\": { value: \\\"\"",
"+",
"search_val",
"+",
"\"\\\"\"",
"+",
"\" } } } } } }\"",
")",
"self",
".",
"connect_es",
"(",
")",
"res",
"=",
"self",
".",
"es",
".",
"search",
"(",
"index",
"=",
"self",
".",
"index",
",",
"body",
"=",
"query",
")",
"# self.pr_dbg(\"%d Hits:\" % res['hits']['total'])",
"objects",
"=",
"{",
"}",
"for",
"doc",
"in",
"res",
"[",
"'hits'",
"]",
"[",
"'hits'",
"]",
":",
"objects",
"[",
"doc",
"[",
"'_id'",
"]",
"]",
"=",
"{",
"}",
"# To make uploading easier in the future:",
"# Record all those bits into the backup.",
"# Mimics how ES returns the result.",
"# Prevents having to store this in some external, contrived, format",
"objects",
"[",
"doc",
"[",
"'_id'",
"]",
"]",
"[",
"'_index'",
"]",
"=",
"self",
".",
"index",
"# also in doc['_index']",
"objects",
"[",
"doc",
"[",
"'_id'",
"]",
"]",
"[",
"'_type'",
"]",
"=",
"doc",
"[",
"'_type'",
"]",
"objects",
"[",
"doc",
"[",
"'_id'",
"]",
"]",
"[",
"'_id'",
"]",
"=",
"doc",
"[",
"'_id'",
"]",
"objects",
"[",
"doc",
"[",
"'_id'",
"]",
"]",
"[",
"'_source'",
"]",
"=",
"doc",
"[",
"'_source'",
"]",
"# the actual result",
"return",
"objects"
] |
Return all objects of type (assumes < MAX_HITS)
|
[
"Return",
"all",
"objects",
"of",
"type",
"(",
"assumes",
"<",
"MAX_HITS",
")"
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L217-L237
|
train
|
rfarley3/Kibana
|
kibana/manager.py
|
KibanaManager.get_dashboard_full
|
def get_dashboard_full(self, db_name):
"""Get DB and all objs needed to duplicate it"""
objects = {}
dashboards = self.get_objects("type", "dashboard")
vizs = self.get_objects("type", "visualization")
searches = self.get_objects("type", "search")
if db_name not in dashboards:
return None
self.pr_inf("Found dashboard: " + db_name)
objects[db_name] = dashboards[db_name]
panels = json.loads(dashboards[db_name]['_source']['panelsJSON'])
for panel in panels:
if 'id' not in panel:
continue
pid = panel['id']
if pid in searches:
self.pr_inf("Found search: " + pid)
objects[pid] = searches[pid]
elif pid in vizs:
self.pr_inf("Found vis: " + pid)
objects[pid] = vizs[pid]
emb = vizs[pid].get('_source', {}).get('savedSearchId', None)
if emb is not None and emb not in objects:
if emb not in searches:
self.pr_err('Missing search %s' % emb)
return objects
objects[emb] = searches[emb]
return objects
|
python
|
def get_dashboard_full(self, db_name):
"""Get DB and all objs needed to duplicate it"""
objects = {}
dashboards = self.get_objects("type", "dashboard")
vizs = self.get_objects("type", "visualization")
searches = self.get_objects("type", "search")
if db_name not in dashboards:
return None
self.pr_inf("Found dashboard: " + db_name)
objects[db_name] = dashboards[db_name]
panels = json.loads(dashboards[db_name]['_source']['panelsJSON'])
for panel in panels:
if 'id' not in panel:
continue
pid = panel['id']
if pid in searches:
self.pr_inf("Found search: " + pid)
objects[pid] = searches[pid]
elif pid in vizs:
self.pr_inf("Found vis: " + pid)
objects[pid] = vizs[pid]
emb = vizs[pid].get('_source', {}).get('savedSearchId', None)
if emb is not None and emb not in objects:
if emb not in searches:
self.pr_err('Missing search %s' % emb)
return objects
objects[emb] = searches[emb]
return objects
|
[
"def",
"get_dashboard_full",
"(",
"self",
",",
"db_name",
")",
":",
"objects",
"=",
"{",
"}",
"dashboards",
"=",
"self",
".",
"get_objects",
"(",
"\"type\"",
",",
"\"dashboard\"",
")",
"vizs",
"=",
"self",
".",
"get_objects",
"(",
"\"type\"",
",",
"\"visualization\"",
")",
"searches",
"=",
"self",
".",
"get_objects",
"(",
"\"type\"",
",",
"\"search\"",
")",
"if",
"db_name",
"not",
"in",
"dashboards",
":",
"return",
"None",
"self",
".",
"pr_inf",
"(",
"\"Found dashboard: \"",
"+",
"db_name",
")",
"objects",
"[",
"db_name",
"]",
"=",
"dashboards",
"[",
"db_name",
"]",
"panels",
"=",
"json",
".",
"loads",
"(",
"dashboards",
"[",
"db_name",
"]",
"[",
"'_source'",
"]",
"[",
"'panelsJSON'",
"]",
")",
"for",
"panel",
"in",
"panels",
":",
"if",
"'id'",
"not",
"in",
"panel",
":",
"continue",
"pid",
"=",
"panel",
"[",
"'id'",
"]",
"if",
"pid",
"in",
"searches",
":",
"self",
".",
"pr_inf",
"(",
"\"Found search: \"",
"+",
"pid",
")",
"objects",
"[",
"pid",
"]",
"=",
"searches",
"[",
"pid",
"]",
"elif",
"pid",
"in",
"vizs",
":",
"self",
".",
"pr_inf",
"(",
"\"Found vis: \"",
"+",
"pid",
")",
"objects",
"[",
"pid",
"]",
"=",
"vizs",
"[",
"pid",
"]",
"emb",
"=",
"vizs",
"[",
"pid",
"]",
".",
"get",
"(",
"'_source'",
",",
"{",
"}",
")",
".",
"get",
"(",
"'savedSearchId'",
",",
"None",
")",
"if",
"emb",
"is",
"not",
"None",
"and",
"emb",
"not",
"in",
"objects",
":",
"if",
"emb",
"not",
"in",
"searches",
":",
"self",
".",
"pr_err",
"(",
"'Missing search %s'",
"%",
"emb",
")",
"return",
"objects",
"objects",
"[",
"emb",
"]",
"=",
"searches",
"[",
"emb",
"]",
"return",
"objects"
] |
Get DB and all objs needed to duplicate it
|
[
"Get",
"DB",
"and",
"all",
"objs",
"needed",
"to",
"duplicate",
"it"
] |
3df1e13be18edfb39ec173d8d2bbe9e90be61022
|
https://github.com/rfarley3/Kibana/blob/3df1e13be18edfb39ec173d8d2bbe9e90be61022/kibana/manager.py#L255-L282
|
train
|
zetaops/zengine
|
zengine/lib/camunda_parser.py
|
CamundaProcessParser.parse_node
|
def parse_node(self, node):
"""
Overrides ProcessParser.parse_node
Parses and attaches the inputOutput tags that created by Camunda Modeller
Args:
node: xml task node
Returns:
TaskSpec
"""
spec = super(CamundaProcessParser, self).parse_node(node)
spec.data = self._parse_input_data(node)
spec.data['lane_data'] = self._get_lane_properties(node)
spec.defines = spec.data
service_class = node.get(full_attr('assignee'))
if service_class:
self.parsed_nodes[node.get('id')].service_class = node.get(full_attr('assignee'))
return spec
|
python
|
def parse_node(self, node):
"""
Overrides ProcessParser.parse_node
Parses and attaches the inputOutput tags that created by Camunda Modeller
Args:
node: xml task node
Returns:
TaskSpec
"""
spec = super(CamundaProcessParser, self).parse_node(node)
spec.data = self._parse_input_data(node)
spec.data['lane_data'] = self._get_lane_properties(node)
spec.defines = spec.data
service_class = node.get(full_attr('assignee'))
if service_class:
self.parsed_nodes[node.get('id')].service_class = node.get(full_attr('assignee'))
return spec
|
[
"def",
"parse_node",
"(",
"self",
",",
"node",
")",
":",
"spec",
"=",
"super",
"(",
"CamundaProcessParser",
",",
"self",
")",
".",
"parse_node",
"(",
"node",
")",
"spec",
".",
"data",
"=",
"self",
".",
"_parse_input_data",
"(",
"node",
")",
"spec",
".",
"data",
"[",
"'lane_data'",
"]",
"=",
"self",
".",
"_get_lane_properties",
"(",
"node",
")",
"spec",
".",
"defines",
"=",
"spec",
".",
"data",
"service_class",
"=",
"node",
".",
"get",
"(",
"full_attr",
"(",
"'assignee'",
")",
")",
"if",
"service_class",
":",
"self",
".",
"parsed_nodes",
"[",
"node",
".",
"get",
"(",
"'id'",
")",
"]",
".",
"service_class",
"=",
"node",
".",
"get",
"(",
"full_attr",
"(",
"'assignee'",
")",
")",
"return",
"spec"
] |
Overrides ProcessParser.parse_node
Parses and attaches the inputOutput tags that created by Camunda Modeller
Args:
node: xml task node
Returns:
TaskSpec
|
[
"Overrides",
"ProcessParser",
".",
"parse_node",
"Parses",
"and",
"attaches",
"the",
"inputOutput",
"tags",
"that",
"created",
"by",
"Camunda",
"Modeller"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/lib/camunda_parser.py#L47-L64
|
train
|
zetaops/zengine
|
zengine/lib/camunda_parser.py
|
CamundaProcessParser._get_description
|
def _get_description(self):
"""
Tries to get WF description from 'collabration' or 'process' or 'pariticipant'
Returns:
"""
ns = {'ns': '{%s}' % BPMN_MODEL_NS}
desc = (
self.doc_xpath('.//{ns}collaboration/{ns}documentation'.format(**ns)) or
self.doc_xpath('.//{ns}process/{ns}documentation'.format(**ns)) or
self.doc_xpath('.//{ns}collaboration/{ns}participant/{ns}documentation'.format(**ns))
)
if desc:
return desc[0].findtext('.')
|
python
|
def _get_description(self):
"""
Tries to get WF description from 'collabration' or 'process' or 'pariticipant'
Returns:
"""
ns = {'ns': '{%s}' % BPMN_MODEL_NS}
desc = (
self.doc_xpath('.//{ns}collaboration/{ns}documentation'.format(**ns)) or
self.doc_xpath('.//{ns}process/{ns}documentation'.format(**ns)) or
self.doc_xpath('.//{ns}collaboration/{ns}participant/{ns}documentation'.format(**ns))
)
if desc:
return desc[0].findtext('.')
|
[
"def",
"_get_description",
"(",
"self",
")",
":",
"ns",
"=",
"{",
"'ns'",
":",
"'{%s}'",
"%",
"BPMN_MODEL_NS",
"}",
"desc",
"=",
"(",
"self",
".",
"doc_xpath",
"(",
"'.//{ns}collaboration/{ns}documentation'",
".",
"format",
"(",
"*",
"*",
"ns",
")",
")",
"or",
"self",
".",
"doc_xpath",
"(",
"'.//{ns}process/{ns}documentation'",
".",
"format",
"(",
"*",
"*",
"ns",
")",
")",
"or",
"self",
".",
"doc_xpath",
"(",
"'.//{ns}collaboration/{ns}participant/{ns}documentation'",
".",
"format",
"(",
"*",
"*",
"ns",
")",
")",
")",
"if",
"desc",
":",
"return",
"desc",
"[",
"0",
"]",
".",
"findtext",
"(",
"'.'",
")"
] |
Tries to get WF description from 'collabration' or 'process' or 'pariticipant'
Returns:
|
[
"Tries",
"to",
"get",
"WF",
"description",
"from",
"collabration",
"or",
"process",
"or",
"pariticipant",
"Returns",
":"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/lib/camunda_parser.py#L66-L79
|
train
|
zetaops/zengine
|
zengine/lib/camunda_parser.py
|
CamundaProcessParser.get_name
|
def get_name(self):
"""
Tries to get WF name from 'process' or 'collobration' or 'pariticipant'
Returns:
str. WF name.
"""
ns = {'ns': '{%s}' % BPMN_MODEL_NS}
for path in ('.//{ns}process',
'.//{ns}collaboration',
'.//{ns}collaboration/{ns}participant/'):
tag = self.doc_xpath(path.format(**ns))
if tag:
name = tag[0].get('name')
if name:
return name
return self.get_id()
|
python
|
def get_name(self):
"""
Tries to get WF name from 'process' or 'collobration' or 'pariticipant'
Returns:
str. WF name.
"""
ns = {'ns': '{%s}' % BPMN_MODEL_NS}
for path in ('.//{ns}process',
'.//{ns}collaboration',
'.//{ns}collaboration/{ns}participant/'):
tag = self.doc_xpath(path.format(**ns))
if tag:
name = tag[0].get('name')
if name:
return name
return self.get_id()
|
[
"def",
"get_name",
"(",
"self",
")",
":",
"ns",
"=",
"{",
"'ns'",
":",
"'{%s}'",
"%",
"BPMN_MODEL_NS",
"}",
"for",
"path",
"in",
"(",
"'.//{ns}process'",
",",
"'.//{ns}collaboration'",
",",
"'.//{ns}collaboration/{ns}participant/'",
")",
":",
"tag",
"=",
"self",
".",
"doc_xpath",
"(",
"path",
".",
"format",
"(",
"*",
"*",
"ns",
")",
")",
"if",
"tag",
":",
"name",
"=",
"tag",
"[",
"0",
"]",
".",
"get",
"(",
"'name'",
")",
"if",
"name",
":",
"return",
"name",
"return",
"self",
".",
"get_id",
"(",
")"
] |
Tries to get WF name from 'process' or 'collobration' or 'pariticipant'
Returns:
str. WF name.
|
[
"Tries",
"to",
"get",
"WF",
"name",
"from",
"process",
"or",
"collobration",
"or",
"pariticipant"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/lib/camunda_parser.py#L91-L107
|
train
|
zetaops/zengine
|
zengine/lib/camunda_parser.py
|
CamundaProcessParser._parse_input_data
|
def _parse_input_data(self, node):
"""
Parses inputOutput part camunda modeller extensions.
Args:
node: SpiffWorkflow Node object.
Returns:
Data dict.
"""
data = DotDict()
try:
for nod in self._get_input_nodes(node):
data.update(self._parse_input_node(nod))
except Exception as e:
log.exception("Error while processing node: %s" % node)
return data
|
python
|
def _parse_input_data(self, node):
"""
Parses inputOutput part camunda modeller extensions.
Args:
node: SpiffWorkflow Node object.
Returns:
Data dict.
"""
data = DotDict()
try:
for nod in self._get_input_nodes(node):
data.update(self._parse_input_node(nod))
except Exception as e:
log.exception("Error while processing node: %s" % node)
return data
|
[
"def",
"_parse_input_data",
"(",
"self",
",",
"node",
")",
":",
"data",
"=",
"DotDict",
"(",
")",
"try",
":",
"for",
"nod",
"in",
"self",
".",
"_get_input_nodes",
"(",
"node",
")",
":",
"data",
".",
"update",
"(",
"self",
".",
"_parse_input_node",
"(",
"nod",
")",
")",
"except",
"Exception",
"as",
"e",
":",
"log",
".",
"exception",
"(",
"\"Error while processing node: %s\"",
"%",
"node",
")",
"return",
"data"
] |
Parses inputOutput part camunda modeller extensions.
Args:
node: SpiffWorkflow Node object.
Returns:
Data dict.
|
[
"Parses",
"inputOutput",
"part",
"camunda",
"modeller",
"extensions",
".",
"Args",
":",
"node",
":",
"SpiffWorkflow",
"Node",
"object",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/lib/camunda_parser.py#L109-L124
|
train
|
zetaops/zengine
|
zengine/lib/camunda_parser.py
|
CamundaProcessParser._get_lane_properties
|
def _get_lane_properties(self, node):
"""
Parses the given XML node
Args:
node (xml): XML node.
.. code-block:: xml
<bpmn2:lane id="Lane_8" name="Lane 8">
<bpmn2:extensionElements>
<camunda:properties>
<camunda:property value="foo,bar" name="perms"/>
</camunda:properties>
</bpmn2:extensionElements>
</bpmn2:lane>
Returns:
{'perms': 'foo,bar'}
"""
lane_name = self.get_lane(node.get('id'))
lane_data = {'name': lane_name}
for a in self.xpath(".//bpmn:lane[@name='%s']/*/*/" % lane_name):
lane_data[a.attrib['name']] = a.attrib['value'].strip()
return lane_data
|
python
|
def _get_lane_properties(self, node):
"""
Parses the given XML node
Args:
node (xml): XML node.
.. code-block:: xml
<bpmn2:lane id="Lane_8" name="Lane 8">
<bpmn2:extensionElements>
<camunda:properties>
<camunda:property value="foo,bar" name="perms"/>
</camunda:properties>
</bpmn2:extensionElements>
</bpmn2:lane>
Returns:
{'perms': 'foo,bar'}
"""
lane_name = self.get_lane(node.get('id'))
lane_data = {'name': lane_name}
for a in self.xpath(".//bpmn:lane[@name='%s']/*/*/" % lane_name):
lane_data[a.attrib['name']] = a.attrib['value'].strip()
return lane_data
|
[
"def",
"_get_lane_properties",
"(",
"self",
",",
"node",
")",
":",
"lane_name",
"=",
"self",
".",
"get_lane",
"(",
"node",
".",
"get",
"(",
"'id'",
")",
")",
"lane_data",
"=",
"{",
"'name'",
":",
"lane_name",
"}",
"for",
"a",
"in",
"self",
".",
"xpath",
"(",
"\".//bpmn:lane[@name='%s']/*/*/\"",
"%",
"lane_name",
")",
":",
"lane_data",
"[",
"a",
".",
"attrib",
"[",
"'name'",
"]",
"]",
"=",
"a",
".",
"attrib",
"[",
"'value'",
"]",
".",
"strip",
"(",
")",
"return",
"lane_data"
] |
Parses the given XML node
Args:
node (xml): XML node.
.. code-block:: xml
<bpmn2:lane id="Lane_8" name="Lane 8">
<bpmn2:extensionElements>
<camunda:properties>
<camunda:property value="foo,bar" name="perms"/>
</camunda:properties>
</bpmn2:extensionElements>
</bpmn2:lane>
Returns:
{'perms': 'foo,bar'}
|
[
"Parses",
"the",
"given",
"XML",
"node"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/lib/camunda_parser.py#L136-L160
|
train
|
zetaops/zengine
|
zengine/lib/camunda_parser.py
|
CamundaProcessParser._parse_input_node
|
def _parse_input_node(cls, node):
"""
:param node: xml node
:return: dict
"""
data = {}
child = node.getchildren()
if not child and node.get('name'):
val = node.text
elif child: # if tag = "{http://activiti.org/bpmn}script" then data_typ = 'script'
data_typ = child[0].tag.split('}')[1]
val = getattr(cls, '_parse_%s' % data_typ)(child[0])
data[node.get('name')] = val
return data
|
python
|
def _parse_input_node(cls, node):
"""
:param node: xml node
:return: dict
"""
data = {}
child = node.getchildren()
if not child and node.get('name'):
val = node.text
elif child: # if tag = "{http://activiti.org/bpmn}script" then data_typ = 'script'
data_typ = child[0].tag.split('}')[1]
val = getattr(cls, '_parse_%s' % data_typ)(child[0])
data[node.get('name')] = val
return data
|
[
"def",
"_parse_input_node",
"(",
"cls",
",",
"node",
")",
":",
"data",
"=",
"{",
"}",
"child",
"=",
"node",
".",
"getchildren",
"(",
")",
"if",
"not",
"child",
"and",
"node",
".",
"get",
"(",
"'name'",
")",
":",
"val",
"=",
"node",
".",
"text",
"elif",
"child",
":",
"# if tag = \"{http://activiti.org/bpmn}script\" then data_typ = 'script'",
"data_typ",
"=",
"child",
"[",
"0",
"]",
".",
"tag",
".",
"split",
"(",
"'}'",
")",
"[",
"1",
"]",
"val",
"=",
"getattr",
"(",
"cls",
",",
"'_parse_%s'",
"%",
"data_typ",
")",
"(",
"child",
"[",
"0",
"]",
")",
"data",
"[",
"node",
".",
"get",
"(",
"'name'",
")",
"]",
"=",
"val",
"return",
"data"
] |
:param node: xml node
:return: dict
|
[
":",
"param",
"node",
":",
"xml",
"node",
":",
"return",
":",
"dict"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/lib/camunda_parser.py#L163-L176
|
train
|
zetaops/zengine
|
zengine/lib/camunda_parser.py
|
InMemoryPackager.package_in_memory
|
def package_in_memory(cls, workflow_name, workflow_files):
"""
Generates wf packages from workflow diagrams.
Args:
workflow_name: Name of wf
workflow_files: Diagram file.
Returns:
Workflow package (file like) object
"""
s = StringIO()
p = cls(s, workflow_name, meta_data=[])
p.add_bpmn_files_by_glob(workflow_files)
p.create_package()
return s.getvalue()
|
python
|
def package_in_memory(cls, workflow_name, workflow_files):
"""
Generates wf packages from workflow diagrams.
Args:
workflow_name: Name of wf
workflow_files: Diagram file.
Returns:
Workflow package (file like) object
"""
s = StringIO()
p = cls(s, workflow_name, meta_data=[])
p.add_bpmn_files_by_glob(workflow_files)
p.create_package()
return s.getvalue()
|
[
"def",
"package_in_memory",
"(",
"cls",
",",
"workflow_name",
",",
"workflow_files",
")",
":",
"s",
"=",
"StringIO",
"(",
")",
"p",
"=",
"cls",
"(",
"s",
",",
"workflow_name",
",",
"meta_data",
"=",
"[",
"]",
")",
"p",
".",
"add_bpmn_files_by_glob",
"(",
"workflow_files",
")",
"p",
".",
"create_package",
"(",
")",
"return",
"s",
".",
"getvalue",
"(",
")"
] |
Generates wf packages from workflow diagrams.
Args:
workflow_name: Name of wf
workflow_files: Diagram file.
Returns:
Workflow package (file like) object
|
[
"Generates",
"wf",
"packages",
"from",
"workflow",
"diagrams",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/lib/camunda_parser.py#L210-L225
|
train
|
cimm-kzn/CGRtools
|
CGRtools/preparer.py
|
CGRpreparer.compose
|
def compose(self, data):
"""
condense reaction container to CGR. see init for details about cgr_type
:param data: ReactionContainer
:return: CGRContainer
"""
g = self.__separate(data) if self.__cgr_type in (1, 2, 3, 4, 5, 6) else self.__condense(data)
g.meta.update(data.meta)
return g
|
python
|
def compose(self, data):
"""
condense reaction container to CGR. see init for details about cgr_type
:param data: ReactionContainer
:return: CGRContainer
"""
g = self.__separate(data) if self.__cgr_type in (1, 2, 3, 4, 5, 6) else self.__condense(data)
g.meta.update(data.meta)
return g
|
[
"def",
"compose",
"(",
"self",
",",
"data",
")",
":",
"g",
"=",
"self",
".",
"__separate",
"(",
"data",
")",
"if",
"self",
".",
"__cgr_type",
"in",
"(",
"1",
",",
"2",
",",
"3",
",",
"4",
",",
"5",
",",
"6",
")",
"else",
"self",
".",
"__condense",
"(",
"data",
")",
"g",
".",
"meta",
".",
"update",
"(",
"data",
".",
"meta",
")",
"return",
"g"
] |
condense reaction container to CGR. see init for details about cgr_type
:param data: ReactionContainer
:return: CGRContainer
|
[
"condense",
"reaction",
"container",
"to",
"CGR",
".",
"see",
"init",
"for",
"details",
"about",
"cgr_type"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/preparer.py#L49-L58
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.add_atom
|
def add_atom(self, atom, _map=None):
"""
new atom addition
"""
if _map is None:
_map = max(self, default=0) + 1
elif _map in self._node:
raise KeyError('atom with same number exists')
attr_dict = self.node_attr_dict_factory()
if isinstance(atom, str):
attr_dict.element = atom
elif isinstance(atom, int):
attr_dict.element = elements_list[atom - 1]
else:
attr_dict.update(atom)
self._adj[_map] = self.adjlist_inner_dict_factory()
self._node[_map] = attr_dict
self.flush_cache()
return _map
|
python
|
def add_atom(self, atom, _map=None):
"""
new atom addition
"""
if _map is None:
_map = max(self, default=0) + 1
elif _map in self._node:
raise KeyError('atom with same number exists')
attr_dict = self.node_attr_dict_factory()
if isinstance(atom, str):
attr_dict.element = atom
elif isinstance(atom, int):
attr_dict.element = elements_list[atom - 1]
else:
attr_dict.update(atom)
self._adj[_map] = self.adjlist_inner_dict_factory()
self._node[_map] = attr_dict
self.flush_cache()
return _map
|
[
"def",
"add_atom",
"(",
"self",
",",
"atom",
",",
"_map",
"=",
"None",
")",
":",
"if",
"_map",
"is",
"None",
":",
"_map",
"=",
"max",
"(",
"self",
",",
"default",
"=",
"0",
")",
"+",
"1",
"elif",
"_map",
"in",
"self",
".",
"_node",
":",
"raise",
"KeyError",
"(",
"'atom with same number exists'",
")",
"attr_dict",
"=",
"self",
".",
"node_attr_dict_factory",
"(",
")",
"if",
"isinstance",
"(",
"atom",
",",
"str",
")",
":",
"attr_dict",
".",
"element",
"=",
"atom",
"elif",
"isinstance",
"(",
"atom",
",",
"int",
")",
":",
"attr_dict",
".",
"element",
"=",
"elements_list",
"[",
"atom",
"-",
"1",
"]",
"else",
":",
"attr_dict",
".",
"update",
"(",
"atom",
")",
"self",
".",
"_adj",
"[",
"_map",
"]",
"=",
"self",
".",
"adjlist_inner_dict_factory",
"(",
")",
"self",
".",
"_node",
"[",
"_map",
"]",
"=",
"attr_dict",
"self",
".",
"flush_cache",
"(",
")",
"return",
"_map"
] |
new atom addition
|
[
"new",
"atom",
"addition"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L71-L91
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.add_bond
|
def add_bond(self, atom1, atom2, bond):
"""
implementation of bond addition
"""
if atom1 == atom2:
raise KeyError('atom loops impossible')
if atom1 not in self._node or atom2 not in self._node:
raise KeyError('atoms not found')
if atom1 in self._adj[atom2]:
raise KeyError('atoms already bonded')
attr_dict = self.edge_attr_dict_factory()
if isinstance(bond, int):
attr_dict.order = bond
else:
attr_dict.update(bond)
self._adj[atom1][atom2] = self._adj[atom2][atom1] = attr_dict
self.flush_cache()
|
python
|
def add_bond(self, atom1, atom2, bond):
"""
implementation of bond addition
"""
if atom1 == atom2:
raise KeyError('atom loops impossible')
if atom1 not in self._node or atom2 not in self._node:
raise KeyError('atoms not found')
if atom1 in self._adj[atom2]:
raise KeyError('atoms already bonded')
attr_dict = self.edge_attr_dict_factory()
if isinstance(bond, int):
attr_dict.order = bond
else:
attr_dict.update(bond)
self._adj[atom1][atom2] = self._adj[atom2][atom1] = attr_dict
self.flush_cache()
|
[
"def",
"add_bond",
"(",
"self",
",",
"atom1",
",",
"atom2",
",",
"bond",
")",
":",
"if",
"atom1",
"==",
"atom2",
":",
"raise",
"KeyError",
"(",
"'atom loops impossible'",
")",
"if",
"atom1",
"not",
"in",
"self",
".",
"_node",
"or",
"atom2",
"not",
"in",
"self",
".",
"_node",
":",
"raise",
"KeyError",
"(",
"'atoms not found'",
")",
"if",
"atom1",
"in",
"self",
".",
"_adj",
"[",
"atom2",
"]",
":",
"raise",
"KeyError",
"(",
"'atoms already bonded'",
")",
"attr_dict",
"=",
"self",
".",
"edge_attr_dict_factory",
"(",
")",
"if",
"isinstance",
"(",
"bond",
",",
"int",
")",
":",
"attr_dict",
".",
"order",
"=",
"bond",
"else",
":",
"attr_dict",
".",
"update",
"(",
"bond",
")",
"self",
".",
"_adj",
"[",
"atom1",
"]",
"[",
"atom2",
"]",
"=",
"self",
".",
"_adj",
"[",
"atom2",
"]",
"[",
"atom1",
"]",
"=",
"attr_dict",
"self",
".",
"flush_cache",
"(",
")"
] |
implementation of bond addition
|
[
"implementation",
"of",
"bond",
"addition"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L93-L111
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.delete_bond
|
def delete_bond(self, n, m):
"""
implementation of bond removing
"""
self.remove_edge(n, m)
self.flush_cache()
|
python
|
def delete_bond(self, n, m):
"""
implementation of bond removing
"""
self.remove_edge(n, m)
self.flush_cache()
|
[
"def",
"delete_bond",
"(",
"self",
",",
"n",
",",
"m",
")",
":",
"self",
".",
"remove_edge",
"(",
"n",
",",
"m",
")",
"self",
".",
"flush_cache",
"(",
")"
] |
implementation of bond removing
|
[
"implementation",
"of",
"bond",
"removing"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L120-L125
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.environment
|
def environment(self, atom):
"""
pairs of (bond, atom) connected to atom
:param atom: number
:return: list
"""
return tuple((bond, self._node[n]) for n, bond in self._adj[atom].items())
|
python
|
def environment(self, atom):
"""
pairs of (bond, atom) connected to atom
:param atom: number
:return: list
"""
return tuple((bond, self._node[n]) for n, bond in self._adj[atom].items())
|
[
"def",
"environment",
"(",
"self",
",",
"atom",
")",
":",
"return",
"tuple",
"(",
"(",
"bond",
",",
"self",
".",
"_node",
"[",
"n",
"]",
")",
"for",
"n",
",",
"bond",
"in",
"self",
".",
"_adj",
"[",
"atom",
"]",
".",
"items",
"(",
")",
")"
] |
pairs of (bond, atom) connected to atom
:param atom: number
:return: list
|
[
"pairs",
"of",
"(",
"bond",
"atom",
")",
"connected",
"to",
"atom"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L128-L135
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.substructure
|
def substructure(self, atoms, meta=False, as_view=True):
"""
create substructure containing atoms from nbunch list
:param atoms: list of atoms numbers of substructure
:param meta: if True metadata will be copied to substructure
:param as_view: If True, the returned graph-view provides a read-only view
of the original structure scaffold without actually copying any data.
"""
s = self.subgraph(atoms)
if as_view:
s.add_atom = s.add_bond = s.delete_atom = s.delete_bond = frozen # more informative exception
return s
s = s.copy()
if not meta:
s.graph.clear()
return s
|
python
|
def substructure(self, atoms, meta=False, as_view=True):
"""
create substructure containing atoms from nbunch list
:param atoms: list of atoms numbers of substructure
:param meta: if True metadata will be copied to substructure
:param as_view: If True, the returned graph-view provides a read-only view
of the original structure scaffold without actually copying any data.
"""
s = self.subgraph(atoms)
if as_view:
s.add_atom = s.add_bond = s.delete_atom = s.delete_bond = frozen # more informative exception
return s
s = s.copy()
if not meta:
s.graph.clear()
return s
|
[
"def",
"substructure",
"(",
"self",
",",
"atoms",
",",
"meta",
"=",
"False",
",",
"as_view",
"=",
"True",
")",
":",
"s",
"=",
"self",
".",
"subgraph",
"(",
"atoms",
")",
"if",
"as_view",
":",
"s",
".",
"add_atom",
"=",
"s",
".",
"add_bond",
"=",
"s",
".",
"delete_atom",
"=",
"s",
".",
"delete_bond",
"=",
"frozen",
"# more informative exception",
"return",
"s",
"s",
"=",
"s",
".",
"copy",
"(",
")",
"if",
"not",
"meta",
":",
"s",
".",
"graph",
".",
"clear",
"(",
")",
"return",
"s"
] |
create substructure containing atoms from nbunch list
:param atoms: list of atoms numbers of substructure
:param meta: if True metadata will be copied to substructure
:param as_view: If True, the returned graph-view provides a read-only view
of the original structure scaffold without actually copying any data.
|
[
"create",
"substructure",
"containing",
"atoms",
"from",
"nbunch",
"list"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L137-L153
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.augmented_substructure
|
def augmented_substructure(self, atoms, dante=False, deep=1, meta=False, as_view=True):
"""
create substructure containing atoms and their neighbors
:param atoms: list of core atoms in graph
:param dante: if True return list of graphs containing atoms, atoms + first circle, atoms + 1st + 2nd,
etc up to deep or while new nodes available
:param deep: number of bonds between atoms and neighbors
:param meta: copy metadata to each substructure
:param as_view: If True, the returned graph-view provides a read-only view
of the original graph without actually copying any data
"""
nodes = [set(atoms)]
for i in range(deep):
n = {y for x in nodes[-1] for y in self._adj[x]} | nodes[-1]
if n in nodes:
break
nodes.append(n)
if dante:
return [self.substructure(a, meta, as_view) for a in nodes]
else:
return self.substructure(nodes[-1], meta, as_view)
|
python
|
def augmented_substructure(self, atoms, dante=False, deep=1, meta=False, as_view=True):
"""
create substructure containing atoms and their neighbors
:param atoms: list of core atoms in graph
:param dante: if True return list of graphs containing atoms, atoms + first circle, atoms + 1st + 2nd,
etc up to deep or while new nodes available
:param deep: number of bonds between atoms and neighbors
:param meta: copy metadata to each substructure
:param as_view: If True, the returned graph-view provides a read-only view
of the original graph without actually copying any data
"""
nodes = [set(atoms)]
for i in range(deep):
n = {y for x in nodes[-1] for y in self._adj[x]} | nodes[-1]
if n in nodes:
break
nodes.append(n)
if dante:
return [self.substructure(a, meta, as_view) for a in nodes]
else:
return self.substructure(nodes[-1], meta, as_view)
|
[
"def",
"augmented_substructure",
"(",
"self",
",",
"atoms",
",",
"dante",
"=",
"False",
",",
"deep",
"=",
"1",
",",
"meta",
"=",
"False",
",",
"as_view",
"=",
"True",
")",
":",
"nodes",
"=",
"[",
"set",
"(",
"atoms",
")",
"]",
"for",
"i",
"in",
"range",
"(",
"deep",
")",
":",
"n",
"=",
"{",
"y",
"for",
"x",
"in",
"nodes",
"[",
"-",
"1",
"]",
"for",
"y",
"in",
"self",
".",
"_adj",
"[",
"x",
"]",
"}",
"|",
"nodes",
"[",
"-",
"1",
"]",
"if",
"n",
"in",
"nodes",
":",
"break",
"nodes",
".",
"append",
"(",
"n",
")",
"if",
"dante",
":",
"return",
"[",
"self",
".",
"substructure",
"(",
"a",
",",
"meta",
",",
"as_view",
")",
"for",
"a",
"in",
"nodes",
"]",
"else",
":",
"return",
"self",
".",
"substructure",
"(",
"nodes",
"[",
"-",
"1",
"]",
",",
"meta",
",",
"as_view",
")"
] |
create substructure containing atoms and their neighbors
:param atoms: list of core atoms in graph
:param dante: if True return list of graphs containing atoms, atoms + first circle, atoms + 1st + 2nd,
etc up to deep or while new nodes available
:param deep: number of bonds between atoms and neighbors
:param meta: copy metadata to each substructure
:param as_view: If True, the returned graph-view provides a read-only view
of the original graph without actually copying any data
|
[
"create",
"substructure",
"containing",
"atoms",
"and",
"their",
"neighbors"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L155-L176
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.split
|
def split(self, meta=False):
"""
split disconnected structure to connected substructures
:param meta: copy metadata to each substructure
:return: list of substructures
"""
return [self.substructure(c, meta, False) for c in connected_components(self)]
|
python
|
def split(self, meta=False):
"""
split disconnected structure to connected substructures
:param meta: copy metadata to each substructure
:return: list of substructures
"""
return [self.substructure(c, meta, False) for c in connected_components(self)]
|
[
"def",
"split",
"(",
"self",
",",
"meta",
"=",
"False",
")",
":",
"return",
"[",
"self",
".",
"substructure",
"(",
"c",
",",
"meta",
",",
"False",
")",
"for",
"c",
"in",
"connected_components",
"(",
"self",
")",
"]"
] |
split disconnected structure to connected substructures
:param meta: copy metadata to each substructure
:return: list of substructures
|
[
"split",
"disconnected",
"structure",
"to",
"connected",
"substructures"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L182-L189
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer.bonds
|
def bonds(self):
"""
iterate other all bonds
"""
seen = set()
for n, m_bond in self._adj.items():
seen.add(n)
for m, bond in m_bond.items():
if m not in seen:
yield n, m, bond
|
python
|
def bonds(self):
"""
iterate other all bonds
"""
seen = set()
for n, m_bond in self._adj.items():
seen.add(n)
for m, bond in m_bond.items():
if m not in seen:
yield n, m, bond
|
[
"def",
"bonds",
"(",
"self",
")",
":",
"seen",
"=",
"set",
"(",
")",
"for",
"n",
",",
"m_bond",
"in",
"self",
".",
"_adj",
".",
"items",
"(",
")",
":",
"seen",
".",
"add",
"(",
"n",
")",
"for",
"m",
",",
"bond",
"in",
"m_bond",
".",
"items",
"(",
")",
":",
"if",
"m",
"not",
"in",
"seen",
":",
"yield",
"n",
",",
"m",
",",
"bond"
] |
iterate other all bonds
|
[
"iterate",
"other",
"all",
"bonds"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L218-L227
|
train
|
cimm-kzn/CGRtools
|
CGRtools/containers/common.py
|
BaseContainer._get_subclass
|
def _get_subclass(name):
"""
need for cyclic import solving
"""
return next(x for x in BaseContainer.__subclasses__() if x.__name__ == name)
|
python
|
def _get_subclass(name):
"""
need for cyclic import solving
"""
return next(x for x in BaseContainer.__subclasses__() if x.__name__ == name)
|
[
"def",
"_get_subclass",
"(",
"name",
")",
":",
"return",
"next",
"(",
"x",
"for",
"x",
"in",
"BaseContainer",
".",
"__subclasses__",
"(",
")",
"if",
"x",
".",
"__name__",
"==",
"name",
")"
] |
need for cyclic import solving
|
[
"need",
"for",
"cyclic",
"import",
"solving"
] |
15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34
|
https://github.com/cimm-kzn/CGRtools/blob/15a19b04f6e4e1d0dab8e0d32a0877c7f7d70f34/CGRtools/containers/common.py#L230-L234
|
train
|
GoogleCloudPlatform/httplib2shim
|
httplib2shim/__init__.py
|
_default_make_pool
|
def _default_make_pool(http, proxy_info):
"""Creates a urllib3.PoolManager object that has SSL verification enabled
and uses the certifi certificates."""
if not http.ca_certs:
http.ca_certs = _certifi_where_for_ssl_version()
ssl_disabled = http.disable_ssl_certificate_validation
cert_reqs = 'CERT_REQUIRED' if http.ca_certs and not ssl_disabled else None
if isinstance(proxy_info, collections.Callable):
proxy_info = proxy_info()
if proxy_info:
if proxy_info.proxy_user and proxy_info.proxy_pass:
proxy_url = 'http://{}:{}@{}:{}/'.format(
proxy_info.proxy_user, proxy_info.proxy_pass,
proxy_info.proxy_host, proxy_info.proxy_port,
)
proxy_headers = urllib3.util.request.make_headers(
proxy_basic_auth='{}:{}'.format(
proxy_info.proxy_user, proxy_info.proxy_pass,
)
)
else:
proxy_url = 'http://{}:{}/'.format(
proxy_info.proxy_host, proxy_info.proxy_port,
)
proxy_headers = {}
return urllib3.ProxyManager(
proxy_url=proxy_url,
proxy_headers=proxy_headers,
ca_certs=http.ca_certs,
cert_reqs=cert_reqs,
)
return urllib3.PoolManager(
ca_certs=http.ca_certs,
cert_reqs=cert_reqs,
)
|
python
|
def _default_make_pool(http, proxy_info):
"""Creates a urllib3.PoolManager object that has SSL verification enabled
and uses the certifi certificates."""
if not http.ca_certs:
http.ca_certs = _certifi_where_for_ssl_version()
ssl_disabled = http.disable_ssl_certificate_validation
cert_reqs = 'CERT_REQUIRED' if http.ca_certs and not ssl_disabled else None
if isinstance(proxy_info, collections.Callable):
proxy_info = proxy_info()
if proxy_info:
if proxy_info.proxy_user and proxy_info.proxy_pass:
proxy_url = 'http://{}:{}@{}:{}/'.format(
proxy_info.proxy_user, proxy_info.proxy_pass,
proxy_info.proxy_host, proxy_info.proxy_port,
)
proxy_headers = urllib3.util.request.make_headers(
proxy_basic_auth='{}:{}'.format(
proxy_info.proxy_user, proxy_info.proxy_pass,
)
)
else:
proxy_url = 'http://{}:{}/'.format(
proxy_info.proxy_host, proxy_info.proxy_port,
)
proxy_headers = {}
return urllib3.ProxyManager(
proxy_url=proxy_url,
proxy_headers=proxy_headers,
ca_certs=http.ca_certs,
cert_reqs=cert_reqs,
)
return urllib3.PoolManager(
ca_certs=http.ca_certs,
cert_reqs=cert_reqs,
)
|
[
"def",
"_default_make_pool",
"(",
"http",
",",
"proxy_info",
")",
":",
"if",
"not",
"http",
".",
"ca_certs",
":",
"http",
".",
"ca_certs",
"=",
"_certifi_where_for_ssl_version",
"(",
")",
"ssl_disabled",
"=",
"http",
".",
"disable_ssl_certificate_validation",
"cert_reqs",
"=",
"'CERT_REQUIRED'",
"if",
"http",
".",
"ca_certs",
"and",
"not",
"ssl_disabled",
"else",
"None",
"if",
"isinstance",
"(",
"proxy_info",
",",
"collections",
".",
"Callable",
")",
":",
"proxy_info",
"=",
"proxy_info",
"(",
")",
"if",
"proxy_info",
":",
"if",
"proxy_info",
".",
"proxy_user",
"and",
"proxy_info",
".",
"proxy_pass",
":",
"proxy_url",
"=",
"'http://{}:{}@{}:{}/'",
".",
"format",
"(",
"proxy_info",
".",
"proxy_user",
",",
"proxy_info",
".",
"proxy_pass",
",",
"proxy_info",
".",
"proxy_host",
",",
"proxy_info",
".",
"proxy_port",
",",
")",
"proxy_headers",
"=",
"urllib3",
".",
"util",
".",
"request",
".",
"make_headers",
"(",
"proxy_basic_auth",
"=",
"'{}:{}'",
".",
"format",
"(",
"proxy_info",
".",
"proxy_user",
",",
"proxy_info",
".",
"proxy_pass",
",",
")",
")",
"else",
":",
"proxy_url",
"=",
"'http://{}:{}/'",
".",
"format",
"(",
"proxy_info",
".",
"proxy_host",
",",
"proxy_info",
".",
"proxy_port",
",",
")",
"proxy_headers",
"=",
"{",
"}",
"return",
"urllib3",
".",
"ProxyManager",
"(",
"proxy_url",
"=",
"proxy_url",
",",
"proxy_headers",
"=",
"proxy_headers",
",",
"ca_certs",
"=",
"http",
".",
"ca_certs",
",",
"cert_reqs",
"=",
"cert_reqs",
",",
")",
"return",
"urllib3",
".",
"PoolManager",
"(",
"ca_certs",
"=",
"http",
".",
"ca_certs",
",",
"cert_reqs",
"=",
"cert_reqs",
",",
")"
] |
Creates a urllib3.PoolManager object that has SSL verification enabled
and uses the certifi certificates.
|
[
"Creates",
"a",
"urllib3",
".",
"PoolManager",
"object",
"that",
"has",
"SSL",
"verification",
"enabled",
"and",
"uses",
"the",
"certifi",
"certificates",
"."
] |
e034530c551f11cf5690ef78a24c66087976c310
|
https://github.com/GoogleCloudPlatform/httplib2shim/blob/e034530c551f11cf5690ef78a24c66087976c310/httplib2shim/__init__.py#L35-L74
|
train
|
GoogleCloudPlatform/httplib2shim
|
httplib2shim/__init__.py
|
patch
|
def patch(make_pool=_default_make_pool):
"""Monkey-patches httplib2.Http to be httplib2shim.Http.
This effectively makes all clients of httplib2 use urlilb3. It's preferable
to specify httplib2shim.Http explicitly where you can, but this can be
useful in situations where you do not control the construction of the http
object.
Args:
make_pool: A function that returns a urllib3.Pool-like object. This
allows you to specify special arguments to your connection pool if
needed. By default, this will create a urllib3.PoolManager with
SSL verification enabled using the certifi certificates.
"""
setattr(httplib2, '_HttpOriginal', httplib2.Http)
httplib2.Http = Http
Http._make_pool = make_pool
|
python
|
def patch(make_pool=_default_make_pool):
"""Monkey-patches httplib2.Http to be httplib2shim.Http.
This effectively makes all clients of httplib2 use urlilb3. It's preferable
to specify httplib2shim.Http explicitly where you can, but this can be
useful in situations where you do not control the construction of the http
object.
Args:
make_pool: A function that returns a urllib3.Pool-like object. This
allows you to specify special arguments to your connection pool if
needed. By default, this will create a urllib3.PoolManager with
SSL verification enabled using the certifi certificates.
"""
setattr(httplib2, '_HttpOriginal', httplib2.Http)
httplib2.Http = Http
Http._make_pool = make_pool
|
[
"def",
"patch",
"(",
"make_pool",
"=",
"_default_make_pool",
")",
":",
"setattr",
"(",
"httplib2",
",",
"'_HttpOriginal'",
",",
"httplib2",
".",
"Http",
")",
"httplib2",
".",
"Http",
"=",
"Http",
"Http",
".",
"_make_pool",
"=",
"make_pool"
] |
Monkey-patches httplib2.Http to be httplib2shim.Http.
This effectively makes all clients of httplib2 use urlilb3. It's preferable
to specify httplib2shim.Http explicitly where you can, but this can be
useful in situations where you do not control the construction of the http
object.
Args:
make_pool: A function that returns a urllib3.Pool-like object. This
allows you to specify special arguments to your connection pool if
needed. By default, this will create a urllib3.PoolManager with
SSL verification enabled using the certifi certificates.
|
[
"Monkey",
"-",
"patches",
"httplib2",
".",
"Http",
"to",
"be",
"httplib2shim",
".",
"Http",
"."
] |
e034530c551f11cf5690ef78a24c66087976c310
|
https://github.com/GoogleCloudPlatform/httplib2shim/blob/e034530c551f11cf5690ef78a24c66087976c310/httplib2shim/__init__.py#L77-L93
|
train
|
GoogleCloudPlatform/httplib2shim
|
httplib2shim/__init__.py
|
_is_ipv6
|
def _is_ipv6(addr):
"""Checks if a given address is an IPv6 address."""
try:
socket.inet_pton(socket.AF_INET6, addr)
return True
except socket.error:
return False
|
python
|
def _is_ipv6(addr):
"""Checks if a given address is an IPv6 address."""
try:
socket.inet_pton(socket.AF_INET6, addr)
return True
except socket.error:
return False
|
[
"def",
"_is_ipv6",
"(",
"addr",
")",
":",
"try",
":",
"socket",
".",
"inet_pton",
"(",
"socket",
".",
"AF_INET6",
",",
"addr",
")",
"return",
"True",
"except",
"socket",
".",
"error",
":",
"return",
"False"
] |
Checks if a given address is an IPv6 address.
|
[
"Checks",
"if",
"a",
"given",
"address",
"is",
"an",
"IPv6",
"address",
"."
] |
e034530c551f11cf5690ef78a24c66087976c310
|
https://github.com/GoogleCloudPlatform/httplib2shim/blob/e034530c551f11cf5690ef78a24c66087976c310/httplib2shim/__init__.py#L180-L186
|
train
|
GoogleCloudPlatform/httplib2shim
|
httplib2shim/__init__.py
|
_certifi_where_for_ssl_version
|
def _certifi_where_for_ssl_version():
"""Gets the right location for certifi certifications for the current SSL
version.
Older versions of SSL don't support the stronger set of root certificates.
"""
if not ssl:
return
if ssl.OPENSSL_VERSION_INFO < (1, 0, 2):
warnings.warn(
'You are using an outdated version of OpenSSL that '
'can\'t use stronger root certificates.')
return certifi.old_where()
return certifi.where()
|
python
|
def _certifi_where_for_ssl_version():
"""Gets the right location for certifi certifications for the current SSL
version.
Older versions of SSL don't support the stronger set of root certificates.
"""
if not ssl:
return
if ssl.OPENSSL_VERSION_INFO < (1, 0, 2):
warnings.warn(
'You are using an outdated version of OpenSSL that '
'can\'t use stronger root certificates.')
return certifi.old_where()
return certifi.where()
|
[
"def",
"_certifi_where_for_ssl_version",
"(",
")",
":",
"if",
"not",
"ssl",
":",
"return",
"if",
"ssl",
".",
"OPENSSL_VERSION_INFO",
"<",
"(",
"1",
",",
"0",
",",
"2",
")",
":",
"warnings",
".",
"warn",
"(",
"'You are using an outdated version of OpenSSL that '",
"'can\\'t use stronger root certificates.'",
")",
"return",
"certifi",
".",
"old_where",
"(",
")",
"return",
"certifi",
".",
"where",
"(",
")"
] |
Gets the right location for certifi certifications for the current SSL
version.
Older versions of SSL don't support the stronger set of root certificates.
|
[
"Gets",
"the",
"right",
"location",
"for",
"certifi",
"certifications",
"for",
"the",
"current",
"SSL",
"version",
"."
] |
e034530c551f11cf5690ef78a24c66087976c310
|
https://github.com/GoogleCloudPlatform/httplib2shim/blob/e034530c551f11cf5690ef78a24c66087976c310/httplib2shim/__init__.py#L189-L204
|
train
|
GoogleCloudPlatform/httplib2shim
|
httplib2shim/__init__.py
|
_map_response
|
def _map_response(response, decode=False):
"""Maps a urllib3 response to a httplib/httplib2 Response."""
# This causes weird deepcopy errors, so it's commented out for now.
# item._urllib3_response = response
item = httplib2.Response(response.getheaders())
item.status = response.status
item['status'] = str(item.status)
item.reason = response.reason
item.version = response.version
# httplib2 expects the content-encoding header to be stripped and the
# content length to be the length of the uncompressed content.
# This does not occur for 'HEAD' requests.
if decode and item.get('content-encoding') in ['gzip', 'deflate']:
item['content-length'] = str(len(response.data))
item['-content-encoding'] = item.pop('content-encoding')
return item
|
python
|
def _map_response(response, decode=False):
"""Maps a urllib3 response to a httplib/httplib2 Response."""
# This causes weird deepcopy errors, so it's commented out for now.
# item._urllib3_response = response
item = httplib2.Response(response.getheaders())
item.status = response.status
item['status'] = str(item.status)
item.reason = response.reason
item.version = response.version
# httplib2 expects the content-encoding header to be stripped and the
# content length to be the length of the uncompressed content.
# This does not occur for 'HEAD' requests.
if decode and item.get('content-encoding') in ['gzip', 'deflate']:
item['content-length'] = str(len(response.data))
item['-content-encoding'] = item.pop('content-encoding')
return item
|
[
"def",
"_map_response",
"(",
"response",
",",
"decode",
"=",
"False",
")",
":",
"# This causes weird deepcopy errors, so it's commented out for now.",
"# item._urllib3_response = response",
"item",
"=",
"httplib2",
".",
"Response",
"(",
"response",
".",
"getheaders",
"(",
")",
")",
"item",
".",
"status",
"=",
"response",
".",
"status",
"item",
"[",
"'status'",
"]",
"=",
"str",
"(",
"item",
".",
"status",
")",
"item",
".",
"reason",
"=",
"response",
".",
"reason",
"item",
".",
"version",
"=",
"response",
".",
"version",
"# httplib2 expects the content-encoding header to be stripped and the",
"# content length to be the length of the uncompressed content.",
"# This does not occur for 'HEAD' requests.",
"if",
"decode",
"and",
"item",
".",
"get",
"(",
"'content-encoding'",
")",
"in",
"[",
"'gzip'",
",",
"'deflate'",
"]",
":",
"item",
"[",
"'content-length'",
"]",
"=",
"str",
"(",
"len",
"(",
"response",
".",
"data",
")",
")",
"item",
"[",
"'-content-encoding'",
"]",
"=",
"item",
".",
"pop",
"(",
"'content-encoding'",
")",
"return",
"item"
] |
Maps a urllib3 response to a httplib/httplib2 Response.
|
[
"Maps",
"a",
"urllib3",
"response",
"to",
"a",
"httplib",
"/",
"httplib2",
"Response",
"."
] |
e034530c551f11cf5690ef78a24c66087976c310
|
https://github.com/GoogleCloudPlatform/httplib2shim/blob/e034530c551f11cf5690ef78a24c66087976c310/httplib2shim/__init__.py#L207-L224
|
train
|
GoogleCloudPlatform/httplib2shim
|
httplib2shim/__init__.py
|
_map_exception
|
def _map_exception(e):
"""Maps an exception from urlib3 to httplib2."""
if isinstance(e, urllib3.exceptions.MaxRetryError):
if not e.reason:
return e
e = e.reason
message = e.args[0] if e.args else ''
if isinstance(e, urllib3.exceptions.ResponseError):
if 'too many redirects' in message:
return httplib2.RedirectLimit(message)
if isinstance(e, urllib3.exceptions.NewConnectionError):
if ('Name or service not known' in message or
'nodename nor servname provided, or not known' in message):
return httplib2.ServerNotFoundError(
'Unable to find hostname.')
if 'Connection refused' in message:
return socket.error((errno.ECONNREFUSED, 'Connection refused'))
if isinstance(e, urllib3.exceptions.DecodeError):
return httplib2.FailedToDecompressContent(
'Content purported as compressed but not uncompressable.',
httplib2.Response({'status': 500}), '')
if isinstance(e, urllib3.exceptions.TimeoutError):
return socket.timeout('timed out')
if isinstance(e, urllib3.exceptions.SSLError):
return ssl.SSLError(*e.args)
return e
|
python
|
def _map_exception(e):
"""Maps an exception from urlib3 to httplib2."""
if isinstance(e, urllib3.exceptions.MaxRetryError):
if not e.reason:
return e
e = e.reason
message = e.args[0] if e.args else ''
if isinstance(e, urllib3.exceptions.ResponseError):
if 'too many redirects' in message:
return httplib2.RedirectLimit(message)
if isinstance(e, urllib3.exceptions.NewConnectionError):
if ('Name or service not known' in message or
'nodename nor servname provided, or not known' in message):
return httplib2.ServerNotFoundError(
'Unable to find hostname.')
if 'Connection refused' in message:
return socket.error((errno.ECONNREFUSED, 'Connection refused'))
if isinstance(e, urllib3.exceptions.DecodeError):
return httplib2.FailedToDecompressContent(
'Content purported as compressed but not uncompressable.',
httplib2.Response({'status': 500}), '')
if isinstance(e, urllib3.exceptions.TimeoutError):
return socket.timeout('timed out')
if isinstance(e, urllib3.exceptions.SSLError):
return ssl.SSLError(*e.args)
return e
|
[
"def",
"_map_exception",
"(",
"e",
")",
":",
"if",
"isinstance",
"(",
"e",
",",
"urllib3",
".",
"exceptions",
".",
"MaxRetryError",
")",
":",
"if",
"not",
"e",
".",
"reason",
":",
"return",
"e",
"e",
"=",
"e",
".",
"reason",
"message",
"=",
"e",
".",
"args",
"[",
"0",
"]",
"if",
"e",
".",
"args",
"else",
"''",
"if",
"isinstance",
"(",
"e",
",",
"urllib3",
".",
"exceptions",
".",
"ResponseError",
")",
":",
"if",
"'too many redirects'",
"in",
"message",
":",
"return",
"httplib2",
".",
"RedirectLimit",
"(",
"message",
")",
"if",
"isinstance",
"(",
"e",
",",
"urllib3",
".",
"exceptions",
".",
"NewConnectionError",
")",
":",
"if",
"(",
"'Name or service not known'",
"in",
"message",
"or",
"'nodename nor servname provided, or not known'",
"in",
"message",
")",
":",
"return",
"httplib2",
".",
"ServerNotFoundError",
"(",
"'Unable to find hostname.'",
")",
"if",
"'Connection refused'",
"in",
"message",
":",
"return",
"socket",
".",
"error",
"(",
"(",
"errno",
".",
"ECONNREFUSED",
",",
"'Connection refused'",
")",
")",
"if",
"isinstance",
"(",
"e",
",",
"urllib3",
".",
"exceptions",
".",
"DecodeError",
")",
":",
"return",
"httplib2",
".",
"FailedToDecompressContent",
"(",
"'Content purported as compressed but not uncompressable.'",
",",
"httplib2",
".",
"Response",
"(",
"{",
"'status'",
":",
"500",
"}",
")",
",",
"''",
")",
"if",
"isinstance",
"(",
"e",
",",
"urllib3",
".",
"exceptions",
".",
"TimeoutError",
")",
":",
"return",
"socket",
".",
"timeout",
"(",
"'timed out'",
")",
"if",
"isinstance",
"(",
"e",
",",
"urllib3",
".",
"exceptions",
".",
"SSLError",
")",
":",
"return",
"ssl",
".",
"SSLError",
"(",
"*",
"e",
".",
"args",
")",
"return",
"e"
] |
Maps an exception from urlib3 to httplib2.
|
[
"Maps",
"an",
"exception",
"from",
"urlib3",
"to",
"httplib2",
"."
] |
e034530c551f11cf5690ef78a24c66087976c310
|
https://github.com/GoogleCloudPlatform/httplib2shim/blob/e034530c551f11cf5690ef78a24c66087976c310/httplib2shim/__init__.py#L227-L253
|
train
|
zetaops/zengine
|
zengine/wf_daemon.py
|
run_workers
|
def run_workers(no_subprocess, watch_paths=None, is_background=False):
"""
subprocess handler
"""
import atexit, os, subprocess, signal
if watch_paths:
from watchdog.observers import Observer
# from watchdog.observers.fsevents import FSEventsObserver as Observer
# from watchdog.observers.polling import PollingObserver as Observer
from watchdog.events import FileSystemEventHandler
def on_modified(event):
if not is_background:
print("Restarting worker due to change in %s" % event.src_path)
log.info("modified %s" % event.src_path)
try:
kill_children()
run_children()
except:
log.exception("Error while restarting worker")
handler = FileSystemEventHandler()
handler.on_modified = on_modified
# global child_pids
child_pids = []
log.info("starting %s workers" % no_subprocess)
def run_children():
global child_pids
child_pids = []
for i in range(int(no_subprocess)):
proc = subprocess.Popen([sys.executable, __file__],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
child_pids.append(proc.pid)
log.info("Started worker with pid %s" % proc.pid)
def kill_children():
"""
kill subprocess on exit of manager (this) process
"""
log.info("Stopping worker(s)")
for pid in child_pids:
if pid is not None:
os.kill(pid, signal.SIGTERM)
run_children()
atexit.register(kill_children)
signal.signal(signal.SIGTERM, kill_children)
if watch_paths:
observer = Observer()
for path in watch_paths:
if not is_background:
print("Watching for changes under %s" % path)
observer.schedule(handler, path=path, recursive=True)
observer.start()
while 1:
try:
sleep(1)
except KeyboardInterrupt:
log.info("Keyboard interrupt, exiting")
if watch_paths:
observer.stop()
observer.join()
sys.exit(0)
|
python
|
def run_workers(no_subprocess, watch_paths=None, is_background=False):
"""
subprocess handler
"""
import atexit, os, subprocess, signal
if watch_paths:
from watchdog.observers import Observer
# from watchdog.observers.fsevents import FSEventsObserver as Observer
# from watchdog.observers.polling import PollingObserver as Observer
from watchdog.events import FileSystemEventHandler
def on_modified(event):
if not is_background:
print("Restarting worker due to change in %s" % event.src_path)
log.info("modified %s" % event.src_path)
try:
kill_children()
run_children()
except:
log.exception("Error while restarting worker")
handler = FileSystemEventHandler()
handler.on_modified = on_modified
# global child_pids
child_pids = []
log.info("starting %s workers" % no_subprocess)
def run_children():
global child_pids
child_pids = []
for i in range(int(no_subprocess)):
proc = subprocess.Popen([sys.executable, __file__],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
child_pids.append(proc.pid)
log.info("Started worker with pid %s" % proc.pid)
def kill_children():
"""
kill subprocess on exit of manager (this) process
"""
log.info("Stopping worker(s)")
for pid in child_pids:
if pid is not None:
os.kill(pid, signal.SIGTERM)
run_children()
atexit.register(kill_children)
signal.signal(signal.SIGTERM, kill_children)
if watch_paths:
observer = Observer()
for path in watch_paths:
if not is_background:
print("Watching for changes under %s" % path)
observer.schedule(handler, path=path, recursive=True)
observer.start()
while 1:
try:
sleep(1)
except KeyboardInterrupt:
log.info("Keyboard interrupt, exiting")
if watch_paths:
observer.stop()
observer.join()
sys.exit(0)
|
[
"def",
"run_workers",
"(",
"no_subprocess",
",",
"watch_paths",
"=",
"None",
",",
"is_background",
"=",
"False",
")",
":",
"import",
"atexit",
",",
"os",
",",
"subprocess",
",",
"signal",
"if",
"watch_paths",
":",
"from",
"watchdog",
".",
"observers",
"import",
"Observer",
"# from watchdog.observers.fsevents import FSEventsObserver as Observer",
"# from watchdog.observers.polling import PollingObserver as Observer",
"from",
"watchdog",
".",
"events",
"import",
"FileSystemEventHandler",
"def",
"on_modified",
"(",
"event",
")",
":",
"if",
"not",
"is_background",
":",
"print",
"(",
"\"Restarting worker due to change in %s\"",
"%",
"event",
".",
"src_path",
")",
"log",
".",
"info",
"(",
"\"modified %s\"",
"%",
"event",
".",
"src_path",
")",
"try",
":",
"kill_children",
"(",
")",
"run_children",
"(",
")",
"except",
":",
"log",
".",
"exception",
"(",
"\"Error while restarting worker\"",
")",
"handler",
"=",
"FileSystemEventHandler",
"(",
")",
"handler",
".",
"on_modified",
"=",
"on_modified",
"# global child_pids",
"child_pids",
"=",
"[",
"]",
"log",
".",
"info",
"(",
"\"starting %s workers\"",
"%",
"no_subprocess",
")",
"def",
"run_children",
"(",
")",
":",
"global",
"child_pids",
"child_pids",
"=",
"[",
"]",
"for",
"i",
"in",
"range",
"(",
"int",
"(",
"no_subprocess",
")",
")",
":",
"proc",
"=",
"subprocess",
".",
"Popen",
"(",
"[",
"sys",
".",
"executable",
",",
"__file__",
"]",
",",
"stdout",
"=",
"subprocess",
".",
"PIPE",
",",
"stderr",
"=",
"subprocess",
".",
"PIPE",
")",
"child_pids",
".",
"append",
"(",
"proc",
".",
"pid",
")",
"log",
".",
"info",
"(",
"\"Started worker with pid %s\"",
"%",
"proc",
".",
"pid",
")",
"def",
"kill_children",
"(",
")",
":",
"\"\"\"\n kill subprocess on exit of manager (this) process\n \"\"\"",
"log",
".",
"info",
"(",
"\"Stopping worker(s)\"",
")",
"for",
"pid",
"in",
"child_pids",
":",
"if",
"pid",
"is",
"not",
"None",
":",
"os",
".",
"kill",
"(",
"pid",
",",
"signal",
".",
"SIGTERM",
")",
"run_children",
"(",
")",
"atexit",
".",
"register",
"(",
"kill_children",
")",
"signal",
".",
"signal",
"(",
"signal",
".",
"SIGTERM",
",",
"kill_children",
")",
"if",
"watch_paths",
":",
"observer",
"=",
"Observer",
"(",
")",
"for",
"path",
"in",
"watch_paths",
":",
"if",
"not",
"is_background",
":",
"print",
"(",
"\"Watching for changes under %s\"",
"%",
"path",
")",
"observer",
".",
"schedule",
"(",
"handler",
",",
"path",
"=",
"path",
",",
"recursive",
"=",
"True",
")",
"observer",
".",
"start",
"(",
")",
"while",
"1",
":",
"try",
":",
"sleep",
"(",
"1",
")",
"except",
"KeyboardInterrupt",
":",
"log",
".",
"info",
"(",
"\"Keyboard interrupt, exiting\"",
")",
"if",
"watch_paths",
":",
"observer",
".",
"stop",
"(",
")",
"observer",
".",
"join",
"(",
")",
"sys",
".",
"exit",
"(",
"0",
")"
] |
subprocess handler
|
[
"subprocess",
"handler"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/wf_daemon.py#L235-L300
|
train
|
zetaops/zengine
|
zengine/wf_daemon.py
|
Worker.exit
|
def exit(self, signal=None, frame=None):
"""
Properly close the AMQP connections
"""
self.input_channel.close()
self.client_queue.close()
self.connection.close()
log.info("Worker exiting")
sys.exit(0)
|
python
|
def exit(self, signal=None, frame=None):
"""
Properly close the AMQP connections
"""
self.input_channel.close()
self.client_queue.close()
self.connection.close()
log.info("Worker exiting")
sys.exit(0)
|
[
"def",
"exit",
"(",
"self",
",",
"signal",
"=",
"None",
",",
"frame",
"=",
"None",
")",
":",
"self",
".",
"input_channel",
".",
"close",
"(",
")",
"self",
".",
"client_queue",
".",
"close",
"(",
")",
"self",
".",
"connection",
".",
"close",
"(",
")",
"log",
".",
"info",
"(",
"\"Worker exiting\"",
")",
"sys",
".",
"exit",
"(",
"0",
")"
] |
Properly close the AMQP connections
|
[
"Properly",
"close",
"the",
"AMQP",
"connections"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/wf_daemon.py#L48-L56
|
train
|
zetaops/zengine
|
zengine/wf_daemon.py
|
Worker.connect
|
def connect(self):
"""
make amqp connection and create channels and queue binding
"""
self.connection = pika.BlockingConnection(BLOCKING_MQ_PARAMS)
self.client_queue = ClientQueue()
self.input_channel = self.connection.channel()
self.input_channel.exchange_declare(exchange=self.INPUT_EXCHANGE,
type='topic',
durable=True)
self.input_channel.queue_declare(queue=self.INPUT_QUEUE_NAME)
self.input_channel.queue_bind(exchange=self.INPUT_EXCHANGE, queue=self.INPUT_QUEUE_NAME)
log.info("Bind to queue named '%s' queue with exchange '%s'" % (self.INPUT_QUEUE_NAME,
self.INPUT_EXCHANGE))
|
python
|
def connect(self):
"""
make amqp connection and create channels and queue binding
"""
self.connection = pika.BlockingConnection(BLOCKING_MQ_PARAMS)
self.client_queue = ClientQueue()
self.input_channel = self.connection.channel()
self.input_channel.exchange_declare(exchange=self.INPUT_EXCHANGE,
type='topic',
durable=True)
self.input_channel.queue_declare(queue=self.INPUT_QUEUE_NAME)
self.input_channel.queue_bind(exchange=self.INPUT_EXCHANGE, queue=self.INPUT_QUEUE_NAME)
log.info("Bind to queue named '%s' queue with exchange '%s'" % (self.INPUT_QUEUE_NAME,
self.INPUT_EXCHANGE))
|
[
"def",
"connect",
"(",
"self",
")",
":",
"self",
".",
"connection",
"=",
"pika",
".",
"BlockingConnection",
"(",
"BLOCKING_MQ_PARAMS",
")",
"self",
".",
"client_queue",
"=",
"ClientQueue",
"(",
")",
"self",
".",
"input_channel",
"=",
"self",
".",
"connection",
".",
"channel",
"(",
")",
"self",
".",
"input_channel",
".",
"exchange_declare",
"(",
"exchange",
"=",
"self",
".",
"INPUT_EXCHANGE",
",",
"type",
"=",
"'topic'",
",",
"durable",
"=",
"True",
")",
"self",
".",
"input_channel",
".",
"queue_declare",
"(",
"queue",
"=",
"self",
".",
"INPUT_QUEUE_NAME",
")",
"self",
".",
"input_channel",
".",
"queue_bind",
"(",
"exchange",
"=",
"self",
".",
"INPUT_EXCHANGE",
",",
"queue",
"=",
"self",
".",
"INPUT_QUEUE_NAME",
")",
"log",
".",
"info",
"(",
"\"Bind to queue named '%s' queue with exchange '%s'\"",
"%",
"(",
"self",
".",
"INPUT_QUEUE_NAME",
",",
"self",
".",
"INPUT_EXCHANGE",
")",
")"
] |
make amqp connection and create channels and queue binding
|
[
"make",
"amqp",
"connection",
"and",
"create",
"channels",
"and",
"queue",
"binding"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/wf_daemon.py#L58-L72
|
train
|
zetaops/zengine
|
zengine/wf_daemon.py
|
Worker.clear_queue
|
def clear_queue(self):
"""
clear outs all messages from INPUT_QUEUE_NAME
"""
def remove_message(ch, method, properties, body):
print("Removed message: %s" % body)
self.input_channel.basic_consume(remove_message, queue=self.INPUT_QUEUE_NAME, no_ack=True)
try:
self.input_channel.start_consuming()
except (KeyboardInterrupt, SystemExit):
log.info(" Exiting")
self.exit()
|
python
|
def clear_queue(self):
"""
clear outs all messages from INPUT_QUEUE_NAME
"""
def remove_message(ch, method, properties, body):
print("Removed message: %s" % body)
self.input_channel.basic_consume(remove_message, queue=self.INPUT_QUEUE_NAME, no_ack=True)
try:
self.input_channel.start_consuming()
except (KeyboardInterrupt, SystemExit):
log.info(" Exiting")
self.exit()
|
[
"def",
"clear_queue",
"(",
"self",
")",
":",
"def",
"remove_message",
"(",
"ch",
",",
"method",
",",
"properties",
",",
"body",
")",
":",
"print",
"(",
"\"Removed message: %s\"",
"%",
"body",
")",
"self",
".",
"input_channel",
".",
"basic_consume",
"(",
"remove_message",
",",
"queue",
"=",
"self",
".",
"INPUT_QUEUE_NAME",
",",
"no_ack",
"=",
"True",
")",
"try",
":",
"self",
".",
"input_channel",
".",
"start_consuming",
"(",
")",
"except",
"(",
"KeyboardInterrupt",
",",
"SystemExit",
")",
":",
"log",
".",
"info",
"(",
"\" Exiting\"",
")",
"self",
".",
"exit",
"(",
")"
] |
clear outs all messages from INPUT_QUEUE_NAME
|
[
"clear",
"outs",
"all",
"messages",
"from",
"INPUT_QUEUE_NAME"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/wf_daemon.py#L76-L87
|
train
|
zetaops/zengine
|
zengine/wf_daemon.py
|
Worker.run
|
def run(self):
"""
actual consuming of incoming works starts here
"""
self.input_channel.basic_consume(self.handle_message,
queue=self.INPUT_QUEUE_NAME,
no_ack=True
)
try:
self.input_channel.start_consuming()
except (KeyboardInterrupt, SystemExit):
log.info(" Exiting")
self.exit()
|
python
|
def run(self):
"""
actual consuming of incoming works starts here
"""
self.input_channel.basic_consume(self.handle_message,
queue=self.INPUT_QUEUE_NAME,
no_ack=True
)
try:
self.input_channel.start_consuming()
except (KeyboardInterrupt, SystemExit):
log.info(" Exiting")
self.exit()
|
[
"def",
"run",
"(",
"self",
")",
":",
"self",
".",
"input_channel",
".",
"basic_consume",
"(",
"self",
".",
"handle_message",
",",
"queue",
"=",
"self",
".",
"INPUT_QUEUE_NAME",
",",
"no_ack",
"=",
"True",
")",
"try",
":",
"self",
".",
"input_channel",
".",
"start_consuming",
"(",
")",
"except",
"(",
"KeyboardInterrupt",
",",
"SystemExit",
")",
":",
"log",
".",
"info",
"(",
"\" Exiting\"",
")",
"self",
".",
"exit",
"(",
")"
] |
actual consuming of incoming works starts here
|
[
"actual",
"consuming",
"of",
"incoming",
"works",
"starts",
"here"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/wf_daemon.py#L89-L101
|
train
|
zetaops/zengine
|
zengine/wf_daemon.py
|
Worker.handle_message
|
def handle_message(self, ch, method, properties, body):
"""
this is a pika.basic_consumer callback
handles client inputs, runs appropriate workflows and views
Args:
ch: amqp channel
method: amqp method
properties:
body: message body
"""
input = {}
headers = {}
try:
self.sessid = method.routing_key
input = json_decode(body)
data = input['data']
# since this comes as "path" we dont know if it's view or workflow yet
# TODO: just a workaround till we modify ui to
if 'path' in data:
if data['path'] in VIEW_METHODS:
data['view'] = data['path']
else:
data['wf'] = data['path']
session = Session(self.sessid)
headers = {'remote_ip': input['_zops_remote_ip'],
'source': input['_zops_source']}
if 'wf' in data:
output = self._handle_workflow(session, data, headers)
elif 'job' in data:
self._handle_job(session, data, headers)
return
else:
output = self._handle_view(session, data, headers)
except HTTPError as e:
import sys
if hasattr(sys, '_called_from_test'):
raise
output = {"cmd": "error", "error": self._prepare_error_msg(e.message), "code": e.code}
log.exception("Http error occurred")
except:
self.current = Current(session=session, input=data)
self.current.headers = headers
import sys
if hasattr(sys, '_called_from_test'):
raise
err = traceback.format_exc()
output = {"cmd": "error", "error": self._prepare_error_msg(err), "code": 500}
log.exception("Worker error occurred with messsage body:\n%s" % body)
if 'callbackID' in input:
output['callbackID'] = input['callbackID']
log.info("OUTPUT for %s: %s" % (self.sessid, output))
output['reply_timestamp'] = time()
self.send_output(output)
|
python
|
def handle_message(self, ch, method, properties, body):
"""
this is a pika.basic_consumer callback
handles client inputs, runs appropriate workflows and views
Args:
ch: amqp channel
method: amqp method
properties:
body: message body
"""
input = {}
headers = {}
try:
self.sessid = method.routing_key
input = json_decode(body)
data = input['data']
# since this comes as "path" we dont know if it's view or workflow yet
# TODO: just a workaround till we modify ui to
if 'path' in data:
if data['path'] in VIEW_METHODS:
data['view'] = data['path']
else:
data['wf'] = data['path']
session = Session(self.sessid)
headers = {'remote_ip': input['_zops_remote_ip'],
'source': input['_zops_source']}
if 'wf' in data:
output = self._handle_workflow(session, data, headers)
elif 'job' in data:
self._handle_job(session, data, headers)
return
else:
output = self._handle_view(session, data, headers)
except HTTPError as e:
import sys
if hasattr(sys, '_called_from_test'):
raise
output = {"cmd": "error", "error": self._prepare_error_msg(e.message), "code": e.code}
log.exception("Http error occurred")
except:
self.current = Current(session=session, input=data)
self.current.headers = headers
import sys
if hasattr(sys, '_called_from_test'):
raise
err = traceback.format_exc()
output = {"cmd": "error", "error": self._prepare_error_msg(err), "code": 500}
log.exception("Worker error occurred with messsage body:\n%s" % body)
if 'callbackID' in input:
output['callbackID'] = input['callbackID']
log.info("OUTPUT for %s: %s" % (self.sessid, output))
output['reply_timestamp'] = time()
self.send_output(output)
|
[
"def",
"handle_message",
"(",
"self",
",",
"ch",
",",
"method",
",",
"properties",
",",
"body",
")",
":",
"input",
"=",
"{",
"}",
"headers",
"=",
"{",
"}",
"try",
":",
"self",
".",
"sessid",
"=",
"method",
".",
"routing_key",
"input",
"=",
"json_decode",
"(",
"body",
")",
"data",
"=",
"input",
"[",
"'data'",
"]",
"# since this comes as \"path\" we dont know if it's view or workflow yet",
"# TODO: just a workaround till we modify ui to",
"if",
"'path'",
"in",
"data",
":",
"if",
"data",
"[",
"'path'",
"]",
"in",
"VIEW_METHODS",
":",
"data",
"[",
"'view'",
"]",
"=",
"data",
"[",
"'path'",
"]",
"else",
":",
"data",
"[",
"'wf'",
"]",
"=",
"data",
"[",
"'path'",
"]",
"session",
"=",
"Session",
"(",
"self",
".",
"sessid",
")",
"headers",
"=",
"{",
"'remote_ip'",
":",
"input",
"[",
"'_zops_remote_ip'",
"]",
",",
"'source'",
":",
"input",
"[",
"'_zops_source'",
"]",
"}",
"if",
"'wf'",
"in",
"data",
":",
"output",
"=",
"self",
".",
"_handle_workflow",
"(",
"session",
",",
"data",
",",
"headers",
")",
"elif",
"'job'",
"in",
"data",
":",
"self",
".",
"_handle_job",
"(",
"session",
",",
"data",
",",
"headers",
")",
"return",
"else",
":",
"output",
"=",
"self",
".",
"_handle_view",
"(",
"session",
",",
"data",
",",
"headers",
")",
"except",
"HTTPError",
"as",
"e",
":",
"import",
"sys",
"if",
"hasattr",
"(",
"sys",
",",
"'_called_from_test'",
")",
":",
"raise",
"output",
"=",
"{",
"\"cmd\"",
":",
"\"error\"",
",",
"\"error\"",
":",
"self",
".",
"_prepare_error_msg",
"(",
"e",
".",
"message",
")",
",",
"\"code\"",
":",
"e",
".",
"code",
"}",
"log",
".",
"exception",
"(",
"\"Http error occurred\"",
")",
"except",
":",
"self",
".",
"current",
"=",
"Current",
"(",
"session",
"=",
"session",
",",
"input",
"=",
"data",
")",
"self",
".",
"current",
".",
"headers",
"=",
"headers",
"import",
"sys",
"if",
"hasattr",
"(",
"sys",
",",
"'_called_from_test'",
")",
":",
"raise",
"err",
"=",
"traceback",
".",
"format_exc",
"(",
")",
"output",
"=",
"{",
"\"cmd\"",
":",
"\"error\"",
",",
"\"error\"",
":",
"self",
".",
"_prepare_error_msg",
"(",
"err",
")",
",",
"\"code\"",
":",
"500",
"}",
"log",
".",
"exception",
"(",
"\"Worker error occurred with messsage body:\\n%s\"",
"%",
"body",
")",
"if",
"'callbackID'",
"in",
"input",
":",
"output",
"[",
"'callbackID'",
"]",
"=",
"input",
"[",
"'callbackID'",
"]",
"log",
".",
"info",
"(",
"\"OUTPUT for %s: %s\"",
"%",
"(",
"self",
".",
"sessid",
",",
"output",
")",
")",
"output",
"[",
"'reply_timestamp'",
"]",
"=",
"time",
"(",
")",
"self",
".",
"send_output",
"(",
"output",
")"
] |
this is a pika.basic_consumer callback
handles client inputs, runs appropriate workflows and views
Args:
ch: amqp channel
method: amqp method
properties:
body: message body
|
[
"this",
"is",
"a",
"pika",
".",
"basic_consumer",
"callback",
"handles",
"client",
"inputs",
"runs",
"appropriate",
"workflows",
"and",
"views"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/wf_daemon.py#L165-L224
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
get_progress
|
def get_progress(start, finish):
"""
Args:
start (DateTime): start date
finish (DateTime): finish date
Returns:
"""
now = datetime.now()
dif_time_start = start - now
dif_time_finish = finish - now
if dif_time_start.days < 0 and dif_time_finish.days < 0:
return PROGRESS_STATES[3][0]
elif dif_time_start.days < 0 and dif_time_finish.days >= 1:
return PROGRESS_STATES[2][0]
elif dif_time_start.days >= 1 and dif_time_finish.days >= 1:
return PROGRESS_STATES[0][0]
else:
return PROGRESS_STATES[2][0]
|
python
|
def get_progress(start, finish):
"""
Args:
start (DateTime): start date
finish (DateTime): finish date
Returns:
"""
now = datetime.now()
dif_time_start = start - now
dif_time_finish = finish - now
if dif_time_start.days < 0 and dif_time_finish.days < 0:
return PROGRESS_STATES[3][0]
elif dif_time_start.days < 0 and dif_time_finish.days >= 1:
return PROGRESS_STATES[2][0]
elif dif_time_start.days >= 1 and dif_time_finish.days >= 1:
return PROGRESS_STATES[0][0]
else:
return PROGRESS_STATES[2][0]
|
[
"def",
"get_progress",
"(",
"start",
",",
"finish",
")",
":",
"now",
"=",
"datetime",
".",
"now",
"(",
")",
"dif_time_start",
"=",
"start",
"-",
"now",
"dif_time_finish",
"=",
"finish",
"-",
"now",
"if",
"dif_time_start",
".",
"days",
"<",
"0",
"and",
"dif_time_finish",
".",
"days",
"<",
"0",
":",
"return",
"PROGRESS_STATES",
"[",
"3",
"]",
"[",
"0",
"]",
"elif",
"dif_time_start",
".",
"days",
"<",
"0",
"and",
"dif_time_finish",
".",
"days",
">=",
"1",
":",
"return",
"PROGRESS_STATES",
"[",
"2",
"]",
"[",
"0",
"]",
"elif",
"dif_time_start",
".",
"days",
">=",
"1",
"and",
"dif_time_finish",
".",
"days",
">=",
"1",
":",
"return",
"PROGRESS_STATES",
"[",
"0",
"]",
"[",
"0",
"]",
"else",
":",
"return",
"PROGRESS_STATES",
"[",
"2",
"]",
"[",
"0",
"]"
] |
Args:
start (DateTime): start date
finish (DateTime): finish date
Returns:
|
[
"Args",
":",
"start",
"(",
"DateTime",
")",
":",
"start",
"date",
"finish",
"(",
"DateTime",
")",
":",
"finish",
"date",
"Returns",
":"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L230-L249
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
sync_wf_cache
|
def sync_wf_cache(current):
"""
BG Job for storing wf state to DB
"""
wf_cache = WFCache(current)
wf_state = wf_cache.get() # unicode serialized json to dict, all values are unicode
if 'role_id' in wf_state:
# role_id inserted by engine, so it's a sign that we get it from cache not db
try:
wfi = WFInstance.objects.get(key=current.input['token'])
except ObjectDoesNotExist:
# wf's that not started from a task invitation
wfi = WFInstance(key=current.input['token'])
wfi.wf = BPMNWorkflow.objects.get(name=wf_state['name'])
if not wfi.current_actor.exist:
# we just started the wf
try:
inv = TaskInvitation.objects.get(instance=wfi, role_id=wf_state['role_id'])
inv.delete_other_invitations()
inv.progress = 20
inv.save()
except ObjectDoesNotExist:
current.log.exception("Invitation not found: %s" % wf_state)
except MultipleObjectsReturned:
current.log.exception("Multiple invitations found: %s" % wf_state)
wfi.step = wf_state['step']
wfi.name = wf_state['name']
wfi.pool = wf_state['pool']
wfi.current_actor_id = str(wf_state['role_id']) # keys must be str not unicode
wfi.data = wf_state['data']
if wf_state['finished']:
wfi.finished = True
wfi.finish_date = wf_state['finish_date']
wf_cache.delete()
wfi.save()
else:
# if cache already cleared, we have nothing to sync
pass
|
python
|
def sync_wf_cache(current):
"""
BG Job for storing wf state to DB
"""
wf_cache = WFCache(current)
wf_state = wf_cache.get() # unicode serialized json to dict, all values are unicode
if 'role_id' in wf_state:
# role_id inserted by engine, so it's a sign that we get it from cache not db
try:
wfi = WFInstance.objects.get(key=current.input['token'])
except ObjectDoesNotExist:
# wf's that not started from a task invitation
wfi = WFInstance(key=current.input['token'])
wfi.wf = BPMNWorkflow.objects.get(name=wf_state['name'])
if not wfi.current_actor.exist:
# we just started the wf
try:
inv = TaskInvitation.objects.get(instance=wfi, role_id=wf_state['role_id'])
inv.delete_other_invitations()
inv.progress = 20
inv.save()
except ObjectDoesNotExist:
current.log.exception("Invitation not found: %s" % wf_state)
except MultipleObjectsReturned:
current.log.exception("Multiple invitations found: %s" % wf_state)
wfi.step = wf_state['step']
wfi.name = wf_state['name']
wfi.pool = wf_state['pool']
wfi.current_actor_id = str(wf_state['role_id']) # keys must be str not unicode
wfi.data = wf_state['data']
if wf_state['finished']:
wfi.finished = True
wfi.finish_date = wf_state['finish_date']
wf_cache.delete()
wfi.save()
else:
# if cache already cleared, we have nothing to sync
pass
|
[
"def",
"sync_wf_cache",
"(",
"current",
")",
":",
"wf_cache",
"=",
"WFCache",
"(",
"current",
")",
"wf_state",
"=",
"wf_cache",
".",
"get",
"(",
")",
"# unicode serialized json to dict, all values are unicode",
"if",
"'role_id'",
"in",
"wf_state",
":",
"# role_id inserted by engine, so it's a sign that we get it from cache not db",
"try",
":",
"wfi",
"=",
"WFInstance",
".",
"objects",
".",
"get",
"(",
"key",
"=",
"current",
".",
"input",
"[",
"'token'",
"]",
")",
"except",
"ObjectDoesNotExist",
":",
"# wf's that not started from a task invitation",
"wfi",
"=",
"WFInstance",
"(",
"key",
"=",
"current",
".",
"input",
"[",
"'token'",
"]",
")",
"wfi",
".",
"wf",
"=",
"BPMNWorkflow",
".",
"objects",
".",
"get",
"(",
"name",
"=",
"wf_state",
"[",
"'name'",
"]",
")",
"if",
"not",
"wfi",
".",
"current_actor",
".",
"exist",
":",
"# we just started the wf",
"try",
":",
"inv",
"=",
"TaskInvitation",
".",
"objects",
".",
"get",
"(",
"instance",
"=",
"wfi",
",",
"role_id",
"=",
"wf_state",
"[",
"'role_id'",
"]",
")",
"inv",
".",
"delete_other_invitations",
"(",
")",
"inv",
".",
"progress",
"=",
"20",
"inv",
".",
"save",
"(",
")",
"except",
"ObjectDoesNotExist",
":",
"current",
".",
"log",
".",
"exception",
"(",
"\"Invitation not found: %s\"",
"%",
"wf_state",
")",
"except",
"MultipleObjectsReturned",
":",
"current",
".",
"log",
".",
"exception",
"(",
"\"Multiple invitations found: %s\"",
"%",
"wf_state",
")",
"wfi",
".",
"step",
"=",
"wf_state",
"[",
"'step'",
"]",
"wfi",
".",
"name",
"=",
"wf_state",
"[",
"'name'",
"]",
"wfi",
".",
"pool",
"=",
"wf_state",
"[",
"'pool'",
"]",
"wfi",
".",
"current_actor_id",
"=",
"str",
"(",
"wf_state",
"[",
"'role_id'",
"]",
")",
"# keys must be str not unicode",
"wfi",
".",
"data",
"=",
"wf_state",
"[",
"'data'",
"]",
"if",
"wf_state",
"[",
"'finished'",
"]",
":",
"wfi",
".",
"finished",
"=",
"True",
"wfi",
".",
"finish_date",
"=",
"wf_state",
"[",
"'finish_date'",
"]",
"wf_cache",
".",
"delete",
"(",
")",
"wfi",
".",
"save",
"(",
")",
"else",
":",
"# if cache already cleared, we have nothing to sync",
"pass"
] |
BG Job for storing wf state to DB
|
[
"BG",
"Job",
"for",
"storing",
"wf",
"state",
"to",
"DB"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L759-L797
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
DiagramXML.get_or_create_by_content
|
def get_or_create_by_content(cls, name, content):
"""
if xml content updated, create a new entry for given wf name
Args:
name: name of wf
content: xml content
Returns (DiagramXML(), bool): A tuple with two members.
(DiagramXML instance and True if it's new or False it's already exists
"""
new = False
diagrams = cls.objects.filter(name=name)
if diagrams:
diagram = diagrams[0]
if diagram.body != content:
new = True
else:
new = True
if new:
diagram = cls(name=name, body=content).save()
return diagram, new
|
python
|
def get_or_create_by_content(cls, name, content):
"""
if xml content updated, create a new entry for given wf name
Args:
name: name of wf
content: xml content
Returns (DiagramXML(), bool): A tuple with two members.
(DiagramXML instance and True if it's new or False it's already exists
"""
new = False
diagrams = cls.objects.filter(name=name)
if diagrams:
diagram = diagrams[0]
if diagram.body != content:
new = True
else:
new = True
if new:
diagram = cls(name=name, body=content).save()
return diagram, new
|
[
"def",
"get_or_create_by_content",
"(",
"cls",
",",
"name",
",",
"content",
")",
":",
"new",
"=",
"False",
"diagrams",
"=",
"cls",
".",
"objects",
".",
"filter",
"(",
"name",
"=",
"name",
")",
"if",
"diagrams",
":",
"diagram",
"=",
"diagrams",
"[",
"0",
"]",
"if",
"diagram",
".",
"body",
"!=",
"content",
":",
"new",
"=",
"True",
"else",
":",
"new",
"=",
"True",
"if",
"new",
":",
"diagram",
"=",
"cls",
"(",
"name",
"=",
"name",
",",
"body",
"=",
"content",
")",
".",
"save",
"(",
")",
"return",
"diagram",
",",
"new"
] |
if xml content updated, create a new entry for given wf name
Args:
name: name of wf
content: xml content
Returns (DiagramXML(), bool): A tuple with two members.
(DiagramXML instance and True if it's new or False it's already exists
|
[
"if",
"xml",
"content",
"updated",
"create",
"a",
"new",
"entry",
"for",
"given",
"wf",
"name",
"Args",
":",
"name",
":",
"name",
"of",
"wf",
"content",
":",
"xml",
"content"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L43-L63
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
BPMNParser.get_description
|
def get_description(self):
"""
Tries to get WF description from 'collabration' or 'process' or 'pariticipant'
Returns str: WF description
"""
paths = ['bpmn:collaboration/bpmn:participant/bpmn:documentation',
'bpmn:collaboration/bpmn:documentation',
'bpmn:process/bpmn:documentation']
for path in paths:
elm = self.root.find(path, NS)
if elm is not None and elm.text:
return elm.text
|
python
|
def get_description(self):
"""
Tries to get WF description from 'collabration' or 'process' or 'pariticipant'
Returns str: WF description
"""
paths = ['bpmn:collaboration/bpmn:participant/bpmn:documentation',
'bpmn:collaboration/bpmn:documentation',
'bpmn:process/bpmn:documentation']
for path in paths:
elm = self.root.find(path, NS)
if elm is not None and elm.text:
return elm.text
|
[
"def",
"get_description",
"(",
"self",
")",
":",
"paths",
"=",
"[",
"'bpmn:collaboration/bpmn:participant/bpmn:documentation'",
",",
"'bpmn:collaboration/bpmn:documentation'",
",",
"'bpmn:process/bpmn:documentation'",
"]",
"for",
"path",
"in",
"paths",
":",
"elm",
"=",
"self",
".",
"root",
".",
"find",
"(",
"path",
",",
"NS",
")",
"if",
"elm",
"is",
"not",
"None",
"and",
"elm",
".",
"text",
":",
"return",
"elm",
".",
"text"
] |
Tries to get WF description from 'collabration' or 'process' or 'pariticipant'
Returns str: WF description
|
[
"Tries",
"to",
"get",
"WF",
"description",
"from",
"collabration",
"or",
"process",
"or",
"pariticipant"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L96-L109
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
BPMNParser.get_name
|
def get_name(self):
"""
Tries to get WF name from 'process' or 'collobration' or 'pariticipant'
Returns:
str. WF name.
"""
paths = ['bpmn:process',
'bpmn:collaboration/bpmn:participant/',
'bpmn:collaboration',
]
for path in paths:
tag = self.root.find(path, NS)
if tag is not None and len(tag):
name = tag.get('name')
if name:
return name
|
python
|
def get_name(self):
"""
Tries to get WF name from 'process' or 'collobration' or 'pariticipant'
Returns:
str. WF name.
"""
paths = ['bpmn:process',
'bpmn:collaboration/bpmn:participant/',
'bpmn:collaboration',
]
for path in paths:
tag = self.root.find(path, NS)
if tag is not None and len(tag):
name = tag.get('name')
if name:
return name
|
[
"def",
"get_name",
"(",
"self",
")",
":",
"paths",
"=",
"[",
"'bpmn:process'",
",",
"'bpmn:collaboration/bpmn:participant/'",
",",
"'bpmn:collaboration'",
",",
"]",
"for",
"path",
"in",
"paths",
":",
"tag",
"=",
"self",
".",
"root",
".",
"find",
"(",
"path",
",",
"NS",
")",
"if",
"tag",
"is",
"not",
"None",
"and",
"len",
"(",
"tag",
")",
":",
"name",
"=",
"tag",
".",
"get",
"(",
"'name'",
")",
"if",
"name",
":",
"return",
"name"
] |
Tries to get WF name from 'process' or 'collobration' or 'pariticipant'
Returns:
str. WF name.
|
[
"Tries",
"to",
"get",
"WF",
"name",
"from",
"process",
"or",
"collobration",
"or",
"pariticipant"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L111-L127
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
BPMNWorkflow.set_xml
|
def set_xml(self, diagram, force=False):
"""
updates xml link if there aren't any running instances of this wf
Args:
diagram: XMLDiagram object
"""
no_of_running = WFInstance.objects.filter(wf=self, finished=False, started=True).count()
if no_of_running and not force:
raise RunningInstancesExist(
"Can't update WF diagram! Running %s WF instances exists for %s" % (
no_of_running, self.name
))
else:
self.xml = diagram
parser = BPMNParser(diagram.body)
self.description = parser.get_description()
self.title = parser.get_name() or self.name.replace('_', ' ').title()
extensions = dict(parser.get_wf_extensions())
self.programmable = extensions.get('programmable', False)
self.task_type = extensions.get('task_type', None)
self.menu_category = extensions.get('menu_category', settings.DEFAULT_WF_CATEGORY_NAME)
self.save()
|
python
|
def set_xml(self, diagram, force=False):
"""
updates xml link if there aren't any running instances of this wf
Args:
diagram: XMLDiagram object
"""
no_of_running = WFInstance.objects.filter(wf=self, finished=False, started=True).count()
if no_of_running and not force:
raise RunningInstancesExist(
"Can't update WF diagram! Running %s WF instances exists for %s" % (
no_of_running, self.name
))
else:
self.xml = diagram
parser = BPMNParser(diagram.body)
self.description = parser.get_description()
self.title = parser.get_name() or self.name.replace('_', ' ').title()
extensions = dict(parser.get_wf_extensions())
self.programmable = extensions.get('programmable', False)
self.task_type = extensions.get('task_type', None)
self.menu_category = extensions.get('menu_category', settings.DEFAULT_WF_CATEGORY_NAME)
self.save()
|
[
"def",
"set_xml",
"(",
"self",
",",
"diagram",
",",
"force",
"=",
"False",
")",
":",
"no_of_running",
"=",
"WFInstance",
".",
"objects",
".",
"filter",
"(",
"wf",
"=",
"self",
",",
"finished",
"=",
"False",
",",
"started",
"=",
"True",
")",
".",
"count",
"(",
")",
"if",
"no_of_running",
"and",
"not",
"force",
":",
"raise",
"RunningInstancesExist",
"(",
"\"Can't update WF diagram! Running %s WF instances exists for %s\"",
"%",
"(",
"no_of_running",
",",
"self",
".",
"name",
")",
")",
"else",
":",
"self",
".",
"xml",
"=",
"diagram",
"parser",
"=",
"BPMNParser",
"(",
"diagram",
".",
"body",
")",
"self",
".",
"description",
"=",
"parser",
".",
"get_description",
"(",
")",
"self",
".",
"title",
"=",
"parser",
".",
"get_name",
"(",
")",
"or",
"self",
".",
"name",
".",
"replace",
"(",
"'_'",
",",
"' '",
")",
".",
"title",
"(",
")",
"extensions",
"=",
"dict",
"(",
"parser",
".",
"get_wf_extensions",
"(",
")",
")",
"self",
".",
"programmable",
"=",
"extensions",
".",
"get",
"(",
"'programmable'",
",",
"False",
")",
"self",
".",
"task_type",
"=",
"extensions",
".",
"get",
"(",
"'task_type'",
",",
"None",
")",
"self",
".",
"menu_category",
"=",
"extensions",
".",
"get",
"(",
"'menu_category'",
",",
"settings",
".",
"DEFAULT_WF_CATEGORY_NAME",
")",
"self",
".",
"save",
"(",
")"
] |
updates xml link if there aren't any running instances of this wf
Args:
diagram: XMLDiagram object
|
[
"updates",
"xml",
"link",
"if",
"there",
"aren",
"t",
"any",
"running",
"instances",
"of",
"this",
"wf",
"Args",
":",
"diagram",
":",
"XMLDiagram",
"object"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L184-L205
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
Task.create_wf_instances
|
def create_wf_instances(self, roles=None):
"""
Creates wf instances.
Args:
roles (list): role list
Returns:
(list): wf instances
"""
# if roles specified then create an instance for each role
# else create only one instance
if roles:
wf_instances = [
WFInstance(
wf=self.wf,
current_actor=role,
task=self,
name=self.wf.name
) for role in roles
]
else:
wf_instances = [
WFInstance(
wf=self.wf,
task=self,
name=self.wf.name
)
]
# if task type is not related with objects save instances immediately.
if self.task_type in ["C", "D"]:
return [wfi.save() for wfi in wf_instances]
# if task type is related with its objects, save populate instances per object
else:
wf_obj_instances = []
for wfi in wf_instances:
role = wfi.current_actor if self.task_type == "A" else None
keys = self.get_object_keys(role)
wf_obj_instances.extend(
[WFInstance(
wf=self.wf,
current_actor=role,
task=self,
name=self.wf.name,
wf_object=key,
wf_object_type=self.object_type
).save() for key in keys]
)
return wf_obj_instances
|
python
|
def create_wf_instances(self, roles=None):
"""
Creates wf instances.
Args:
roles (list): role list
Returns:
(list): wf instances
"""
# if roles specified then create an instance for each role
# else create only one instance
if roles:
wf_instances = [
WFInstance(
wf=self.wf,
current_actor=role,
task=self,
name=self.wf.name
) for role in roles
]
else:
wf_instances = [
WFInstance(
wf=self.wf,
task=self,
name=self.wf.name
)
]
# if task type is not related with objects save instances immediately.
if self.task_type in ["C", "D"]:
return [wfi.save() for wfi in wf_instances]
# if task type is related with its objects, save populate instances per object
else:
wf_obj_instances = []
for wfi in wf_instances:
role = wfi.current_actor if self.task_type == "A" else None
keys = self.get_object_keys(role)
wf_obj_instances.extend(
[WFInstance(
wf=self.wf,
current_actor=role,
task=self,
name=self.wf.name,
wf_object=key,
wf_object_type=self.object_type
).save() for key in keys]
)
return wf_obj_instances
|
[
"def",
"create_wf_instances",
"(",
"self",
",",
"roles",
"=",
"None",
")",
":",
"# if roles specified then create an instance for each role",
"# else create only one instance",
"if",
"roles",
":",
"wf_instances",
"=",
"[",
"WFInstance",
"(",
"wf",
"=",
"self",
".",
"wf",
",",
"current_actor",
"=",
"role",
",",
"task",
"=",
"self",
",",
"name",
"=",
"self",
".",
"wf",
".",
"name",
")",
"for",
"role",
"in",
"roles",
"]",
"else",
":",
"wf_instances",
"=",
"[",
"WFInstance",
"(",
"wf",
"=",
"self",
".",
"wf",
",",
"task",
"=",
"self",
",",
"name",
"=",
"self",
".",
"wf",
".",
"name",
")",
"]",
"# if task type is not related with objects save instances immediately.",
"if",
"self",
".",
"task_type",
"in",
"[",
"\"C\"",
",",
"\"D\"",
"]",
":",
"return",
"[",
"wfi",
".",
"save",
"(",
")",
"for",
"wfi",
"in",
"wf_instances",
"]",
"# if task type is related with its objects, save populate instances per object",
"else",
":",
"wf_obj_instances",
"=",
"[",
"]",
"for",
"wfi",
"in",
"wf_instances",
":",
"role",
"=",
"wfi",
".",
"current_actor",
"if",
"self",
".",
"task_type",
"==",
"\"A\"",
"else",
"None",
"keys",
"=",
"self",
".",
"get_object_keys",
"(",
"role",
")",
"wf_obj_instances",
".",
"extend",
"(",
"[",
"WFInstance",
"(",
"wf",
"=",
"self",
".",
"wf",
",",
"current_actor",
"=",
"role",
",",
"task",
"=",
"self",
",",
"name",
"=",
"self",
".",
"wf",
".",
"name",
",",
"wf_object",
"=",
"key",
",",
"wf_object_type",
"=",
"self",
".",
"object_type",
")",
".",
"save",
"(",
")",
"for",
"key",
"in",
"keys",
"]",
")",
"return",
"wf_obj_instances"
] |
Creates wf instances.
Args:
roles (list): role list
Returns:
(list): wf instances
|
[
"Creates",
"wf",
"instances",
".",
"Args",
":",
"roles",
"(",
"list",
")",
":",
"role",
"list"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L286-L338
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
Task.create_tasks
|
def create_tasks(self):
"""
will create a WFInstance per object
and per TaskInvitation for each role and WFInstance
"""
roles = self.get_roles()
if self.task_type in ["A", "D"]:
instances = self.create_wf_instances(roles=roles)
self.create_task_invitation(instances)
elif self.task_type in ["C", "B"]:
instances = self.create_wf_instances()
self.create_task_invitation(instances, roles)
|
python
|
def create_tasks(self):
"""
will create a WFInstance per object
and per TaskInvitation for each role and WFInstance
"""
roles = self.get_roles()
if self.task_type in ["A", "D"]:
instances = self.create_wf_instances(roles=roles)
self.create_task_invitation(instances)
elif self.task_type in ["C", "B"]:
instances = self.create_wf_instances()
self.create_task_invitation(instances, roles)
|
[
"def",
"create_tasks",
"(",
"self",
")",
":",
"roles",
"=",
"self",
".",
"get_roles",
"(",
")",
"if",
"self",
".",
"task_type",
"in",
"[",
"\"A\"",
",",
"\"D\"",
"]",
":",
"instances",
"=",
"self",
".",
"create_wf_instances",
"(",
"roles",
"=",
"roles",
")",
"self",
".",
"create_task_invitation",
"(",
"instances",
")",
"elif",
"self",
".",
"task_type",
"in",
"[",
"\"C\"",
",",
"\"B\"",
"]",
":",
"instances",
"=",
"self",
".",
"create_wf_instances",
"(",
")",
"self",
".",
"create_task_invitation",
"(",
"instances",
",",
"roles",
")"
] |
will create a WFInstance per object
and per TaskInvitation for each role and WFInstance
|
[
"will",
"create",
"a",
"WFInstance",
"per",
"object",
"and",
"per",
"TaskInvitation",
"for",
"each",
"role",
"and",
"WFInstance"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L354-L367
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
Task.get_object_query_dict
|
def get_object_query_dict(self):
"""returns objects keys according to self.object_query_code
which can be json encoded queryset filter dict or key=value set
in the following format: ```"key=val, key2 = val2 , key3= value with spaces"```
Returns:
(dict): Queryset filtering dicqt
"""
if isinstance(self.object_query_code, dict):
# _DATE_ _DATETIME_
return self.object_query_code
else:
# comma separated, key=value pairs. wrapping spaces will be ignored
# eg: "key=val, key2 = val2 , key3= value with spaces"
return dict(pair.split('=') for pair in self.object_query_code.split(','))
|
python
|
def get_object_query_dict(self):
"""returns objects keys according to self.object_query_code
which can be json encoded queryset filter dict or key=value set
in the following format: ```"key=val, key2 = val2 , key3= value with spaces"```
Returns:
(dict): Queryset filtering dicqt
"""
if isinstance(self.object_query_code, dict):
# _DATE_ _DATETIME_
return self.object_query_code
else:
# comma separated, key=value pairs. wrapping spaces will be ignored
# eg: "key=val, key2 = val2 , key3= value with spaces"
return dict(pair.split('=') for pair in self.object_query_code.split(','))
|
[
"def",
"get_object_query_dict",
"(",
"self",
")",
":",
"if",
"isinstance",
"(",
"self",
".",
"object_query_code",
",",
"dict",
")",
":",
"# _DATE_ _DATETIME_",
"return",
"self",
".",
"object_query_code",
"else",
":",
"# comma separated, key=value pairs. wrapping spaces will be ignored",
"# eg: \"key=val, key2 = val2 , key3= value with spaces\"",
"return",
"dict",
"(",
"pair",
".",
"split",
"(",
"'='",
")",
"for",
"pair",
"in",
"self",
".",
"object_query_code",
".",
"split",
"(",
"','",
")",
")"
] |
returns objects keys according to self.object_query_code
which can be json encoded queryset filter dict or key=value set
in the following format: ```"key=val, key2 = val2 , key3= value with spaces"```
Returns:
(dict): Queryset filtering dicqt
|
[
"returns",
"objects",
"keys",
"according",
"to",
"self",
".",
"object_query_code",
"which",
"can",
"be",
"json",
"encoded",
"queryset",
"filter",
"dict",
"or",
"key",
"=",
"value",
"set",
"in",
"the",
"following",
"format",
":",
"key",
"=",
"val",
"key2",
"=",
"val2",
"key3",
"=",
"value",
"with",
"spaces"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L369-L383
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
Task.get_object_keys
|
def get_object_keys(self, wfi_role=None):
"""returns object keys according to task definition
which can be explicitly selected one object (self.object_key) or
result of a queryset filter.
Returns:
list of object keys
"""
if self.object_key:
return [self.object_key]
if self.object_query_code:
model = model_registry.get_model(self.object_type)
return [m.key for m in
self.get_model_objects(model, wfi_role, **self.get_object_query_dict())]
|
python
|
def get_object_keys(self, wfi_role=None):
"""returns object keys according to task definition
which can be explicitly selected one object (self.object_key) or
result of a queryset filter.
Returns:
list of object keys
"""
if self.object_key:
return [self.object_key]
if self.object_query_code:
model = model_registry.get_model(self.object_type)
return [m.key for m in
self.get_model_objects(model, wfi_role, **self.get_object_query_dict())]
|
[
"def",
"get_object_keys",
"(",
"self",
",",
"wfi_role",
"=",
"None",
")",
":",
"if",
"self",
".",
"object_key",
":",
"return",
"[",
"self",
".",
"object_key",
"]",
"if",
"self",
".",
"object_query_code",
":",
"model",
"=",
"model_registry",
".",
"get_model",
"(",
"self",
".",
"object_type",
")",
"return",
"[",
"m",
".",
"key",
"for",
"m",
"in",
"self",
".",
"get_model_objects",
"(",
"model",
",",
"wfi_role",
",",
"*",
"*",
"self",
".",
"get_object_query_dict",
"(",
")",
")",
"]"
] |
returns object keys according to task definition
which can be explicitly selected one object (self.object_key) or
result of a queryset filter.
Returns:
list of object keys
|
[
"returns",
"object",
"keys",
"according",
"to",
"task",
"definition",
"which",
"can",
"be",
"explicitly",
"selected",
"one",
"object",
"(",
"self",
".",
"object_key",
")",
"or",
"result",
"of",
"a",
"queryset",
"filter",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L385-L398
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
Task.get_model_objects
|
def get_model_objects(model, wfi_role=None, **kwargs):
"""
Fetches model objects by filtering with kwargs
If wfi_role is specified, then we expect kwargs contains a
filter value starting with role,
e.g. {'user': 'role.program.user'}
We replace this `role` key with role instance parameter `wfi_role` and try to get
object that filter value 'role.program.user' points by iterating `getattribute`. At
the end filter argument becomes {'user': user}.
Args:
model (Model): Model class
wfi_role (Role): role instance of wf instance
**kwargs: filter arguments
Returns:
(list): list of model object instances
"""
query_dict = {}
for k, v in kwargs.items():
if isinstance(v, list):
query_dict[k] = [str(x) for x in v]
else:
parse = str(v).split('.')
if parse[0] == 'role' and wfi_role:
query_dict[k] = wfi_role
for i in range(1, len(parse)):
query_dict[k] = query_dict[k].__getattribute__(parse[i])
else:
query_dict[k] = parse[0]
return model.objects.all(**query_dict)
|
python
|
def get_model_objects(model, wfi_role=None, **kwargs):
"""
Fetches model objects by filtering with kwargs
If wfi_role is specified, then we expect kwargs contains a
filter value starting with role,
e.g. {'user': 'role.program.user'}
We replace this `role` key with role instance parameter `wfi_role` and try to get
object that filter value 'role.program.user' points by iterating `getattribute`. At
the end filter argument becomes {'user': user}.
Args:
model (Model): Model class
wfi_role (Role): role instance of wf instance
**kwargs: filter arguments
Returns:
(list): list of model object instances
"""
query_dict = {}
for k, v in kwargs.items():
if isinstance(v, list):
query_dict[k] = [str(x) for x in v]
else:
parse = str(v).split('.')
if parse[0] == 'role' and wfi_role:
query_dict[k] = wfi_role
for i in range(1, len(parse)):
query_dict[k] = query_dict[k].__getattribute__(parse[i])
else:
query_dict[k] = parse[0]
return model.objects.all(**query_dict)
|
[
"def",
"get_model_objects",
"(",
"model",
",",
"wfi_role",
"=",
"None",
",",
"*",
"*",
"kwargs",
")",
":",
"query_dict",
"=",
"{",
"}",
"for",
"k",
",",
"v",
"in",
"kwargs",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"v",
",",
"list",
")",
":",
"query_dict",
"[",
"k",
"]",
"=",
"[",
"str",
"(",
"x",
")",
"for",
"x",
"in",
"v",
"]",
"else",
":",
"parse",
"=",
"str",
"(",
"v",
")",
".",
"split",
"(",
"'.'",
")",
"if",
"parse",
"[",
"0",
"]",
"==",
"'role'",
"and",
"wfi_role",
":",
"query_dict",
"[",
"k",
"]",
"=",
"wfi_role",
"for",
"i",
"in",
"range",
"(",
"1",
",",
"len",
"(",
"parse",
")",
")",
":",
"query_dict",
"[",
"k",
"]",
"=",
"query_dict",
"[",
"k",
"]",
".",
"__getattribute__",
"(",
"parse",
"[",
"i",
"]",
")",
"else",
":",
"query_dict",
"[",
"k",
"]",
"=",
"parse",
"[",
"0",
"]",
"return",
"model",
".",
"objects",
".",
"all",
"(",
"*",
"*",
"query_dict",
")"
] |
Fetches model objects by filtering with kwargs
If wfi_role is specified, then we expect kwargs contains a
filter value starting with role,
e.g. {'user': 'role.program.user'}
We replace this `role` key with role instance parameter `wfi_role` and try to get
object that filter value 'role.program.user' points by iterating `getattribute`. At
the end filter argument becomes {'user': user}.
Args:
model (Model): Model class
wfi_role (Role): role instance of wf instance
**kwargs: filter arguments
Returns:
(list): list of model object instances
|
[
"Fetches",
"model",
"objects",
"by",
"filtering",
"with",
"kwargs"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L401-L435
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
Task.get_roles
|
def get_roles(self):
"""
Returns:
Role instances according to task definition.
"""
if self.role.exist:
# return explicitly selected role
return [self.role]
else:
roles = []
if self.role_query_code:
# use given "role_query_code"
roles = RoleModel.objects.filter(**self.role_query_code)
elif self.unit.exist:
# get roles from selected unit or sub-units of it
if self.recursive_units:
# this returns a list, we're converting it to a Role generator!
roles = (RoleModel.objects.get(k) for k in
UnitModel.get_role_keys(self.unit.key))
else:
roles = RoleModel.objects.filter(unit=self.unit)
elif self.get_roles_from:
# get roles from selected predefined "get_roles_from" method
return ROLE_GETTER_METHODS[self.get_roles_from](RoleModel)
if self.abstract_role.exist and roles:
# apply abstract_role filtering on roles we got
if isinstance(roles, (list, types.GeneratorType)):
roles = [a for a in roles if a.abstract_role.key == self.abstract_role.key]
else:
roles = roles.filter(abstract_role=self.abstract_role)
else:
roles = RoleModel.objects.filter(abstract_role=self.abstract_role)
return roles
|
python
|
def get_roles(self):
"""
Returns:
Role instances according to task definition.
"""
if self.role.exist:
# return explicitly selected role
return [self.role]
else:
roles = []
if self.role_query_code:
# use given "role_query_code"
roles = RoleModel.objects.filter(**self.role_query_code)
elif self.unit.exist:
# get roles from selected unit or sub-units of it
if self.recursive_units:
# this returns a list, we're converting it to a Role generator!
roles = (RoleModel.objects.get(k) for k in
UnitModel.get_role_keys(self.unit.key))
else:
roles = RoleModel.objects.filter(unit=self.unit)
elif self.get_roles_from:
# get roles from selected predefined "get_roles_from" method
return ROLE_GETTER_METHODS[self.get_roles_from](RoleModel)
if self.abstract_role.exist and roles:
# apply abstract_role filtering on roles we got
if isinstance(roles, (list, types.GeneratorType)):
roles = [a for a in roles if a.abstract_role.key == self.abstract_role.key]
else:
roles = roles.filter(abstract_role=self.abstract_role)
else:
roles = RoleModel.objects.filter(abstract_role=self.abstract_role)
return roles
|
[
"def",
"get_roles",
"(",
"self",
")",
":",
"if",
"self",
".",
"role",
".",
"exist",
":",
"# return explicitly selected role",
"return",
"[",
"self",
".",
"role",
"]",
"else",
":",
"roles",
"=",
"[",
"]",
"if",
"self",
".",
"role_query_code",
":",
"# use given \"role_query_code\"",
"roles",
"=",
"RoleModel",
".",
"objects",
".",
"filter",
"(",
"*",
"*",
"self",
".",
"role_query_code",
")",
"elif",
"self",
".",
"unit",
".",
"exist",
":",
"# get roles from selected unit or sub-units of it",
"if",
"self",
".",
"recursive_units",
":",
"# this returns a list, we're converting it to a Role generator!",
"roles",
"=",
"(",
"RoleModel",
".",
"objects",
".",
"get",
"(",
"k",
")",
"for",
"k",
"in",
"UnitModel",
".",
"get_role_keys",
"(",
"self",
".",
"unit",
".",
"key",
")",
")",
"else",
":",
"roles",
"=",
"RoleModel",
".",
"objects",
".",
"filter",
"(",
"unit",
"=",
"self",
".",
"unit",
")",
"elif",
"self",
".",
"get_roles_from",
":",
"# get roles from selected predefined \"get_roles_from\" method",
"return",
"ROLE_GETTER_METHODS",
"[",
"self",
".",
"get_roles_from",
"]",
"(",
"RoleModel",
")",
"if",
"self",
".",
"abstract_role",
".",
"exist",
"and",
"roles",
":",
"# apply abstract_role filtering on roles we got",
"if",
"isinstance",
"(",
"roles",
",",
"(",
"list",
",",
"types",
".",
"GeneratorType",
")",
")",
":",
"roles",
"=",
"[",
"a",
"for",
"a",
"in",
"roles",
"if",
"a",
".",
"abstract_role",
".",
"key",
"==",
"self",
".",
"abstract_role",
".",
"key",
"]",
"else",
":",
"roles",
"=",
"roles",
".",
"filter",
"(",
"abstract_role",
"=",
"self",
".",
"abstract_role",
")",
"else",
":",
"roles",
"=",
"RoleModel",
".",
"objects",
".",
"filter",
"(",
"abstract_role",
"=",
"self",
".",
"abstract_role",
")",
"return",
"roles"
] |
Returns:
Role instances according to task definition.
|
[
"Returns",
":",
"Role",
"instances",
"according",
"to",
"task",
"definition",
"."
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L437-L471
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
Task.post_save
|
def post_save(self):
"""can be removed when a proper task manager admin interface implemented"""
if self.run:
self.run = False
self.create_tasks()
self.save()
|
python
|
def post_save(self):
"""can be removed when a proper task manager admin interface implemented"""
if self.run:
self.run = False
self.create_tasks()
self.save()
|
[
"def",
"post_save",
"(",
"self",
")",
":",
"if",
"self",
".",
"run",
":",
"self",
".",
"run",
"=",
"False",
"self",
".",
"create_tasks",
"(",
")",
"self",
".",
"save",
"(",
")"
] |
can be removed when a proper task manager admin interface implemented
|
[
"can",
"be",
"removed",
"when",
"a",
"proper",
"task",
"manager",
"admin",
"interface",
"implemented"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L553-L558
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
TaskInvitation.delete_other_invitations
|
def delete_other_invitations(self):
"""
When one person use an invitation, we should delete other invitations
"""
# TODO: Signal logged-in users to remove the task from their task list
self.objects.filter(instance=self.instance).exclude(key=self.key).delete()
|
python
|
def delete_other_invitations(self):
"""
When one person use an invitation, we should delete other invitations
"""
# TODO: Signal logged-in users to remove the task from their task list
self.objects.filter(instance=self.instance).exclude(key=self.key).delete()
|
[
"def",
"delete_other_invitations",
"(",
"self",
")",
":",
"# TODO: Signal logged-in users to remove the task from their task list",
"self",
".",
"objects",
".",
"filter",
"(",
"instance",
"=",
"self",
".",
"instance",
")",
".",
"exclude",
"(",
"key",
"=",
"self",
".",
"key",
")",
".",
"delete",
"(",
")"
] |
When one person use an invitation, we should delete other invitations
|
[
"When",
"one",
"person",
"use",
"an",
"invitation",
"we",
"should",
"delete",
"other",
"invitations"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L664-L669
|
train
|
zetaops/zengine
|
zengine/models/workflow_manager.py
|
WFCache.save
|
def save(self, wf_state):
"""
write wf state to DB through MQ >> Worker >> _zops_sync_wf_cache
Args:
wf_state dict: wf state
"""
self.wf_state = wf_state
self.wf_state['role_id'] = self.current.role_id
self.set(self.wf_state)
if self.wf_state['name'] not in settings.EPHEMERAL_WORKFLOWS:
self.publish(job='_zops_sync_wf_cache',
token=self.db_key)
|
python
|
def save(self, wf_state):
"""
write wf state to DB through MQ >> Worker >> _zops_sync_wf_cache
Args:
wf_state dict: wf state
"""
self.wf_state = wf_state
self.wf_state['role_id'] = self.current.role_id
self.set(self.wf_state)
if self.wf_state['name'] not in settings.EPHEMERAL_WORKFLOWS:
self.publish(job='_zops_sync_wf_cache',
token=self.db_key)
|
[
"def",
"save",
"(",
"self",
",",
"wf_state",
")",
":",
"self",
".",
"wf_state",
"=",
"wf_state",
"self",
".",
"wf_state",
"[",
"'role_id'",
"]",
"=",
"self",
".",
"current",
".",
"role_id",
"self",
".",
"set",
"(",
"self",
".",
"wf_state",
")",
"if",
"self",
".",
"wf_state",
"[",
"'name'",
"]",
"not",
"in",
"settings",
".",
"EPHEMERAL_WORKFLOWS",
":",
"self",
".",
"publish",
"(",
"job",
"=",
"'_zops_sync_wf_cache'",
",",
"token",
"=",
"self",
".",
"db_key",
")"
] |
write wf state to DB through MQ >> Worker >> _zops_sync_wf_cache
Args:
wf_state dict: wf state
|
[
"write",
"wf",
"state",
"to",
"DB",
"through",
"MQ",
">>",
"Worker",
">>",
"_zops_sync_wf_cache"
] |
b5bc32d3b37bca799f8985be916f04528ac79e4a
|
https://github.com/zetaops/zengine/blob/b5bc32d3b37bca799f8985be916f04528ac79e4a/zengine/models/workflow_manager.py#L743-L755
|
train
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.