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