def __init__(self, conf): KwiverProcess.__init__(self, conf) self.add_config_trait() # register port traits self.add_port_trait("exemplar_uids", "string_vector", "Positive exemplar descriptor UUIDs") self.add_port_trait("positive_uids", "string_vector", "Positive sample UIDs") self.add_port_trait("negative_uids", "string_vector", "Negative sample UIDs") self.add_port_trait("result_descritpor_uids", "string_vector", "Result ranked descriptor UUIDs in rank order.") self.add_port_trait( "result_descriptor_scores", "double_vector", "Result ranked descriptor distance score values " "in rank order.") # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) ## declare our input port ( port-name,flags) # user-provided positive examplar descriptors. self.declare_input_port_using_trait('descriptor_set', required) # UUIDs for the user provided positive exemplar descriptors self.declare_input_port_using_trait('exemplar_uids', required) # user adjudicated positive and negative descriptor UUIDs self.declare_input_port_using_trait('positive_uids', optional) self.declare_input_port_using_trait('negative_uids', optional) # Output, ranked descriptor UUIDs self.declare_output_port_using_trait('result_descritpor_uids', optional) # Output, ranked descriptor scores. self.declare_output_port_using_trait('result_descriptor_scores', optional) ## Member variables to be configured in ``_configure``. # Path to the json config file for the DescriptorIndex self.di_json_config_path = None self.di_json_config = None # Path to the json config file for the NearestNeighborsIndex self.nn_json_config_path = None self.nn_json_config = None # Number of top, refined descriptor UUIDs to return per step. self.query_return_n = None # Set of descriptors to pull positive/negative querys from. self.descriptor_set = None # Nearest Neighbors index to use for IQR working index population. self.neighbor_index = None # IQR session state object self.iqr_session = None # Factory for converting vital descriptors to smqtk. Currently just # use in-memory elements for conversion. self.smqtk_descriptor_element_factory = smqtk.representation.DescriptorElementFactory( smqtk.representation.descriptor_element.local_elements. DescriptorMemoryElement, {})
def __init__(self, conf): print("[DEBUG] ----- init") KwiverProcess.__init__(self, conf) self.add_config_trait("modelFile", "modelFile", "Model File", "Path to TF Inference Graph.") self.declare_config_using_trait("modelFile") self.add_config_trait("normImageType", "normImageType", "", "Type of normalization for input image.") self.declare_config_using_trait("normImageType") self.add_config_trait("confidenceThresh", "confidenceThresh", ".5", "Confidence threshold for detection.") self.declare_config_using_trait("confidenceThresh") self.add_port_trait("image_norm", "image", "Normalized image") # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait("image", required) self.declare_output_port_using_trait("detected_object_set", optional) self.declare_output_port_using_trait("image_norm", optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # register python config file self.add_config_trait( 'config_file', 'config_file', '', 'Path to the json configuration file for the descriptor index to add to.' ) self.declare_config_using_trait('config_file') self.add_config_trait( 'max_frame_buffer', 'max_frame_buffer', '0', 'Maximum number of frames to buffer descriptors over for larger batch sizes' ) self.declare_config_using_trait('max_frame_buffer') self.add_config_trait( 'max_descriptor_buffer', 'max_descriptor_buffer', '10000', 'Maximum number of descriptors to buffer over to make larger batch sizes' ) self.declare_config_using_trait('max_descriptor_buffer') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('descriptor_set', required) self.declare_input_port_using_trait('string_vector', required) self.declare_output_port_using_trait('descriptor_set', optional) self.declare_output_port_using_trait('string_vector', optional)
def test_create(): from sprokit.pipeline import datum from sprokit.pipeline import process process.ProcessType() process.ProcessTypes() process.ProcessName() process.ProcessNames() process.ProcessProperty() process.ProcessProperties() process.PortDescription() process.PortFrequency(1) process.PortFrequency(1, 1) process.Port() process.Ports() process.PortType() process.PortFlag() process.PortFlags() process.PortAddr() process.PortAddrs() process.Connection() process.Connections() process.PortInfo('type', process.PortFlags(), 'desc', process.PortFrequency(1, 1)) process.ConfInfo('default', 'desc', False) process.DataInfo(True, datum.DatumType.invalid) process.DataCheck.none process.DataCheck.sync process.DataCheck.valid
def __init__(self, conf): KwiverProcess.__init__(self, conf) # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our ports (port-name, flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('image', optional)
def __init__(self, conf): process.PythonProcess.__init__(self, conf) # declare our configuration items self.declare_configuration_key('output_directory', '.', 'The path for output files.') self.declare_configuration_key('base_filename', 'kw_archive', 'Base filename (no extension)') self.declare_configuration_key('separate_meta', 'true', 'Whether to write separate .meta file') self.declare_configuration_key('mission_id', '', 'Mission id to store in archive') self.declare_configuration_key('stream_id', '', 'Stream id to store in archive') self.declare_configuration_key( 'compress_image', 'true', "Whether to compress image data stored in archive") # create port flags flags = process.PortFlags() flags.add(self.flag_required) # create input ports self.declare_input_port( # example 'input', 'integer', flags, 'Where numbers are read from.') self.declare_input_port( 'timestamp', # name 'timestamp', # type flags, 'Timestamp for current inputs') self.declare_input_port('image', 'vil_image_view_byte', flags, 'Input image') self.declare_input_port('src_to_ref_homography', 'image_to_image_homography', flags, 'Src to ref homography') self.declare_input_port( 'corner_points', 'video_metadata', process.PortFlags(), #optional 'Video metadata defining corner points') self.declare_input_port('world_units_per_pixel', 'double', flags, 'Meters per pixel')
def __init__(self, config): KwiverProcess.__init__(self, config) add_declare_config(self, "min_iou", str(DEFAULT_MIN_IOU), "Minimum IOU to associate a detection to a track") optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) self.declare_input_port_using_trait('detected_object_set', required) self.declare_input_port_using_trait('timestamp', required) self.declare_input_port_using_trait('homography_src_to_ref', required) self.declare_output_port_using_trait('object_track_set', optional)
def __init__(self, conf): print('conf = {!r}'.format(conf)) logger.debug(' ----- init ' + self.__class__.__name__) KwiverProcess.__init__(self, conf) camtrawl_setup_config(self, ctalgo.GMMForegroundObjectDetector.default_params()) # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('detected_object_set', optional )
def __init__(self, conf): logger.debug(' ----- ' + self.__class__.__name__ + ' init') KwiverProcess.__init__(self, conf) camtrawl_setup_config(self, ctalgo.FishStereoMeasurments.default_params()) self.add_config_trait('output_fpath', 'output_fpath', 'camtrawl_out.csv', 'output file to write detection measurements') self.declare_config_using_trait('output_fpath') self.add_config_trait('cal_fpath', 'cal_fpath', 'cal_201608.mat', 'matlab or npz file with calibration info') self.declare_config_using_trait('cal_fpath') # optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # self.add_port_trait('camera' + '1', 'camera', 'Left camera calibration') # self.add_port_trait('camera' + '2', 'camera', 'Right camera calibration') self.add_port_trait('detected_object_set' + '1', 'detected_object_set', 'Detections from camera1') self.add_port_trait('detected_object_set' + '2', 'detected_object_set', 'Detections from camera2') self.add_port_trait('image_file_name' + '1', 'image_file_name', 'desc1') self.add_port_trait('image_file_name' + '2', 'image_file_name', 'desc2') # self.add_port_trait('frame_id1', 'int', 'frame id') # self.add_port_trait('frame_id2', 'int', 'frame id') # declare our input port ( port-name,flags) # self.declare_input_port_using_trait('camera' + '1', optional) # self.declare_input_port_using_trait('camera' + '2', optional) self.declare_input_port_using_trait('image_file_name' + '1', required) self.declare_input_port_using_trait('image_file_name' + '2', required) self.declare_input_port_using_trait('detected_object_set' + '1', required) self.declare_input_port_using_trait('detected_object_set' + '2', required)
def test_peek_at_datum_on_port(): """ Test peek at datum on a test port with complete datum """ from sprokit.pipeline import process from sprokit.pipeline import datum, DatumType from vital.config import config from sprokit.pipeline import edge from sprokit.pipeline import stamp cfg = config.empty_config() # Create Dummy Receiver process receiver_proc = process.PythonProcess(cfg) optional = process.PortFlags() receiver_proc.declare_input_port("test_port", "test", optional, "test_port") # Create an Edge and connect input port to the edge test_edge = edge.Edge() receiver_proc.connect_input_port("test_port", test_edge) # Create an Edge Datum and push it to the port s = stamp.new_stamp(1) e_datum = edge.EdgeDatum(datum.complete(), s) test_edge.push_datum(e_datum) receiver_datum_type = receiver_proc.peek_at_datum_on_port( "test_port").type() if receiver_datum_type != DatumType.complete: test_error("Datum mismatch: expected a complete datum, got {0}".format( receiver_datum_type))
def __init__(self, conf): KwiverProcess.__init__(self, conf) # declare configuration self.add_config_trait("model_file", "model_file", 'dummy.model', 'Model file for the classifier') self.declare_config_using_trait('model_file') # set up flags required = process.PortFlags() required.add(self.flag_required) optional = process.PortFlags() # declare ports self.declare_input_port_using_trait('image', required) self.declare_input_port_using_trait('file_name', optional ) self.declare_output_port_using_trait( 'double_vector', required );
def __init__(self, conf): KwiverProcess.__init__(self, conf) # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port (port-name,flags) self.declare_input_port_using_trait('object_track_set', required) self.declare_input_port_using_trait('timestamp', required) self.declare_output_port_using_trait('detected_object_set', optional) # since viame gives us all tracks each time we just want to organize them by frame # on the first time _step is called. self.track_dict_initialized = False self.track_dict = {}
def __init__(self, conf): KwiverProcess.__init__(self, conf) # set up configs self.add_config_trait("good_match_percent", "good_match_percent", '0.15', 'Good match percent [0.0,1.0].') self.add_config_trait("ratio_test", "ratio_test", '0.85', 'Feature point test ratio') self.add_config_trait("match_height", "match_height", '512', 'Match height.') self.add_config_trait("min_matches", "min_matches", '4', 'Minimum number of feature matches') self.add_config_trait("min_inliers", "min_inliers", '4', 'Minimum number of inliers') self.declare_config_using_trait('good_match_percent') self.declare_config_using_trait('ratio_test') self.declare_config_using_trait('match_height') self.declare_config_using_trait('min_matches') self.declare_config_using_trait('min_inliers') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our ports (port-name, flags) self.add_port_trait("optical_image", "image", "Input image") self.add_port_trait("thermal_image", "image", "Input image") self.add_port_trait("warped_optical_image", "image", "Output image") self.add_port_trait("warped_thermal_image", "image", "Output image") self.add_port_trait("optical_to_thermal_homog", "homography", "Output homog") self.add_port_trait("thermal_to_optical_homog", "homography", "Output homog") self.declare_input_port_using_trait('optical_image', required) self.declare_input_port_using_trait('thermal_image', required) self.declare_output_port_using_trait('warped_optical_image', optional) self.declare_output_port_using_trait('warped_thermal_image', optional) self.declare_output_port_using_trait('optical_to_thermal_homog', optional) self.declare_output_port_using_trait('thermal_to_optical_homog', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) self.add_config_trait("example_param", "example_param", 'Default Value', 'Text to display to user.') self.declare_config_using_trait('example_param') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port (port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('detected_object_set', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) self.add_config_trait("text", "text", 'Hello World', 'Text to display to user.') self.declare_config_using_trait('text') #self.add_port_trait('detections', 'detected_object_set', 'Output detections') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('detected_object_set', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) self.add_config_trait("output", "output", '.', 'The path of the file to output to.') self.declare_config_using_trait('output') self.add_port_trait('out_image', 'image', 'Processed image') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('out_image', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # register python config file self.add_config_trait( 'config_file', 'config_file', '', 'Path to the json configuration file for the descriptor index to add to.' ) self.declare_config_using_trait('config_file') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our input port ( port-name,flags) self.declare_input_port_using_trait('descriptor_set', required) self.declare_input_port_using_trait('string_vector', required) self.declare_output_port_using_trait('descriptor_set', optional) self.declare_output_port_using_trait('string_vector', optional)
def __init__(self, conf): process.PythonProcess.__init__(self, conf) self.declare_configuration_key('output', '', 'The path of the file to output to.') flags = process.PortFlags() flags.add(self.flag_required) self.declare_input_port('input', 'integer', flags, 'Where numbers are read from.')
def __init__(self, conf): process.PythonProcess.__init__(self, conf) self.conf_output = 'output' self.declare_configuration_key(self.conf_output, 'output.txt', 'Output file name', False) self.port_input = 'number' required = process.PortFlags() required.add(self.flag_required) self.declare_input_port(self.port_input, 'integer', required, 'input port')
def __init__( self, conf ): KwiverProcess.__init__( self, conf ) self.add_config_trait( "text", # Config name "text", # Config type 'Hello World', # Default value 'Text to display to user.' ) # Config self.declare_config_using_trait( 'text' ) # Register config name # Would be used if declaring a new output field 'out_image' instead # of the default 'image' output port name defined in KwiverProcess #self.add_port_trait( 'out_image', 'image', 'Processed image' ) # set up required port flags optional = process.PortFlags() required = process.PortFlags() required.add( self.flag_required ) # declare our input and output ports ( port-name, flags ) self.declare_input_port_using_trait( 'image', required ) self.declare_output_port_using_trait( 'image', optional )
def __init__(self, conf): KwiverProcess.__init__(self, conf) # register python config file self.add_config_trait( 'config_file', 'config_file', '', 'Path to the json configuration file for the descriptor index to fetch from.' ) self.declare_config_using_trait('config_file') self.add_config_trait('video_name', 'video_name', '', 'Video name') self.declare_config_using_trait('video_name') self.add_config_trait('conn_str', 'conn_str', '', 'Connection string') self.declare_config_using_trait('conn_str') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) self.declare_input_port_using_trait('object_track_set', required) self.declare_output_port_using_trait('object_track_set', optional)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # set up configs self.add_config_trait("reference_image", "reference_image", '', 'Reference noise image') self.add_config_trait("response_kernel", "response_kernel", '25', 'Response kernel size.') self.add_config_trait("smooth_kernel", "smooth_kernel", '50', 'Local average kernel size') self.declare_config_using_trait('reference_image') self.declare_config_using_trait('response_kernel') self.declare_config_using_trait('smooth_kernel') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) # declare our ports (port-name, flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('image', optional)
def __init__(self, conf): process.PythonProcess.__init__(self, conf) self.conf_start = 'start' self.conf_end = 'end' self.declare_configuration_key(self.conf_start, str(0), 'Starting number', False) self.declare_configuration_key(self.conf_end, str(10), 'Ending number', True) self.port_output = 'number' required = process.PortFlags() required.add(self.flag_required) self.declare_output_port(self.port_output, 'integer', required, 'output port')
def __init__(self, conf): KwiverProcess.__init__(self, conf) # self.add_config_trait("match_iou", # "match_iou", # '.8', # 'IOU to declare two boxes matching') # self.declare_config_using_trait('match_iou') # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) self.dos1_port_name = 'detected_object_set' + '1' self.dos2_port_name = 'detected_object_set' + '2' # declare our input port (port-name,flags) self.add_port_trait(self.dos1_port_name, 'detected_object_set', 'Detections from camera1') self.add_port_trait(self.dos2_port_name, 'detected_object_set', 'Detections from camera2') self.declare_input_port_using_trait(self.dos1_port_name, required) self.declare_input_port_using_trait(self.dos2_port_name, required) self.matches_port_name = 'detected_object_set' + '_matches' self.new_detections_port_name = 'detected_object_set' + '_new_detections' self.add_port_trait(self.matches_port_name, 'detected_object_set', 'Detections from camera3') self.add_port_trait(self.new_detections_port_name, 'detected_object_set', 'Detections from camera3') self.declare_output_port_using_trait(self.matches_port_name, optional) self.declare_output_port_using_trait(self.new_detections_port_name, optional) print(dir(self)) print(self.input_ports())
def __init__(self, conf): KwiverProcess.__init__(self, conf) # set up required flags required = process.PortFlags() required.add(self.flag_required) # Add the type trait self.add_type_trait( "BBoxWithMultipleDescriptors", "BBoxWithMultipleDescriptors", datum.Datum.get_datum, datum.new ) # Create a new port trait self.add_port_trait( "BBoxWithMultipleDescriptors", "BBoxWithMultipleDescriptors", "Custom python data type" ) # Declare the port using the trait self.declare_input_port_using_trait("BBoxWithMultipleDescriptors", required)
def __init__(self, conf): KwiverProcess.__init__(self, conf) # Add trait for our output port self.add_port_trait('vector', 'double_vector', 'Output descriptor vector') # set up required flags required = process.PortFlags() required.add(self.flag_required) # declare our ports ( port-name, flags) self.declare_input_port_using_trait('image', required) self.declare_output_port_using_trait('vector', required) # declare our configuration self.declare_configuration_key("config_file", "", "Descriptor configuration file name")
def test_api_calls(): from sprokit.pipeline import datum from sprokit.pipeline import process a = process.PortAddr() a.process a.port a.process = '' a.port = '' f = process.PortFrequency(1, 1) a = process.PortInfo('type', process.PortFlags(), 'desc', f) a.type a.flags a.description a.frequency a = process.ConfInfo('default', 'desc', False) a.default a.description a.tunable a = process.DataInfo(True, datum.DatumType.invalid) a.in_sync a.max_status process.PythonProcess.property_no_threads process.PythonProcess.property_no_reentrancy process.PythonProcess.property_unsync_input process.PythonProcess.property_unsync_output process.PythonProcess.port_heartbeat process.PythonProcess.config_name process.PythonProcess.config_type process.PythonProcess.type_any process.PythonProcess.type_none process.PythonProcess.type_data_dependent process.PythonProcess.type_flow_dependent process.PythonProcess.flag_output_const process.PythonProcess.flag_output_shared process.PythonProcess.flag_input_static process.PythonProcess.flag_input_mutable process.PythonProcess.flag_input_nodep process.PythonProcess.flag_required
def __init__(self, conf): KwiverProcess.__init__(self, conf) # register port and config traits self.add_port_traits() self.add_config_traits() # set up required flags optional = process.PortFlags() required = process.PortFlags() required.add(self.flag_required) ## declare our input port ( port-name,flags) # user-provided positive examplar descriptors. self.declare_input_port_using_trait('positive_descriptor_set', required) self.declare_input_port_using_trait('positive_exemplar_uids', required) # user-provided negative examplar descriptors. self.declare_input_port_using_trait('negative_descriptor_set', optional) self.declare_input_port_using_trait('negative_exemplar_uids', optional) # user adjudicated positive and negative descriptor UUIDs self.declare_input_port_using_trait('iqr_positive_uids', optional) self.declare_input_port_using_trait('iqr_negative_uids', optional) # input model if pre-generated self.declare_input_port_using_trait('iqr_query_model', optional) # Output, ranked descriptor UUIDs self.declare_output_port_using_trait('result_uids', optional) # Output, feedback descriptor UUIDs in decreasing order of # importance self.declare_output_port_using_trait('feedback_uids', optional) # Output, ranked descriptor scores. self.declare_output_port_using_trait('result_scores', optional) # Output, distances of feedback descriptors from the separating plane # in increasing order of magnitude. These distances correspond to # feedback_uids. self.declare_output_port_using_trait('feedback_distances', optional) # Output, feedback scores corresponding to the descriptors. self.declare_output_port_using_trait('feedback_scores', optional) # Output, trained IQR model. self.declare_output_port_using_trait('result_model', optional) ## Member variables to be configured in ``_configure``. # Path to the json config file for the DescriptorIndex self.di_json_config_path = None self.di_json_config = None # Path to the json config file for the NearestNeighborsIndex self.nn_json_config_path = None self.nn_json_config = None # Number of top, refined descriptor UUIDs to return per step. self.query_return_n = None # Set of descriptors to pull positive/negative querys from. self.descriptor_set = None # Nearest Neighbors index to use for IQR working index population. self.neighbor_index = None # IQR session state object self.iqr_session = None # Factory for converting vital descriptors to smqtk. Currently just # use in-memory elements for conversion. self.smqtk_descriptor_element_factory = smqtk.representation.DescriptorElementFactory( smqtk.representation.descriptor_element.local_elements. DescriptorMemoryElement, {})
def test_flags_as_set(): from sprokit.pipeline import process # TODO: Make tests more rigorous (check more than just len()). a = process.PortFlags() # adding to the set a.add(process.PythonProcess.flag_required) a.add(process.PythonProcess.flag_input_mutable) a.add(process.PythonProcess.flag_input_nodep) a.add(process.PythonProcess.flag_input_static) # length if not len(a) == 4: test_error("len() does not work: expected 4, got %d" % len(a)) # adding duplicate values a.add(process.PythonProcess.flag_required) if not len(a) == 4: test_error(".add() added a duplicate item: expected 4, got %d" % len(a)) # adding invalid objects expect_exception('adding a value of an invalid type', TypeError, process.PortFlags.add, a, True), # indexing failures expect_exception('getting an item by index', TypeError, process.PortFlags.__getitem__, a, 0) expect_exception('deleting an item by index', TypeError, process.PortFlags.__delitem__, a, 0) expect_exception('setting an item by index', TypeError, process.PortFlags.__setitem__, a, 0, process.PythonProcess.flag_input_mutable) # 'in' keyword if process.PythonProcess.flag_required not in a: test_error("a value in the set is 'not in' the set") if process.PythonProcess.flag_output_const in a: test_error("a value not in the set is 'in' the set") # iteration for value in a: pass # boolean casting if not a: test_error("a non-empty set is False-like") b = process.PortFlags() if b: test_error("an empty set is True-like") # removal expect_exception('.pop() on an empty set', KeyError, process.PortFlags.pop, b) expect_exception('.remove() with an item that does not exist in the set', KeyError, process.PortFlags.remove, a, process.PythonProcess.flag_output_const) a.discard(process.PythonProcess.flag_output_const) if not len(a) == 4: test_error(".discard() removed an item not in the set") a.discard(process.PythonProcess.flag_input_static) if not len(a) == 3: test_error(".discard() did not remove an item from the set") a.remove(process.PythonProcess.flag_input_nodep) if not len(a) == 2: test_error(".remove() did not remove an item from the set") a.pop() if not len(a) == 1: test_error(".pop() did not remove an item from the set") a.clear() if a: test_error(".clear() did not make a False-like set") # copy b.add(process.PythonProcess.flag_required) c = b.copy() b.clear() if not c: test_error(".clear() on a set modified a set created using .copy()") c = b.copy() b.add(process.PythonProcess.flag_required) if c: test_error(".add() on a set modified a set created using .copy()") # set vs. set queries a.add(process.PythonProcess.flag_input_nodep) a.add(process.PythonProcess.flag_input_static) if not b.isdisjoint(a): test_error(".isdisjoint() does not work") if b.issubset(a): test_error(".issubset() does not work") if a.issuperset(b): test_error(".issuperset() does not work") a.add(process.PythonProcess.flag_required) if b.isdisjoint(a): test_error(".isdisjoint() does not work") if not b.issubset(a): test_error(".issubset() does not work") if not a.issuperset(b): test_error(".issuperset() does not work") u = a.union(b) if not len(u) == 3: test_error(".union() does not work: expected 3, got %d" % len(u)) d = a.difference(b) if not len(d) == 2: test_error(".difference() does not work: expected 2, got %d" % len(d)) i = a.intersection(b) if not len(i) == 1: test_error(".intersection() does not work: expected 1, got %d" % len(i)) b.add(process.PythonProcess.flag_output_const) s = a.symmetric_difference(b) if not len(s) == 3: test_error( ".symmetric_difference() does not work: expected 3, got %d" % len(s)) a.update(b) if not len(a) == 4: test_error(".update() does not work: expected 4, got %d" % len(a))