idx int64 0 63k | question stringlengths 53 5.28k | target stringlengths 5 805 |
|---|---|---|
40,100 | def reset ( self ) : self . k = 0. self . x = np . zeros ( 0 ) self . lam = np . zeros ( 0 ) self . nu = np . zeros ( 0 ) self . mu = np . zeros ( 0 ) self . pi = np . zeros ( 0 ) self . status = self . STATUS_UNKNOWN self . error_msg = '' self . obj_sca = 1. | Resets solver data . |
40,101 | def set_parameters ( self , parameters ) : for key , value in list ( parameters . items ( ) ) : if key in self . parameters : self . parameters [ key ] = value | Sets solver parameters . |
40,102 | def factorize_and_solve ( self , A , b ) : self . factorize ( A ) return self . solve ( b ) | Factorizes A and solves Ax = b . |
40,103 | def format_files ( src : str , dest : str , ** fmt_vars : str ) -> None : assert os . path . exists ( src ) assert os . path . exists ( dest ) for filename in os . listdir ( src ) : if filename . endswith ( EXCLUDED_EXTENSIONS ) : continue elif not os . path . isfile ( os . path . join ( src , filename ) ) : continue with open ( os . path . join ( src , filename ) ) as f : output_contents = f . read ( ) . format ( ** fmt_vars ) with open ( os . path . join ( dest , filename ) , 'w' ) as file_obj : file_obj . write ( output_contents ) | Copies all files inside src into dest while formatting the contents of the files into the output . |
40,104 | def analyze ( self , A ) : A = coo_matrix ( A ) self . mumps . set_shape ( A . shape [ 0 ] ) self . mumps . set_centralized_assembled_rows_cols ( A . row + 1 , A . col + 1 ) self . mumps . run ( job = 1 ) self . analyzed = True | Analyzes structure of A . |
40,105 | def factorize_and_solve ( self , A , b ) : A = coo_matrix ( A ) x = b . copy ( ) self . mumps . set_centralized_assembled_values ( A . data ) self . mumps . set_rhs ( x ) self . mumps . run ( job = 5 ) return x | Factorizes A and sovles Ax = b . |
40,106 | def spsolve ( A , b , comm = None ) : assert A . dtype == 'd' and b . dtype == 'd' , "Only double precision supported." with DMumpsContext ( par = 1 , sym = 0 , comm = comm ) as ctx : if ctx . myid == 0 : ctx . set_centralized_sparse ( A . tocoo ( ) ) x = b . copy ( ) ctx . set_rhs ( x ) ctx . set_silent ( ) ctx . run ( job = 6 ) if ctx . myid == 0 : return x | Sparse solve A \ b . |
40,107 | def set_centralized_assembled_rows_cols ( self , irn , jcn ) : if self . myid != 0 : return assert irn . size == jcn . size self . _refs . update ( irn = irn , jcn = jcn ) self . id . nz = irn . size self . id . irn = self . cast_array ( irn ) self . id . jcn = self . cast_array ( jcn ) | Set assembled matrix indices on processor 0 . |
40,108 | def set_centralized_assembled_values ( self , a ) : if self . myid != 0 : return assert a . size == self . id . nz self . _refs . update ( a = a ) self . id . a = self . cast_array ( a ) | Set assembled matrix values on processor 0 . |
40,109 | def set_distributed_assembled ( self , irn_loc , jcn_loc , a_loc ) : self . set_distributed_assembled_rows_cols ( irn_loc , jcn_loc ) self . set_distributed_assembled_values ( a_loc ) | Set the distributed assembled matrix . |
40,110 | def set_distributed_assembled_rows_cols ( self , irn_loc , jcn_loc ) : assert irn_loc . size == jcn_loc . size self . _refs . update ( irn_loc = irn_loc , jcn_loc = jcn_loc ) self . id . nz_loc = irn_loc . size self . id . irn_loc = self . cast_array ( irn_loc ) self . id . jcn_loc = self . cast_array ( jcn_loc ) | Set the distributed assembled matrix row & column numbers . |
40,111 | def set_distributed_assembled_values ( self , a_loc ) : assert a_loc . size == self . _refs [ 'irn_loc' ] . size self . _refs . update ( a_loc = a_loc ) self . id . a_loc = self . cast_array ( a_loc ) | Set the distributed assembled matrix values . |
40,112 | def set_rhs ( self , rhs ) : assert rhs . size == self . id . n self . _refs . update ( rhs = rhs ) self . id . rhs = self . cast_array ( rhs ) | Set the right hand side . This matrix will be modified in place . |
40,113 | def set_silent ( self ) : self . set_icntl ( 1 , - 1 ) self . set_icntl ( 2 , - 1 ) self . set_icntl ( 3 , - 1 ) self . set_icntl ( 4 , 0 ) | Silence most messages . |
40,114 | def destroy ( self ) : if self . id is not None and self . _mumps_c is not None : self . id . job = - 2 self . _mumps_c ( self . id ) self . id = None self . _refs = None | Delete the MUMPS context and release all array references . |
40,115 | def mumps ( self ) : self . _mumps_c ( self . id ) if self . id . infog [ 0 ] < 0 : raise RuntimeError ( "MUMPS error: %d" % self . id . infog [ 0 ] ) | Call MUMPS checking for errors in the return code . |
40,116 | def modify_origin ( self , from_state , from_key ) : if not isinstance ( from_state , string_types ) : raise ValueError ( "Invalid data flow origin port: from_state must be a string" ) if not isinstance ( from_key , int ) : raise ValueError ( "Invalid data flow origin port: from_key must be of type int" ) old_from_state = self . from_state old_from_key = self . from_key self . _from_state = from_state self . _from_key = from_key valid , message = self . _check_validity ( ) if not valid : self . _from_state = old_from_state self . _from_key = old_from_key raise ValueError ( "The data flow origin could not be changed: {0}" . format ( message ) ) | Set both from_state and from_key at the same time to modify data flow origin |
40,117 | def modify_target ( self , to_state , to_key ) : if not isinstance ( to_state , string_types ) : raise ValueError ( "Invalid data flow target port: from_state must be a string" ) if not isinstance ( to_key , int ) : raise ValueError ( "Invalid data flow target port: from_outcome must be of type int" ) old_to_state = self . to_state old_to_key = self . to_key self . _to_state = to_state self . _to_key = to_key valid , message = self . _check_validity ( ) if not valid : self . _to_state = old_to_state self . _to_key = old_to_key raise ValueError ( "The data flow target could not be changed: {0}" . format ( message ) ) | Set both to_state and to_key at the same time to modify data flow target |
40,118 | def code_changed ( self , source ) : if not self . view . textview . get_editable ( ) and not self . view . while_in_set_enabled : if hasattr ( self . view . get_buffer ( ) , 'begin_not_undoable_action' ) : self . view . get_buffer ( ) . begin_not_undoable_action ( ) self . view . set_enabled ( False , self . source_text ) if hasattr ( self . view . get_buffer ( ) , 'end_not_undoable_action' ) : self . view . get_buffer ( ) . end_not_undoable_action ( ) if self . view : self . view . apply_tag ( 'default' ) | Apply checks and adjustments of the TextBuffer and TextView after every change in buffer . |
40,119 | def apply_clicked ( self , button ) : if isinstance ( self . model . state , LibraryState ) : return self . set_script_text ( self . view . get_text ( ) ) | Triggered when the Apply - Shortcut in the editor is triggered . |
40,120 | def set_text ( self , text ) : line_number , line_offset = self . get_cursor_position ( ) self . get_buffer ( ) . set_text ( text ) self . set_cursor_position ( line_number , line_offset ) | The method insert text into the text buffer of the text view and preserves the cursor location . |
40,121 | def reduce_to_parent_states ( models ) : models = set ( models ) models_to_remove = set ( ) for model in models : parent_m = model . parent while parent_m is not None : if parent_m in models : models_to_remove . add ( model ) break parent_m = parent_m . parent for model in models_to_remove : models . remove ( model ) if models_to_remove : logger . debug ( "The selection has been reduced, as it may not contain elements whose children are also selected" ) return models | Remove all models of states that have a state model with parent relation in the list |
40,122 | def updates_selection ( update_selection ) : def handle_update ( selection , * args , ** kwargs ) : old_selection = selection . get_all ( ) update_selection ( selection , * args , ** kwargs ) new_selection = selection . get_all ( ) affected_models = old_selection ^ new_selection if len ( affected_models ) != 0 : deselected_models = old_selection - new_selection selected_models = new_selection - old_selection map ( selection . relieve_model , deselected_models ) map ( selection . observe_model , selected_models ) selection . update_core_element_lists ( ) if selection . focus and selection . focus not in new_selection : del selection . focus affected_classes = set ( model . core_element . __class__ for model in affected_models ) msg_namedtuple = SelectionChangedSignalMsg ( update_selection . __name__ , new_selection , old_selection , affected_classes ) selection . selection_changed_signal . emit ( msg_namedtuple ) if selection . parent_signal is not None : selection . parent_signal . emit ( msg_namedtuple ) return handle_update | Decorator indicating that the decorated method could change the selection |
40,123 | def extend_selection ( ) : from rafcon . gui . singleton import main_window_controller currently_pressed_keys = main_window_controller . currently_pressed_keys if main_window_controller else set ( ) if any ( key in currently_pressed_keys for key in [ constants . EXTEND_SELECTION_KEY , constants . EXTEND_SELECTION_KEY_ALT ] ) : return True return False | Checks is the selection is to be extended |
40,124 | def _check_model_types ( self , models ) : if not hasattr ( models , "__iter__" ) : models = { models } if not all ( [ isinstance ( model , ( AbstractStateModel , StateElementModel ) ) for model in models ] ) : raise TypeError ( "The selection supports only models with base class AbstractStateModel or " "StateElementModel, see handed elements {0}" . format ( models ) ) return models if isinstance ( models , set ) else set ( models ) | Check types of passed models for correctness and in case raise exception |
40,125 | def handle_prepared_selection_of_core_class_elements ( self , core_class , models ) : if extend_selection ( ) : self . _selected . difference_update ( self . get_selected_elements_of_core_class ( core_class ) ) else : self . _selected . clear ( ) models = self . _check_model_types ( models ) if len ( models ) > 1 : models = reduce_to_parent_states ( models ) self . _selected . update ( models ) | Handles the selection for TreeStore widgets maintaining lists of a specific core_class elements |
40,126 | def handle_new_selection ( self , models ) : models = self . _check_model_types ( models ) if extend_selection ( ) : already_selected_elements = models & self . _selected newly_selected_elements = models - self . _selected self . _selected . difference_update ( already_selected_elements ) self . _selected . update ( newly_selected_elements ) else : self . _selected = models self . _selected = reduce_to_parent_states ( self . _selected ) | Handles the selection for generic widgets |
40,127 | def focus ( self , model ) : if model is None : del self . focus return self . _check_model_types ( model ) self . add ( model ) focus_msg = FocusSignalMsg ( model , self . _focus ) self . _focus = model self . _selected . add ( model ) self . _selected = reduce_to_parent_states ( self . _selected ) self . focus_signal . emit ( focus_msg ) | Sets the passed model as focused element |
40,128 | def focus ( self ) : focus_msg = FocusSignalMsg ( None , self . _focus ) self . _focus = None self . focus_signal . emit ( focus_msg ) | Unsets the focused element |
40,129 | def update_core_element_lists ( self ) : def get_selected_elements_of_core_class ( core_class ) : return set ( element for element in self . _selected if isinstance ( element . core_element , core_class ) ) self . _states = get_selected_elements_of_core_class ( State ) self . _transitions = get_selected_elements_of_core_class ( Transition ) self . _data_flows = get_selected_elements_of_core_class ( DataFlow ) self . _input_data_ports = get_selected_elements_of_core_class ( InputDataPort ) self . _output_data_ports = get_selected_elements_of_core_class ( OutputDataPort ) self . _scoped_variables = get_selected_elements_of_core_class ( ScopedVariable ) self . _outcomes = get_selected_elements_of_core_class ( Outcome ) | Maintains inner lists of selected elements with a specific core element class |
40,130 | def get_selected_elements_of_core_class ( self , core_element_type ) : if core_element_type is Outcome : return self . outcomes elif core_element_type is InputDataPort : return self . input_data_ports elif core_element_type is OutputDataPort : return self . output_data_ports elif core_element_type is ScopedVariable : return self . scoped_variables elif core_element_type is Transition : return self . transitions elif core_element_type is DataFlow : return self . data_flows elif core_element_type is State : return self . states raise RuntimeError ( "Invalid core element type: " + core_element_type ) | Returns all selected elements having the specified core_element_type as state element class |
40,131 | def is_selected ( self , model ) : if model is None : return len ( self . _selected ) == 0 return model in self . _selected | Checks whether the given model is selected |
40,132 | def execute_command_with_path_in_process ( command , path , shell = False , cwd = None , logger = None ) : if logger is None : logger = _logger logger . debug ( "Opening path with command: {0} {1}" . format ( command , path ) ) args = shlex . split ( '{0} "{1}"' . format ( command , path ) ) try : subprocess . Popen ( args , shell = shell , cwd = cwd ) return True except OSError as e : logger . error ( 'The operating system raised an error: {}' . format ( e ) ) return False | Executes a specific command in a separate process with a path as argument . |
40,133 | def execute_command_in_process ( command , shell = False , cwd = None , logger = None ) : if logger is None : logger = _logger logger . debug ( "Run shell command: {0}" . format ( command ) ) try : subprocess . Popen ( command , shell = shell , cwd = cwd ) return True except OSError as e : logger . error ( 'The operating system raised an error: {}' . format ( e ) ) return False | Executes a specific command in a separate process |
40,134 | def _load_child_state_models ( self , load_meta_data ) : self . states = { } child_states = self . state . states for child_state in child_states . values ( ) : model_class = get_state_model_class_for_state ( child_state ) if model_class is not None : self . _add_model ( self . states , child_state , model_class , child_state . state_id , load_meta_data ) else : logger . error ( "Unknown state type '{type:s}'. Cannot create model." . format ( type = type ( child_state ) ) ) | Adds models for each child state of the state |
40,135 | def _load_scoped_variable_models ( self ) : self . scoped_variables = [ ] for scoped_variable in self . state . scoped_variables . values ( ) : self . _add_model ( self . scoped_variables , scoped_variable , ScopedVariableModel ) | Adds models for each scoped variable of the state |
40,136 | def _load_data_flow_models ( self ) : self . data_flows = [ ] for data_flow in self . state . data_flows . values ( ) : self . _add_model ( self . data_flows , data_flow , DataFlowModel ) | Adds models for each data flow of the state |
40,137 | def _load_transition_models ( self ) : self . transitions = [ ] for transition in self . state . transitions . values ( ) : self . _add_model ( self . transitions , transition , TransitionModel ) | Adds models for each transition of the state |
40,138 | def update_child_models ( self , _ , name , info ) : if info . method_name in [ 'start_state_id' , 'add_transition' , 'remove_transition' ] : self . update_child_is_start ( ) if info . method_name in [ "add_transition" , "remove_transition" , "transitions" ] : ( model_list , data_list , model_name , model_class , model_key ) = self . _get_model_info ( "transition" ) elif info . method_name in [ "add_data_flow" , "remove_data_flow" , "data_flows" ] : ( model_list , data_list , model_name , model_class , model_key ) = self . _get_model_info ( "data_flow" ) elif info . method_name in [ "add_state" , "remove_state" , "states" ] : ( model_list , data_list , model_name , model_class , model_key ) = self . _get_model_info ( "state" , info ) elif info . method_name in [ "add_scoped_variable" , "remove_scoped_variable" , "scoped_variables" ] : ( model_list , data_list , model_name , model_class , model_key ) = self . _get_model_info ( "scoped_variable" ) else : return if isinstance ( info . result , Exception ) : pass elif "add" in info . method_name : self . add_missing_model ( model_list , data_list , model_name , model_class , model_key ) elif "remove" in info . method_name : destroy = info . kwargs . get ( 'destroy' , True ) recursive = info . kwargs . get ( 'recursive' , True ) self . remove_specific_model ( model_list , info . result , model_key , recursive , destroy ) elif info . method_name in [ "transitions" , "data_flows" , "states" , "scoped_variables" ] : self . re_initiate_model_list ( model_list , data_list , model_name , model_class , model_key ) | This method is always triggered when the state model changes |
40,139 | def get_scoped_variable_m ( self , data_port_id ) : for scoped_variable_m in self . scoped_variables : if scoped_variable_m . scoped_variable . data_port_id == data_port_id : return scoped_variable_m return None | Returns the scoped variable model for the given data port id |
40,140 | def get_transition_m ( self , transition_id ) : for transition_m in self . transitions : if transition_m . transition . transition_id == transition_id : return transition_m return None | Searches and return the transition model with the given in the given container state model |
40,141 | def get_data_flow_m ( self , data_flow_id ) : for data_flow_m in self . data_flows : if data_flow_m . data_flow . data_flow_id == data_flow_id : return data_flow_m return None | Searches and return the data flow model with the given in the given container state model |
40,142 | def store_meta_data ( self , copy_path = None ) : super ( ContainerStateModel , self ) . store_meta_data ( copy_path ) for state_key , state in self . states . items ( ) : state . store_meta_data ( copy_path ) | Store meta data of container states to the filesystem |
40,143 | def add_state_machine ( widget , event = None ) : logger . debug ( "Creating new state-machine..." ) root_state = HierarchyState ( "new root state" ) state_machine = StateMachine ( root_state ) rafcon . core . singleton . state_machine_manager . add_state_machine ( state_machine ) | Create a new state - machine when the user clicks on the + next to the tabs |
40,144 | def register_actions ( self , shortcut_manager ) : shortcut_manager . add_callback_for_action ( 'close' , self . on_close_shortcut ) super ( StateMachinesEditorController , self ) . register_actions ( shortcut_manager ) | Register callback methods fot triggered actions . |
40,145 | def close_state_machine ( self , widget , page_number , event = None ) : page = widget . get_nth_page ( page_number ) for tab_info in self . tabs . values ( ) : if tab_info [ 'page' ] is page : state_machine_m = tab_info [ 'state_machine_m' ] self . on_close_clicked ( event , state_machine_m , None , force = False ) return | Triggered when the close button in the tab is clicked |
40,146 | def add_graphical_state_machine_editor ( self , state_machine_m ) : assert isinstance ( state_machine_m , StateMachineModel ) sm_id = state_machine_m . state_machine . state_machine_id logger . debug ( "Create new graphical editor for state machine with id %s" % str ( sm_id ) ) graphical_editor_view = GraphicalEditorGaphasView ( state_machine_m ) graphical_editor_ctrl = GraphicalEditorGaphasController ( state_machine_m , graphical_editor_view ) self . add_controller ( sm_id , graphical_editor_ctrl ) tab , tab_label = create_tab_header ( '' , self . on_close_clicked , self . on_mouse_right_click , state_machine_m , 'refused' ) set_tab_label_texts ( tab_label , state_machine_m , state_machine_m . state_machine . marked_dirty ) page = graphical_editor_view [ 'main_frame' ] self . view . notebook . append_page ( page , tab ) self . view . notebook . set_tab_reorderable ( page , True ) page . show_all ( ) self . tabs [ sm_id ] = { 'page' : page , 'state_machine_m' : state_machine_m , 'file_system_path' : state_machine_m . state_machine . file_system_path , 'marked_dirty' : state_machine_m . state_machine . marked_dirty , 'root_state_name' : state_machine_m . state_machine . root_state . name } self . observe_model ( state_machine_m ) graphical_editor_view . show ( ) self . view . notebook . show ( ) self . last_focused_state_machine_ids . append ( sm_id ) | Add to for new state machine |
40,147 | def notification_selected_sm_changed ( self , model , prop_name , info ) : selected_state_machine_id = self . model . selected_state_machine_id if selected_state_machine_id is None : return page_id = self . get_page_num ( selected_state_machine_id ) number_of_pages = self . view [ "notebook" ] . get_n_pages ( ) old_label_colors = list ( range ( number_of_pages ) ) for p in range ( number_of_pages ) : page = self . view [ "notebook" ] . get_nth_page ( p ) label = self . view [ "notebook" ] . get_tab_label ( page ) . get_child ( ) . get_children ( ) [ 0 ] old_label_colors [ p ] = label . get_style_context ( ) . get_color ( Gtk . StateType . NORMAL ) if not self . view . notebook . get_current_page ( ) == page_id : self . view . notebook . set_current_page ( page_id ) for p in range ( number_of_pages ) : page = self . view [ "notebook" ] . get_nth_page ( p ) label = self . view [ "notebook" ] . get_tab_label ( page ) . get_child ( ) . get_children ( ) [ 0 ] style = label . get_style_context ( ) | If a new state machine is selected make sure the tab is open |
40,148 | def update_state_machine_tab_label ( self , state_machine_m ) : sm_id = state_machine_m . state_machine . state_machine_id if sm_id in self . tabs : sm = state_machine_m . state_machine if not self . tabs [ sm_id ] [ 'marked_dirty' ] == sm . marked_dirty or not self . tabs [ sm_id ] [ 'file_system_path' ] == sm . file_system_path or not self . tabs [ sm_id ] [ 'root_state_name' ] == sm . root_state . name : label = self . view [ "notebook" ] . get_tab_label ( self . tabs [ sm_id ] [ "page" ] ) . get_child ( ) . get_children ( ) [ 0 ] set_tab_label_texts ( label , state_machine_m , unsaved_changes = sm . marked_dirty ) self . tabs [ sm_id ] [ 'file_system_path' ] = sm . file_system_path self . tabs [ sm_id ] [ 'marked_dirty' ] = sm . marked_dirty self . tabs [ sm_id ] [ 'root_state_name' ] = sm . root_state . name else : logger . warning ( "State machine '{0}' tab label can not be updated there is no tab." . format ( sm_id ) ) | Updates tab label if needed because system path root state name or marked_dirty flag changed |
40,149 | def on_close_clicked ( self , event , state_machine_m , result , force = False ) : from rafcon . core . singleton import state_machine_execution_engine , state_machine_manager force = True if event is not None and hasattr ( event , 'state' ) and event . get_state ( ) & Gdk . ModifierType . SHIFT_MASK and event . get_state ( ) & Gdk . ModifierType . CONTROL_MASK else force def remove_state_machine_m ( ) : state_machine_id = state_machine_m . state_machine . state_machine_id if state_machine_id in self . model . state_machine_manager . state_machines : self . model . state_machine_manager . remove_state_machine ( state_machine_id ) def push_sm_running_dialog ( ) : message_string = "The state machine is still running. Are you sure you want to close?" dialog = RAFCONButtonDialog ( message_string , [ "Stop and close" , "Cancel" ] , message_type = Gtk . MessageType . QUESTION , parent = self . get_root_window ( ) ) response_id = dialog . run ( ) dialog . destroy ( ) if response_id == 1 : logger . debug ( "State machine execution is being stopped" ) state_machine_execution_engine . stop ( ) state_machine_execution_engine . join ( ) rafcon . gui . utils . wait_for_gui ( ) remove_state_machine_m ( ) return True elif response_id == 2 : logger . debug ( "State machine execution will keep running" ) return False def push_sm_dirty_dialog ( ) : sm_id = state_machine_m . state_machine . state_machine_id root_state_name = state_machine_m . root_state . state . name message_string = "There are unsaved changes in the state machine '{0}' with id {1}. Do you want to close " "the state machine anyway?" . format ( root_state_name , sm_id ) dialog = RAFCONButtonDialog ( message_string , [ "Close without saving" , "Cancel" ] , message_type = Gtk . MessageType . QUESTION , parent = self . get_root_window ( ) ) response_id = dialog . run ( ) dialog . destroy ( ) if response_id == 1 : remove_state_machine_m ( ) return True else : logger . debug ( "Closing of state machine canceled" ) return False if not state_machine_execution_engine . finished_or_stopped ( ) and state_machine_manager . active_state_machine_id == state_machine_m . state_machine . state_machine_id : return push_sm_running_dialog ( ) elif force : remove_state_machine_m ( ) return True elif state_machine_m . state_machine . marked_dirty : return push_sm_dirty_dialog ( ) else : remove_state_machine_m ( ) return True | Triggered when the close button of a state machine tab is clicked |
40,150 | def close_all_pages ( self ) : state_machine_m_list = [ tab [ 'state_machine_m' ] for tab in self . tabs . values ( ) ] for state_machine_m in state_machine_m_list : self . on_close_clicked ( None , state_machine_m , None , force = True ) | Closes all tabs of the state machines editor . |
40,151 | def refresh_state_machines ( self , state_machine_ids ) : currently_selected_sm_id = None if self . model . get_selected_state_machine_model ( ) : currently_selected_sm_id = self . model . get_selected_state_machine_model ( ) . state_machine . state_machine_id state_machine_path_by_sm_id = { } page_num_by_sm_id = { } for sm_id , sm in self . model . state_machine_manager . state_machines . items ( ) : if sm_id in state_machine_ids and sm . file_system_path is not None : state_machine_path_by_sm_id [ sm_id ] = sm . file_system_path page_num_by_sm_id [ sm_id ] = self . get_page_num ( sm_id ) for sm_id in state_machine_ids : was_closed = self . on_close_clicked ( None , self . model . state_machines [ sm_id ] , None , force = True ) if not was_closed and sm_id in page_num_by_sm_id : logger . info ( "State machine with id {0} will not be re-open because was not closed." . format ( sm_id ) ) del state_machine_path_by_sm_id [ sm_id ] del page_num_by_sm_id [ sm_id ] try : self . model . state_machine_manager . open_state_machines ( state_machine_path_by_sm_id ) except AttributeError as e : logger . warning ( "Not all state machines were re-open because {0}" . format ( e ) ) import rafcon . gui . utils rafcon . gui . utils . wait_for_gui ( ) self . rearrange_state_machines ( page_num_by_sm_id ) if currently_selected_sm_id : if currently_selected_sm_id in self . model . state_machine_manager . state_machines : self . set_active_state_machine ( currently_selected_sm_id ) | Refresh list af state machine tabs |
40,152 | def refresh_all_state_machines ( self ) : self . refresh_state_machines ( list ( self . model . state_machine_manager . state_machines . keys ( ) ) ) | Refreshes all state machine tabs |
40,153 | def execution_engine_model_changed ( self , model , prop_name , info ) : notebook = self . view [ 'notebook' ] active_state_machine_id = self . model . state_machine_manager . active_state_machine_id if active_state_machine_id is None : for tab in self . tabs . values ( ) : label = notebook . get_tab_label ( tab [ 'page' ] ) . get_child ( ) . get_children ( ) [ 0 ] if label . get_style_context ( ) . has_class ( constants . execution_running_style_class ) : label . get_style_context ( ) . remove_class ( constants . execution_running_style_class ) else : page = self . get_page_for_state_machine_id ( active_state_machine_id ) if page : label = notebook . get_tab_label ( page ) . get_child ( ) . get_children ( ) [ 0 ] label . get_style_context ( ) . add_class ( constants . execution_running_style_class ) | High light active state machine . |
40,154 | def meta_dump_or_deepcopy ( meta ) : if DEBUG_META_REFERENCES : from rafcon . gui . helpers . meta_data import meta_data_reference_check meta_data_reference_check ( meta ) return copy . deepcopy ( meta ) | Function to observe meta data vivi - dict copy process and to debug it at one point |
40,155 | def get_cached_image ( self , width , height , zoom , parameters = None , clear = False ) : global MAX_ALLOWED_AREA if not parameters : parameters = { } if self . __compare_parameters ( width , height , zoom , parameters ) and not clear : return True , self . __image , self . __zoom while True : try : self . __limiting_multiplicator = 1 area = width * zoom * self . __zoom_multiplicator * height * zoom * self . __zoom_multiplicator if area > MAX_ALLOWED_AREA : self . __limiting_multiplicator = sqrt ( MAX_ALLOWED_AREA / area ) image = ImageSurface ( self . __format , int ( ceil ( width * zoom * self . multiplicator ) ) , int ( ceil ( height * zoom * self . multiplicator ) ) ) break except Error : MAX_ALLOWED_AREA *= 0.8 self . __set_cached_image ( image , width , height , zoom , parameters ) return False , self . __image , zoom | Get ImageSurface object if possible cached |
40,156 | def copy_image_to_context ( self , context , position , rotation = 0 , zoom = None ) : if not zoom : zoom = self . __zoom zoom_multiplicator = zoom * self . multiplicator context . save ( ) context . scale ( 1. / zoom_multiplicator , 1. / zoom_multiplicator ) image_position = round ( position [ 0 ] * zoom_multiplicator ) , round ( position [ 1 ] * zoom_multiplicator ) context . translate ( * image_position ) context . rotate ( rotation ) context . set_source_surface ( self . __image , 0 , 0 ) context . paint ( ) context . restore ( ) | Draw a cached image on the context |
40,157 | def get_context_for_image ( self , zoom ) : cairo_context = Context ( self . __image ) cairo_context . scale ( zoom * self . multiplicator , zoom * self . multiplicator ) return cairo_context | Creates a temporary cairo context for the image surface |
40,158 | def __compare_parameters ( self , width , height , zoom , parameters ) : if not global_gui_config . get_config_value ( 'ENABLE_CACHING' , True ) : return False if not self . __image : return False if self . __width != width or self . __height != height : return False if zoom > self . __zoom * self . __zoom_multiplicator : return False if zoom < self . __zoom / self . __zoom_multiplicator : return False for key in parameters : try : if key not in self . __last_parameters or self . __last_parameters [ key ] != parameters [ key ] : return False except ( AttributeError , ValueError ) : try : import numpy if isinstance ( self . __last_parameters [ key ] , numpy . ndarray ) : return numpy . array_equal ( self . __last_parameters [ key ] , parameters [ key ] ) except ImportError : return False return False return True | Compare parameters for equality |
40,159 | def post_setup_plugins ( parser_result ) : if not isinstance ( parser_result , dict ) : parser_result = vars ( parser_result ) plugins . run_post_inits ( parser_result ) | Calls the post init hubs |
40,160 | def setup_environment ( ) : try : from gi . repository import GLib user_data_folder = GLib . get_user_data_dir ( ) except ImportError : user_data_folder = join ( os . path . expanduser ( "~" ) , ".local" , "share" ) rafcon_root_path = dirname ( realpath ( rafcon . __file__ ) ) user_library_folder = join ( user_data_folder , "rafcon" , "libraries" ) if not os . environ . get ( 'RAFCON_LIB_PATH' , None ) : if exists ( user_library_folder ) : os . environ [ 'RAFCON_LIB_PATH' ] = user_library_folder else : os . environ [ 'RAFCON_LIB_PATH' ] = join ( dirname ( dirname ( rafcon_root_path ) ) , 'share' , 'libraries' ) if sys . version_info >= ( 3 , ) : import builtins as builtins23 else : import __builtin__ as builtins23 if "_" not in builtins23 . __dict__ : builtins23 . __dict__ [ "_" ] = lambda s : s | Ensures that the environmental variable RAFCON_LIB_PATH is existent |
40,161 | def parse_state_machine_path ( path ) : sm_root_file = join ( path , storage . STATEMACHINE_FILE ) if exists ( sm_root_file ) : return path else : sm_root_file = join ( path , storage . STATEMACHINE_FILE_OLD ) if exists ( sm_root_file ) : return path raise argparse . ArgumentTypeError ( "Failed to open {0}: {1} not found in path" . format ( path , storage . STATEMACHINE_FILE ) ) | Parser for argparse checking pfor a proper state machine path |
40,162 | def setup_configuration ( config_path ) : if config_path is not None : config_path , config_file = filesystem . separate_folder_path_and_file_name ( config_path ) global_config . load ( config_file = config_file , path = config_path ) else : global_config . load ( path = config_path ) core_singletons . library_manager . initialize ( ) | Loads the core configuration from the specified path and uses its content for further setup |
40,163 | def open_state_machine ( state_machine_path ) : sm = storage . load_state_machine_from_path ( state_machine_path ) core_singletons . state_machine_manager . add_state_machine ( sm ) return sm | Executes the specified state machine |
40,164 | def wait_for_state_machine_finished ( state_machine ) : global _user_abort from rafcon . core . states . execution_state import ExecutionState if not isinstance ( state_machine . root_state , ExecutionState ) : while len ( state_machine . execution_histories [ 0 ] ) < 1 : time . sleep ( 0.1 ) else : time . sleep ( 0.5 ) while state_machine . root_state . state_execution_status is not StateExecutionStatus . INACTIVE : try : state_machine . root_state . concurrency_queue . get ( timeout = 1 ) if _user_abort : return except Empty : pass logger . verbose ( "RAFCON live signal" ) | wait for a state machine to finish its execution |
40,165 | def stop_reactor_on_state_machine_finish ( state_machine ) : wait_for_state_machine_finished ( state_machine ) from twisted . internet import reactor if reactor . running : plugins . run_hook ( "pre_destruction" ) reactor . callFromThread ( reactor . stop ) | Wait for a state machine to be finished and stops the reactor |
40,166 | async def wait_until_ready ( self , timeout : Optional [ float ] = None , no_raise : bool = False ) -> bool : if self . node . ready . is_set ( ) : return True try : return await self . node . wait_until_ready ( timeout = timeout ) except asyncio . TimeoutError : if no_raise : return False else : raise | Waits for the underlying node to become ready . |
40,167 | async def connect ( self ) : await self . node . join_voice_channel ( self . channel . guild . id , self . channel . id ) | Connects to the voice channel associated with this Player . |
40,168 | async def move_to ( self , channel : discord . VoiceChannel ) : if channel . guild != self . channel . guild : raise TypeError ( "Cannot move to a different guild." ) self . channel = channel await self . connect ( ) | Moves this player to a voice channel . |
40,169 | async def disconnect ( self , requested = True ) : if self . state == PlayerState . DISCONNECTING : return await self . update_state ( PlayerState . DISCONNECTING ) if not requested : log . debug ( f"Forcing player disconnect for guild {self.channel.guild.id}" f" due to player manager request." ) guild_id = self . channel . guild . id voice_ws = self . node . get_voice_ws ( guild_id ) if not voice_ws . closed : await voice_ws . voice_state ( guild_id , None ) await self . node . destroy_guild ( guild_id ) await self . close ( ) self . manager . remove_player ( self ) | Disconnects this player from it s voice channel . |
40,170 | async def handle_event ( self , event : "node.LavalinkEvents" , extra ) : if event == LavalinkEvents . TRACK_END : if extra == TrackEndReason . FINISHED : await self . play ( ) else : self . _is_playing = False | Handles various Lavalink Events . |
40,171 | async def handle_player_update ( self , state : "node.PlayerState" ) : if state . position > self . position : self . _is_playing = True self . position = state . position | Handles player updates from lavalink . |
40,172 | def add ( self , requester : discord . User , track : Track ) : track . requester = requester self . queue . append ( track ) | Adds a track to the queue . |
40,173 | async def play ( self ) : if self . repeat and self . current is not None : self . queue . append ( self . current ) self . current = None self . position = 0 self . _paused = False if not self . queue : await self . stop ( ) else : self . _is_playing = True if self . shuffle : track = self . queue . pop ( randrange ( len ( self . queue ) ) ) else : track = self . queue . pop ( 0 ) self . current = track log . debug ( "Assigned current." ) await self . node . play ( self . channel . guild . id , track ) | Starts playback from lavalink . |
40,174 | async def stop ( self ) : await self . node . stop ( self . channel . guild . id ) self . queue = [ ] self . current = None self . position = 0 self . _paused = False | Stops playback from lavalink . |
40,175 | async def pause ( self , pause : bool = True ) : self . _paused = pause await self . node . pause ( self . channel . guild . id , pause ) | Pauses the current song . |
40,176 | async def set_volume ( self , volume : int ) : self . _volume = max ( min ( volume , 150 ) , 0 ) await self . node . volume ( self . channel . guild . id , self . volume ) | Sets the volume of Lavalink . |
40,177 | async def seek ( self , position : int ) : if self . current . seekable : position = max ( min ( position , self . current . length ) , 0 ) await self . node . seek ( self . channel . guild . id , position ) | If the track allows it seeks to a position . |
40,178 | def get_player ( self , guild_id : int ) -> Player : if guild_id in self . _player_dict : return self . _player_dict [ guild_id ] raise KeyError ( "No such player for that guild." ) | Gets a Player object from a guild ID . |
40,179 | async def disconnect ( self ) : for p in tuple ( self . players ) : await p . disconnect ( requested = False ) log . debug ( "Disconnected players." ) | Disconnects all players . |
40,180 | def resource_filename ( package_or_requirement , resource_name ) : if pkg_resources . resource_exists ( package_or_requirement , resource_name ) : return pkg_resources . resource_filename ( package_or_requirement , resource_name ) path = _search_in_share_folders ( package_or_requirement , resource_name ) if path : return path raise RuntimeError ( "Resource {} not found in {}" . format ( package_or_requirement , resource_name ) ) | Similar to pkg_resources . resource_filename but if the resource it not found via pkg_resources it also looks in a predefined list of paths in order to find the resource |
40,181 | def resource_exists ( package_or_requirement , resource_name ) : if pkg_resources . resource_exists ( package_or_requirement , resource_name ) : return True path = _search_in_share_folders ( package_or_requirement , resource_name ) return True if path else False | Similar to pkg_resources . resource_exists but if the resource it not found via pkg_resources it also looks in a predefined list of paths in order to find the resource |
40,182 | def resource_string ( package_or_requirement , resource_name ) : with open ( resource_filename ( package_or_requirement , resource_name ) , 'r' ) as resource_file : return resource_file . read ( ) | Similar to pkg_resources . resource_string but if the resource it not found via pkg_resources it also looks in a predefined list of paths in order to find the resource |
40,183 | def resource_listdir ( package_or_requirement , relative_path ) : path = resource_filename ( package_or_requirement , relative_path ) only_files = [ f for f in listdir ( path ) if isfile ( join ( path , f ) ) ] return only_files | Similar to pkg_resources . resource_listdir but if the resource it not found via pkg_resources it also looks in a predefined list of paths in order to find the resource |
40,184 | def load_plugins ( ) : plugins = os . environ . get ( 'RAFCON_PLUGIN_PATH' , '' ) plugin_list = set ( plugins . split ( os . pathsep ) ) global plugin_dict for plugin_path in plugin_list : if not plugin_path : continue plugin_path = os . path . expandvars ( os . path . expanduser ( plugin_path ) ) . strip ( ) if not os . path . exists ( plugin_path ) : logger . error ( "The specified plugin path does not exist: {}" . format ( plugin_path ) ) continue dir_name , plugin_name = os . path . split ( plugin_path . rstrip ( '/' ) ) logger . info ( "Found plugin '{}' at {}" . format ( plugin_name , plugin_path ) ) sys . path . insert ( 0 , dir_name ) if plugin_name in plugin_dict : logger . error ( "Plugin '{}' already loaded" . format ( plugin_name ) ) else : try : module = importlib . import_module ( plugin_name ) plugin_dict [ plugin_name ] = module logger . info ( "Successfully loaded plugin '{}'" . format ( plugin_name ) ) except ImportError as e : logger . error ( "Could not import plugin '{}': {}\n{}" . format ( plugin_name , e , str ( traceback . format_exc ( ) ) ) ) | Loads all plugins specified in the RAFCON_PLUGIN_PATH environment variable |
40,185 | def run_hook ( hook_name , * args , ** kwargs ) : for module in plugin_dict . values ( ) : if hasattr ( module , "hooks" ) and callable ( getattr ( module . hooks , hook_name , None ) ) : getattr ( module . hooks , hook_name ) ( * args , ** kwargs ) | Runs the passed hook on all registered plugins |
40,186 | def get_state_model_class_for_state ( state ) : from rafcon . gui . models . state import StateModel from rafcon . gui . models . container_state import ContainerStateModel from rafcon . gui . models . library_state import LibraryStateModel if isinstance ( state , ContainerState ) : return ContainerStateModel elif isinstance ( state , LibraryState ) : return LibraryStateModel elif isinstance ( state , State ) : return StateModel else : logger . warning ( "There is not model for state of type {0} {1}" . format ( type ( state ) , state ) ) return None | Determines the model required for the given state class |
40,187 | def update_is_start ( self ) : self . is_start = self . state . is_root_state or self . parent is None or isinstance ( self . parent . state , LibraryState ) or self . state . state_id == self . state . parent . start_state_id | Updates the is_start property of the state A state is a start state if it is the root state it has no parent the parent is a LibraryState or the state s state_id is identical with the ContainerState . start_state_id of the ContainerState it is within . |
40,188 | def get_state_machine_m ( self , two_factor_check = True ) : from rafcon . gui . singleton import state_machine_manager_model state_machine = self . state . get_state_machine ( ) if state_machine : if state_machine . state_machine_id in state_machine_manager_model . state_machines : sm_m = state_machine_manager_model . state_machines [ state_machine . state_machine_id ] if not two_factor_check or sm_m . get_state_model_by_path ( self . state . get_path ( ) ) is self : return sm_m else : logger . debug ( "State model requesting its state machine model parent seems to be obsolete. " "This is a hint to duplicated models and dirty coding" ) return None | Get respective state machine model |
40,189 | def get_input_data_port_m ( self , data_port_id ) : for data_port_m in self . input_data_ports : if data_port_m . data_port . data_port_id == data_port_id : return data_port_m return None | Returns the input data port model for the given data port id |
40,190 | def get_output_data_port_m ( self , data_port_id ) : for data_port_m in self . output_data_ports : if data_port_m . data_port . data_port_id == data_port_id : return data_port_m return None | Returns the output data port model for the given data port id |
40,191 | def get_outcome_m ( self , outcome_id ) : for outcome_m in self . outcomes : if outcome_m . outcome . outcome_id == outcome_id : return outcome_m return False | Returns the outcome model for the given outcome id |
40,192 | def action_signal_triggered ( self , model , prop_name , info ) : msg = info . arg if msg . action . startswith ( 'sm_notification_' ) : return if any ( [ m in self for m in info [ 'arg' ] . affected_models ] ) : if not msg . action . startswith ( 'parent_notification_' ) : new_msg = msg . _replace ( action = 'parent_notification_' + msg . action ) else : new_msg = msg for m in info [ 'arg' ] . affected_models : if isinstance ( m , AbstractStateModel ) and m in self : m . action_signal . emit ( new_msg ) if msg . action . startswith ( 'parent_notification_' ) : return if self . parent is not None : info . arg = msg self . parent . action_signal_triggered ( model , prop_name , info ) elif not msg . action . startswith ( 'sm_notification_' ) : new_msg = msg . _replace ( action = 'sm_notification_' + msg . action ) self . action_signal . emit ( new_msg ) else : pass | This method notifies the parent state and child state models about complex actions |
40,193 | def load_meta_data ( self , path = None ) : if not path : path = self . state . file_system_path if path is None : self . meta = Vividict ( { } ) return False path_meta_data = os . path . join ( path , storage . FILE_NAME_META_DATA ) if not os . path . exists ( path_meta_data ) : logger . debug ( "Because meta data was not found in {0} use backup option {1}" "" . format ( path_meta_data , os . path . join ( path , storage . FILE_NAME_META_DATA_OLD ) ) ) path_meta_data = os . path . join ( path , storage . FILE_NAME_META_DATA_OLD ) try : tmp_meta = storage . load_data_file ( path_meta_data ) except ValueError as e : if not path . startswith ( constants . RAFCON_TEMP_PATH_STORAGE ) and not os . path . exists ( os . path . dirname ( path ) ) : logger . debug ( "Because '{1}' meta data of {0} was not loaded properly." . format ( self , e ) ) tmp_meta = { } tmp_meta = Vividict ( tmp_meta ) if tmp_meta : self . _parse_for_element_meta_data ( tmp_meta ) self . meta = tmp_meta self . meta_signal . emit ( MetaSignalMsg ( "load_meta_data" , "all" , True ) ) return True else : return False | Load meta data of state model from the file system |
40,194 | def store_meta_data ( self , copy_path = None ) : if copy_path : meta_file_path_json = os . path . join ( copy_path , self . state . get_storage_path ( ) , storage . FILE_NAME_META_DATA ) else : if self . state . file_system_path is None : logger . error ( "Meta data of {0} can be stored temporary arbitrary but by default first after the " "respective state was stored and a file system path is set." . format ( self ) ) return meta_file_path_json = os . path . join ( self . state . file_system_path , storage . FILE_NAME_META_DATA ) meta_data = deepcopy ( self . meta ) self . _generate_element_meta_data ( meta_data ) storage_utils . write_dict_to_json ( meta_data , meta_file_path_json ) | Save meta data of state model to the file system |
40,195 | def _parse_for_element_meta_data ( self , meta_data ) : for data_port_m in self . input_data_ports : self . _copy_element_meta_data_from_meta_file_data ( meta_data , data_port_m , "input_data_port" , data_port_m . data_port . data_port_id ) for data_port_m in self . output_data_ports : self . _copy_element_meta_data_from_meta_file_data ( meta_data , data_port_m , "output_data_port" , data_port_m . data_port . data_port_id ) for outcome_m in self . outcomes : self . _copy_element_meta_data_from_meta_file_data ( meta_data , outcome_m , "outcome" , outcome_m . outcome . outcome_id ) if "income" in meta_data : if "gui" in meta_data and "editor_gaphas" in meta_data [ "gui" ] and "income" in meta_data [ "gui" ] [ "editor_gaphas" ] : del meta_data [ "gui" ] [ "editor_gaphas" ] [ "income" ] elif "gui" in meta_data and "editor_gaphas" in meta_data [ "gui" ] and "income" in meta_data [ "gui" ] [ "editor_gaphas" ] : meta_data [ "income" ] [ "gui" ] [ "editor_gaphas" ] = meta_data [ "gui" ] [ "editor_gaphas" ] [ "income" ] del meta_data [ "gui" ] [ "editor_gaphas" ] [ "income" ] self . _copy_element_meta_data_from_meta_file_data ( meta_data , self . income , "income" , "" ) | Load meta data for state elements |
40,196 | def _copy_element_meta_data_from_meta_file_data ( meta_data , element_m , element_name , element_id ) : meta_data_element_id = element_name + str ( element_id ) meta_data_element = meta_data [ meta_data_element_id ] element_m . meta = meta_data_element del meta_data [ meta_data_element_id ] | Helper method to assign the meta of the given element |
40,197 | def apply_clicked ( self , button ) : if isinstance ( self . model . state , LibraryState ) : logger . warning ( "It is not allowed to modify libraries." ) self . view . set_text ( "" ) return while Gtk . events_pending ( ) : Gtk . main_iteration_do ( False ) current_text = self . view . get_text ( ) if not self . view [ 'pylint_check_button' ] . get_active ( ) : self . set_script_text ( current_text ) return logger . debug ( "Parsing execute script..." ) with open ( self . tmp_file , "w" ) as text_file : text_file . write ( current_text ) MANAGER . astroid_cache . clear ( ) lint_config_file = resource_filename ( rafcon . __name__ , "pylintrc" ) args = [ "--rcfile={}" . format ( lint_config_file ) ] with contextlib . closing ( StringIO ( ) ) as dummy_buffer : json_report = JSONReporter ( dummy_buffer . getvalue ( ) ) try : lint . Run ( [ self . tmp_file ] + args , reporter = json_report , exit = False ) except : logger . exception ( "Could not run linter to check script" ) os . remove ( self . tmp_file ) if json_report . messages : def on_message_dialog_response_signal ( widget , response_id ) : if response_id == 1 : self . set_script_text ( current_text ) else : logger . debug ( "The script was not saved" ) widget . destroy ( ) message_string = "Are you sure that you want to save this file?\n\nThe following errors were found:" line = None for message in json_report . messages : ( error_string , line ) = self . format_error_string ( message ) message_string += "\n\n" + error_string if line : tbuffer = self . view . get_buffer ( ) start_iter = tbuffer . get_start_iter ( ) start_iter . set_line ( int ( line ) - 1 ) tbuffer . place_cursor ( start_iter ) message_string += "\n\nThe line was focused in the source editor." self . view . scroll_to_cursor_onscreen ( ) sm_m = state_machine_manager_model . get_state_machine_model ( self . model ) if sm_m . selection . get_selected_state ( ) is not self . model : sm_m . selection . set ( self . model ) dialog = RAFCONButtonDialog ( message_string , [ "Save with errors" , "Do not save" ] , on_message_dialog_response_signal , message_type = Gtk . MessageType . WARNING , parent = self . get_root_window ( ) ) result = dialog . run ( ) else : self . set_script_text ( current_text ) | Triggered when the Apply button in the source editor is clicked . |
40,198 | def update_auto_scroll_mode ( self ) : if self . _enables [ 'CONSOLE_FOLLOW_LOGGING' ] : if self . _auto_scroll_handler_id is None : self . _auto_scroll_handler_id = self . text_view . connect ( "size-allocate" , self . _auto_scroll ) else : if self . _auto_scroll_handler_id is not None : self . text_view . disconnect ( self . _auto_scroll_handler_id ) self . _auto_scroll_handler_id = None | Register or un - register signals for follow mode |
40,199 | def _auto_scroll ( self , * args ) : adj = self [ 'scrollable' ] . get_vadjustment ( ) adj . set_value ( adj . get_upper ( ) - adj . get_page_size ( ) ) | Scroll to the end of the text view |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.