Python random.seed() Examples

The following are code examples for showing how to use random.seed(). They are extracted from open source Python projects. You can vote up the examples you like or vote down the ones you don't like. You can also save this page to your account.

Example 1
Project: nidaqmx-python   Author: ni   File: test_stream_digital_readers_writers.py    (license) View Source Project 7 votes vote down vote up
def test_one_sample_one_line(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        do_line = random.choice(x_series_device.do_lines).name

        with nidaqmx.Task() as task:
            task.do_channels.add_do_chan(
                do_line, line_grouping=LineGrouping.CHAN_PER_LINE)

            writer = DigitalSingleChannelWriter(task.out_stream)
            reader = DigitalSingleChannelReader(task.in_stream)

            # Generate random values to test.
            values_to_test = [bool(random.getrandbits(1)) for _ in range(10)]

            values_read = []
            for value_to_test in values_to_test:
                writer.write_one_sample_one_line(value_to_test)
                time.sleep(0.001)
                values_read.append(reader.read_one_sample_one_line())

            numpy.testing.assert_array_equal(values_read, values_to_test) 
Example 2
Project: nidaqmx-python   Author: ni   File: test_stream_digital_readers_writers.py    (license) View Source Project 7 votes vote down vote up
def test_one_sample_port_byte(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        do_port = random.choice(
            [d for d in x_series_device.do_ports if d.do_port_width <= 8])

        with nidaqmx.Task() as task:
            task.do_channels.add_do_chan(
                do_port.name, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES)

            # Generate random values to test.
            values_to_test = [int(random.getrandbits(do_port.do_port_width))
                              for _ in range(10)]

            writer = DigitalSingleChannelWriter(task.out_stream)
            reader = DigitalSingleChannelReader(task.in_stream)

            values_read = []
            for value_to_test in values_to_test:
                writer.write_one_sample_port_byte(value_to_test)
                time.sleep(0.001)
                values_read.append(reader.read_one_sample_port_byte())

            numpy.testing.assert_array_equal(values_read, values_to_test) 
Example 3
Project: nidaqmx-python   Author: ni   File: test_stream_digital_readers_writers.py    (license) View Source Project 6 votes vote down vote up
def test_one_sample_port_uint32(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        do_port = random.choice(
            [do for do in x_series_device.do_ports if do.do_port_width <= 32])

        with nidaqmx.Task() as task:
            task.do_channels.add_do_chan(
                do_port.name, line_grouping=LineGrouping.CHAN_FOR_ALL_LINES)

            # Generate random values to test.
            values_to_test = [int(random.getrandbits(do_port.do_port_width))
                              for _ in range(10)]

            writer = DigitalSingleChannelWriter(task.out_stream)
            reader = DigitalSingleChannelReader(task.in_stream)

            values_read = []
            for value_to_test in values_to_test:
                writer.write_one_sample_port_uint32(value_to_test)
                time.sleep(0.001)
                values_read.append(reader.read_one_sample_port_uint32())

            numpy.testing.assert_array_equal(values_read, values_to_test) 
Example 4
Project: nidaqmx-python   Author: ni   File: test_invalid_writes.py    (license) View Source Project 6 votes vote down vote up
def test_insufficient_numpy_write_data(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        # Randomly select physical channels to test.
        number_of_channels = random.randint(
            2, len(x_series_device.ao_physical_chans))
        channels_to_test = random.sample(
            x_series_device.ao_physical_chans, number_of_channels)

        with nidaqmx.Task() as task:
            task.ao_channels.add_ao_voltage_chan(
                flatten_channel_string([c.name for c in channels_to_test]),
                max_val=10, min_val=-10)

            number_of_samples = random.randint(1, number_of_channels - 1)
            values_to_test = numpy.float64([
                random.uniform(-10, 10) for _ in range(number_of_samples)])

            with pytest.raises(DaqError) as e:
                task.write(values_to_test, auto_start=True)
            assert e.value.error_code == -200524 
Example 5
Project: nidaqmx-python   Author: ni   File: test_channel_creation.py    (license) View Source Project 6 votes vote down vote up
def test_create_ai_voltage_chan(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        ai_phys_chan = random.choice(x_series_device.ai_physical_chans).name

        with nidaqmx.Task() as task:
            ai_channel = task.ai_channels.add_ai_voltage_chan(
                ai_phys_chan, name_to_assign_to_channel="VoltageChannel",
                terminal_config=TerminalConfiguration.NRSE, min_val=-20.0,
                max_val=20.0, units=VoltageUnits.FROM_CUSTOM_SCALE,
                custom_scale_name="double_gain_scale")

            assert ai_channel.physical_channel.name == ai_phys_chan
            assert ai_channel.name == "VoltageChannel"
            assert ai_channel.ai_term_cfg == TerminalConfiguration.NRSE
            assert ai_channel.ai_min == -20.0
            assert ai_channel.ai_max == 20.0
            assert (ai_channel.ai_voltage_units ==
                    VoltageUnits.FROM_CUSTOM_SCALE)
            assert (ai_channel.ai_custom_scale.name ==
                    "double_gain_scale") 
Example 6
Project: nidaqmx-python   Author: ni   File: test_channel_creation.py    (license) View Source Project 6 votes vote down vote up
def test_create_ai_resistance_chan(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        ai_phys_chan = random.choice(x_series_device.ai_physical_chans).name

        with nidaqmx.Task() as task:
            ai_channel = task.ai_channels.add_ai_resistance_chan(
                ai_phys_chan, name_to_assign_to_channel="ResistanceChannel",
                min_val=-1000.0, max_val=1000.0, units=ResistanceUnits.OHMS,
                resistance_config=ResistanceConfiguration.TWO_WIRE,
                current_excit_source=ExcitationSource.EXTERNAL,
                current_excit_val=0.002, custom_scale_name="")

            assert ai_channel.physical_channel.name == ai_phys_chan
            assert ai_channel.name == "ResistanceChannel"
            assert numpy.isclose(ai_channel.ai_min, -1000.0, atol=1)
            assert numpy.isclose(ai_channel.ai_max, 1000.0, atol=1)
            assert ai_channel.ai_resistance_units == ResistanceUnits.OHMS
            assert (ai_channel.ai_resistance_cfg ==
                    ResistanceConfiguration.TWO_WIRE)
            assert ai_channel.ai_excit_src == ExcitationSource.EXTERNAL
            assert ai_channel.ai_excit_val == 0.002 
Example 7
Project: nidaqmx-python   Author: ni   File: test_watchdog.py    (license) View Source Project 6 votes vote down vote up
def test_watchdog_expir_state(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        do_line = random.choice(x_series_device.do_lines)

        with nidaqmx.system.WatchdogTask(
                x_series_device.name, timeout=0.1) as task:
            expir_states = [DOExpirationState(
                physical_channel=do_line.name,
                expiration_state=Level.TRISTATE)]

            task.cfg_watchdog_do_expir_states(expir_states)

            expir_state_obj = task.expiration_states[do_line.name]
            assert expir_state_obj.expir_states_do_state == Level.TRISTATE

            expir_state_obj.expir_states_do_state = Level.LOW
            assert expir_state_obj.expir_states_do_state == Level.LOW 
Example 8
Project: nidaqmx-python   Author: ni   File: test_triggers.py    (license) View Source Project 6 votes vote down vote up
def test_arm_start_trigger(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        counter = random.choice(self._get_device_counters(x_series_device))

        with nidaqmx.Task() as task:
            task.co_channels.add_co_pulse_chan_freq(counter)
            task.triggers.arm_start_trigger.trig_type = (
                TriggerType.DIGITAL_EDGE)
            assert (task.triggers.arm_start_trigger.trig_type ==
                    TriggerType.DIGITAL_EDGE)

            task.triggers.arm_start_trigger.trig_type = (
                TriggerType.NONE)
            assert (task.triggers.arm_start_trigger.trig_type ==
                    TriggerType.NONE) 
Example 9
Project: nidaqmx-python   Author: ni   File: test_triggers.py    (license) View Source Project 6 votes vote down vote up
def test_pause_trigger(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        counter = random.choice(self._get_device_counters(x_series_device))

        with nidaqmx.Task() as task:
            task.co_channels.add_co_pulse_chan_freq(counter)
            task.timing.cfg_implicit_timing(
                sample_mode=AcquisitionType.CONTINUOUS)

            task.triggers.pause_trigger.trig_type = (
                TriggerType.DIGITAL_LEVEL)
            assert (task.triggers.pause_trigger.trig_type ==
                    TriggerType.DIGITAL_LEVEL)

            task.triggers.pause_trigger.trig_type = (
                TriggerType.NONE)
            assert (task.triggers.pause_trigger.trig_type ==
                    TriggerType.NONE) 
Example 10
Project: nidaqmx-python   Author: ni   File: test_properties.py    (license) View Source Project 6 votes vote down vote up
def test_int_property(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        with nidaqmx.Task() as task:
            task.ci_channels.add_ci_count_edges_chan(
                x_series_device.ci_physical_chans[0].name)

            # Test property default value.
            assert task.in_stream.offset == 0

            # Test property setter and getter.
            value_to_test = random.randint(0, 100)
            task.in_stream.offset = value_to_test
            assert task.in_stream.offset == value_to_test

            value_to_test = random.randint(-100, 0)
            task.in_stream.offset = value_to_test
            assert task.in_stream.offset == value_to_test

            # Test property deleter.
            del task.in_stream.offset
            assert task.in_stream.offset == 0 
Example 11
Project: nidaqmx-python   Author: ni   File: test_properties.py    (license) View Source Project 6 votes vote down vote up
def test_uint_property(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        with nidaqmx.Task() as task:
            task.ai_channels.add_ai_voltage_chan(
                x_series_device.ai_physical_chans[0].name)

            task.timing.cfg_samp_clk_timing(1000)

            # Test property initial value.
            assert task.timing.samp_clk_timebase_div == 100000

            # Test property setter and getter.
            value_to_test = random.randint(500, 10000)
            task.timing.samp_clk_timebase_div = value_to_test
            assert task.timing.samp_clk_timebase_div == value_to_test

            # Test property deleter.
            del task.timing.samp_clk_timebase_div
            assert task.timing.samp_clk_timebase_div == 100000 
Example 12
Project: IgDiscover   Author: NBISweden   File: discover.py    (MIT License) View Source Project 6 votes vote down vote up
def __init__(self, database, windows, left, right, cluster, table_output,
			consensus_threshold, v_error_rate, downsample,
			cluster_subsample_size, approx_columns, max_n_bases, exact_copies,
			d_coverage, d_evalue, seed):
		self.database = database
		self.windows = windows
		self.left = left
		self.right = right
		self.cluster = cluster
		self.table_output = table_output
		self.consensus_threshold = consensus_threshold
		self.v_error_rate = v_error_rate
		self.downsample = downsample
		self.cluster_subsample_size = cluster_subsample_size
		self.approx_columns = approx_columns
		self.max_n_bases = max_n_bases
		self.exact_copies = exact_copies
		self.d_coverage = d_coverage
		self.d_evalue = d_evalue
		self.seed = seed 
Example 13
Project: zipline-chinese   Author: zhanghan1990   File: test_events.py    (Apache License 2.0) View Source Project 6 votes vote down vote up
def minutes_for_days():
    """
    500 randomly selected days.
    This is used to make sure our test coverage is unbaised towards any rules.
    We use a random sample because testing on all the trading days took
    around 180 seconds on my laptop, which is far too much for normal unit
    testing.

    We manually set the seed so that this will be deterministic.
    Results of multiple runs were compared to make sure that this is actually
    true.

    This returns a generator of tuples each wrapping a single generator.
    Iterating over this yeilds a single day, iterating over the day yields
    the minutes for that day.
    """
    env = TradingEnvironment()
    random.seed('deterministic')
    return ((env.market_minutes_for_day(random.choice(env.trading_days)),)
            for _ in range(500)) 
Example 14
Project: vehicle_brand_classification_CNN   Author: nanoc812   File: logoSet.py    (MIT License) View Source Project 6 votes vote down vote up
def loadLogoSet(path, rows,cols,test_data_rate=0.15):
    random.seed(612)
    _, imgID = readItems('data.txt')
    y, _ = modelDict(path)
    nPics =  len(y)
    faceassset = np.zeros((nPics,rows,cols), dtype = np.uint8) ### gray images
    noImg = []
    for i in range(nPics):
        temp = cv2.imread(path +'logo/'+imgID[i]+'.jpg', 0)
        if temp == None:
            noImg.append(i)
        elif temp.size < 1000:
            noImg.append(i)
        else:
            temp = cv2.resize(temp,(cols, rows), interpolation = cv2.INTER_CUBIC)
            faceassset[i,:,:] = temp
    y = np.delete(y, noImg,0); faceassset = np.delete(faceassset, noImg, 0)
    nPics = len(y)
    index = random.sample(np.arange(nPics), int(nPics*test_data_rate))
    x_test = faceassset[index,:,:]; x_train = np.delete(faceassset, index, 0)
    y_test = y[index]; y_train = np.delete(y, index, 0)
    return (x_train, y_train), (x_test, y_test) 
Example 15
Project: Google-QuickDraw   Author: ankonzoid   File: QuickDraw_noisy_classifier.py    (MIT License) View Source Project 6 votes vote down vote up
def plot_labeled_images_random(image_list, label_list, categories, n, title_str, ypixels, xpixels, seed, filename):
    random.seed(seed)
    index_sample = random.sample(range(len(image_list)), n)
    plt.figure(figsize=(2*n, 2))
    #plt.suptitle(title_str)
    for i, ind in enumerate(index_sample):
        ax = plt.subplot(1, n, i + 1)
        plt.imshow(image_list[ind].reshape(ypixels, xpixels))
        plt.gray()
        ax.set_title(categories[label_list[ind]], fontsize=20)
        ax.get_xaxis().set_visible(False); ax.get_yaxis().set_visible(False)
    if 1:
        pylab.savefig(filename, bbox_inches='tight')
    else:
        plt.show()

# plot_unlabeled_images_random: plots unlabeled images at random 
Example 16
Project: Google-QuickDraw   Author: ankonzoid   File: QuickDraw_noisy_classifier.py    (MIT License) View Source Project 6 votes vote down vote up
def plot_unlabeled_images_random(image_list, n, title_str, ypixels, xpixels, seed, filename):
    random.seed(seed)
    index_sample = random.sample(range(len(image_list)), n)
    plt.figure(figsize=(2*n, 2))
    plt.suptitle(title_str)
    for i, ind in enumerate(index_sample):
        ax = plt.subplot(1, n, i + 1)
        plt.imshow(image_list[ind].reshape(ypixels, xpixels))
        plt.gray()
        ax.get_xaxis().set_visible(False); ax.get_yaxis().set_visible(False)
    if 1:
        pylab.savefig(filename, bbox_inches='tight')
    else:
        plt.show()

# plot_compare: given test images and their reconstruction, we plot them for visual comparison 
Example 17
Project: GraphTime   Author: GlooperLabs   File: simulate.py    (license) View Source Project 6 votes vote down vote up
def generate_graphs(self, n_edges_list, use_seed=True):
        """For each number of edges (n_edges) in n_edges_list create
        an Erdos Renyi Precision Graph that allows us to sample
        from later.

        Parameters
        ----------
        n_edges : list[int] or int
            list of number of edges for each graph or scalar
            if only one graph is wanted
        use_seed : bool
            indicates if seed shall be reset
        """
        if use_seed and self.seed is not None:
            random.seed(self.seed)

        n_edges = n_edges_list if type(n_edges_list) is list \
            else [n_edges_list]

        self.graphs = [ErdosRenyiPrecisionGraph(self.n_vertices, n_es)
                       for n_es in n_edges] 
Example 18
Project: dogs-vs-cats   Author: yaricom   File: im2rec.py    (MIT License) View Source Project 6 votes vote down vote up
def make_list(args):
    image_list = list_image(args.root, args.recursive, args.exts)
    image_list = list(image_list)
    if args.shuffle is True:
        random.seed(100)
        random.shuffle(image_list)
    N = len(image_list)
    chunk_size = (N + args.chunks - 1) / args.chunks
    for i in xrange(args.chunks):
        chunk = image_list[i * chunk_size:(i + 1) * chunk_size]
        if args.chunks > 1:
            str_chunk = '_%d' % i
        else:
            str_chunk = ''
        sep = int(chunk_size * args.train_ratio)
        sep_test = int(chunk_size * args.test_ratio)
        if args.train_ratio == 1.0:
            write_list(args.prefix + str_chunk + '.lst', chunk)
        else:
            if args.test_ratio:
                write_list(args.prefix + str_chunk + '_test.lst', chunk[:sep_test])
            if args.train_ratio + args.test_ratio < 1.0:
                write_list(args.prefix + str_chunk + '_val.lst', chunk[sep_test + sep:])
            write_list(args.prefix + str_chunk + '_train.lst', chunk[sep_test:sep_test + sep]) 
Example 19
Project: ptm   Author: GrivIN   File: factory.py    (MIT License) View Source Project 6 votes vote down vote up
def get_random_string(length=12,
                      allowed_chars='abcdefghijklmnopqrstuvwxyz'
                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
    """
    Returns a securely generated random string.

    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
    """
    if not using_sysrandom:
        # This is ugly, and a hack, but it makes things better than
        # the alternative of predictability. This re-seeds the PRNG
        # using a value that is hard for an attacker to predict, every
        # time a random string is required. This may change the
        # properties of the chosen random sequence slightly, but this
        # is better than absolute predictability.
        random.seed(
            hashlib.sha256(
                ("%s%s" % (random.getstate(), time.time())).encode('utf-8')
            ).digest())
    return ''.join(random.choice(allowed_chars) for i in range(length)) 
Example 20
Project: CLAM   Author: Xinglab   File: CLAM.fdr_peak.MP.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
def write_parameter_log(options, output_dir):
	"""
	Write paramter values to a log file, named by current time.
	"""
	merge_method_dict={1:'narrowPeak', 2:'broadPeak'}
	correction_method_dict={1:'Bonferroni', 2:'BH_FDR'}
	with open(output_dir+'/CLAM_Peaker.Parameters.'+ strftime("%Y%m%d_%H%M") + '.txt', 'w') as log:
		log.write('CLAM Peaker ' + __version__ + '\n')
		log.write('resume: ' + str(options.resume) + '\n')
		log.write('verbose: ' + str(options.verbose) + '\n')
		log.write('output_dir:' + str(options.output_dir) + '\n')
		log.write('tmp_dir: ' + str(options.tmp_dir) + '\n')
		log.write('peak_file: ' + str(options.peak_file) + '\n')
		log.write('is_stranded: ' + str(options.is_stranded) + '\n')
		log.write('extend: ' + str(options.extend) + '\n')
		log.write('pval_cutoff: ' + str(options.pval_cutoff) + '\n')
		log.write('merge_size: ' + str(options.merge_size) + '\n')
		log.write('max_iter: ' + str(options.max_iter) + '\n')
		log.write('gtf: ' + str(options.gtf) + '\n')
		log.write('seed: ' + str(options.seed) + '\n')
		log.write('merge_method: ' + merge_method_dict[options.merge_method] + '\n')
		log.write('correction_method: ' + correction_method_dict[options.correction_method] + '\n')
		log.write('thread: ' + str(options.nb_proc) + '\n') 
Example 21
Project: CLAM   Author: Xinglab   File: CLAM.fdr_peak.MP.py    (GNU General Public License v3.0) View Source Project 6 votes vote down vote up
def write_parameter_log(options, output_dir):
	"""
	Write paramter values to a log file, named by current time.
	"""
	merge_method_dict={1:'narrowPeak', 2:'broadPeak'}
	correction_method_dict={1:'Bonferroni', 2:'BH_FDR'}
	with open(output_dir+'/CLAM_Peaker.Parameters.'+ strftime("%Y%m%d_%H%M") + '.txt', 'w') as log:
		log.write('CLAM Peaker ' + __version__ + '\n')
		log.write('resume: ' + str(options.resume) + '\n')
		log.write('verbose: ' + str(options.verbose) + '\n')
		log.write('output_dir:' + str(options.output_dir) + '\n')
		log.write('tmp_dir: ' + str(options.tmp_dir) + '\n')
		log.write('peak_file: ' + str(options.peak_file) + '\n')
		log.write('is_stranded: ' + str(options.is_stranded) + '\n')
		log.write('extend: ' + str(options.extend) + '\n')
		log.write('pval_cutoff: ' + str(options.pval_cutoff) + '\n')
		log.write('merge_size: ' + str(options.merge_size) + '\n')
		log.write('max_iter: ' + str(options.max_iter) + '\n')
		log.write('gtf: ' + str(options.gtf) + '\n')
		log.write('seed: ' + str(options.seed) + '\n')
		log.write('merge_method: ' + merge_method_dict[options.merge_method] + '\n')
		log.write('correction_method: ' + correction_method_dict[options.correction_method] + '\n')
		log.write('thread: ' + str(options.nb_proc) + '\n') 
Example 22
Project: ProtScan   Author: gianlucacorrado   File: peak.py    (MIT License) View Source Project 6 votes vote down vote up
def split_keys(profiles, bin_sites, random_state=1234):
    """Balanced split over binding/non-binding sequences."""
    random.seed(random_state)
    pos_keys = bin_sites.keys()
    neg_keys = list(set(profiles.keys()) - set(pos_keys))
    random.shuffle(pos_keys)
    random.shuffle(neg_keys)

    len_pos = len(pos_keys)
    pos_keys1 = pos_keys[:len_pos / 2]
    pos_keys2 = pos_keys[len_pos / 2:]

    len_neg = len(neg_keys)
    neg_keys1 = neg_keys[:len_neg / 2]
    neg_keys2 = neg_keys[len_neg / 2:]

    return [pos_keys1, pos_keys2, neg_keys1, neg_keys2] 
Example 23
Project: neural-abstract-anaphora   Author: amarasovic   File: data_utils.py    (license) View Source Project 6 votes vote down vote up
def get_batches(data, batch_size, vocabulary, pos_vocabulary):
    '''
    Get batches without any restrictions on number of antecedents and negative candidates.
    '''
    random.seed(24)
    random.shuffle(data)

    data_size = len(data)
    if data_size % float(batch_size) == 0:
        num_batches = int(data_size / float(batch_size))
    else:
        num_batches = int(data_size / float(batch_size)) + 1

    batches = []
    for batch_num in range(num_batches):
        start_index = batch_num * batch_size
        end_index = min((batch_num + 1) * batch_size, data_size)

        batch = pad_batch(data[start_index:end_index], vocabulary, pos_vocabulary)
        batches.append(batch)

    logging.info('Data size: %s' % len(data))
    logging.info('Number of batches: %s' % len(batches))

    return batches 
Example 24
Project: kaggle-review   Author: daxiongshu   File: utils.py    (license) View Source Project 6 votes vote down vote up
def split(flags):
    if os.path.exists(flags.split_path):
        return np.load(flags.split_path).item()
    folds = flags.folds
    path = flags.input_path
    random.seed(6)
    img_list = ["%s/%s"%(path,img) for img in os.listdir(path)]
    random.shuffle(img_list)
    dic = {}
    n = len(img_list)
    num = (n+folds-1)//folds
    for i in range(folds):
        s,e = i*num,min(i*num+num,n)
        dic[i] = img_list[s:e]
    np.save(flags.split_path,dic)
    return dic 
Example 25
Project: speechless   Author: JuliusKunze   File: corpus.py    (MIT License) View Source Project 6 votes vote down vote up
def randomly_grouped_by(key_from_example: Callable[[LabeledExample], Any], training_share: float = .9) -> Callable[
        [List[LabeledExample]], Tuple[List[LabeledExample], List[LabeledExample]]]:
        def split(examples: List[LabeledExample]) -> Tuple[List[LabeledExample], List[LabeledExample]]:
            examples_by_directory = group(examples, key=key_from_example)
            directories = examples_by_directory.keys()

            # split must be the same every time:
            random.seed(42)
            keys = set(random.sample(directories, int(training_share * len(directories))))

            training_examples = [example for example in examples if key_from_example(example) in keys]
            test_examples = [example for example in examples if key_from_example(example) not in keys]

            return training_examples, test_examples

        return split 
Example 26
Project: BlueWhale   Author: caffe2   File: test_ml_trainer.py    (license) View Source Project 6 votes vote down vote up
def gen_training_data(
    num_features,
    num_training_samples,
    num_outputs,
    noise_scale=0.1,
):
    np.random.seed(0)
    random.seed(1)
    input_distribution = stats.norm()
    training_inputs = input_distribution.rvs(
        size=(num_training_samples, num_features)
    ).astype(np.float32)
    weights = np.random.normal(size=(num_outputs, num_features)
                              ).astype(np.float32).transpose()
    noise = np.multiply(
        np.random.normal(size=(num_training_samples, num_outputs)), noise_scale
    )
    training_outputs = (np.dot(training_inputs, weights) +
                        noise).astype(np.float32)

    return training_inputs, training_outputs, weights, input_distribution 
Example 27
Project: CopyNet   Author: MultiPath   File: bst_dataset.py    (MIT License) View Source Project 6 votes vote down vote up
def test(args=None, BSTtype=BST):
    import random, sys
    random.seed(19920206)
    if not args:
        args = sys.argv[1:]
    if not args:
        print 'usage: %s <number-of-random-items | item item item ...>' % \
              sys.argv[0]
        sys.exit()
    elif len(args) == 1:
        items = (random.randrange(100) for i in xrange(int(args[0])))
    else:
        items = [int(i) for i in args]

    tree   = BSTtype()
    source = []
    for item in items:
        tree.insert(item)
        source += [str(item)]
    print ' '.join(source)
    print tree 
Example 28
Project: CopyNet   Author: MultiPath   File: bst_dataset.py    (MIT License) View Source Project 6 votes vote down vote up
def generate():
    import random, sys
    random.seed(19920206)

    Lmin   = 2 ** 2 - 1
    Lmax   = 2 ** 4 - 1
    Xnum   = 1000000
    voc    = 26

    wfile  = open('/home/thoma/Work/Dial-DRL/dataset/BST_1M.txt', 'w')
    for id in xrange(Xnum):
        tree   = BST()
        items  = (random.randrange(voc) for i in
                 xrange(random.randint(Lmin, Lmax)))
        source = []
        for item in items:
            item = chr(item + 65)
            tree.insert(item)
            source += [str(item)]
        source = ' '.join(source)
        target = str(tree)
        line   = '{0} -> {1}'.format(source, target)
        wfile.write(line + '\n')
        if id % 10000 == 0:
            print id 
Example 29
Project: deeppavlov   Author: deepmipt   File: agents.py    (license) View Source Project 6 votes vote down vote up
def add_cmdline_args(argparser):
        """Parameters of agent and default values"""
        group = argparser.add_argument_group('Coreference Teacher')
        group.add_argument('--language', type=str, default='ru')
        group.add_argument('--predictions_folder', type=str, default='predicts',
                           help='folder where to dump conll predictions, scorer will use this folder')
        group.add_argument('--scorer_path', type=str, default='scorer/reference-coreference-scorers/v8.01/scorer.pl',
                           help='path to CoNLL scorer perl script')
        group.add_argument('--valid_ratio', type=float,
                           default=0.2, help='valid_set ratio')
        group.add_argument('--test_ratio', type=float,
                           default=0.2, help='test_set ratio')
        group.add_argument('--teacher_seed', type=int, default=42, help='seed')
        group.add_argument('--raw-dataset-path', type=str, default=None,
                             help='Path to folder with two subfolders: dataset and scorer. '
                                  'These two folders are extracted rucoref_29.10.2015.zip and '
                                  'reference-coreference-scorers.v8.01.tar.gz') 
Example 30
Project: deeppavlov   Author: deepmipt   File: agents.py    (license) View Source Project 6 votes vote down vote up
def __init__(self, opt, shared=None):
        """Initialize the parameters of the DefaultTeacher"""
        assert opt['train_part'] + opt['test_part'] + opt['valid_part'] == 1
        self.parts = [opt['train_part'], opt['valid_part'], opt['test_part']]
        # store datatype
        self.dt = opt['datatype'].split(':')[0]
        self.opt = opt
        opt['datafile'] = _path(opt)

        # store identifier for the teacher in the dialog
        self.id = 'ner_teacher'

        random_state = random.getstate()
        random.seed(opt.get('teacher_seed'))
        self.random_state = random.getstate()
        random.setstate(random_state)

        if shared and shared.get('metrics'):
            self.metrics = shared['metrics']
        else:
            self.metrics = CoNLLClassificationMetrics(opt['model_file'])

        # define standard question, since it doesn't change for this task
        super().__init__(opt, shared) 
Example 31
Project: iotronic   Author: openstack   File: service.py    (license) View Source Project 6 votes vote down vote up
def _child_process(self, service):
        self._child_process_handle_signal()

        # Reopen the eventlet hub to make sure we don't share an epoll
        # fd with parent and/or siblings, which would be bad
        eventlet.hubs.use_hub()

        # Close write to ensure only parent has it open
        os.close(self.writepipe)
        # Create greenthread to watch for parent to close pipe
        eventlet.spawn_n(self._pipe_watcher)

        # Reseed random number generator
        random.seed()

        launcher = Launcher()
        launcher.launch_service(service)
        return launcher 
Example 32
Project: CodingDojo   Author: ComputerSocietyUNB   File: crypto.py    (license) View Source Project 6 votes vote down vote up
def get_random_string(length=12,
                      allowed_chars='abcdefghijklmnopqrstuvwxyz'
                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
    """
    Returns a securely generated random string.

    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
    """
    if not using_sysrandom:
        # This is ugly, and a hack, but it makes things better than
        # the alternative of predictability. This re-seeds the PRNG
        # using a value that is hard for an attacker to predict, every
        # time a random string is required. This may change the
        # properties of the chosen random sequence slightly, but this
        # is better than absolute predictability.
        random.seed(
            hashlib.sha256(
                ("%s%s%s" % (
                    random.getstate(),
                    time.time(),
                    settings.SECRET_KEY)).encode('utf-8')
            ).digest())
    return ''.join(random.choice(allowed_chars) for i in range(length)) 
Example 33
Project: cpsc415   Author: WheezePuppet   File: chunk_vacuum.py    (license) View Source Project 6 votes vote down vote up
def run(self, vacuum_class, max_steps=10000):
        scores = []

        for seed in seeds:
            logging.debug('Running seed {}...'.format(seed))
            random.seed(seed)
            dve = RandomDirtyVacuumEnvironment()
            dve.add_to_random_empty_square(vacuum_class())
            step = 0
            steps_to_clean = 0
            while step < max_steps:
                dve.step()
                step += 1
                if not dve.is_clean():
                    steps_to_clean += 1
            scores.append(Result(seed, dve.agents[0].performance,
                steps_to_clean))
        return scores 
Example 34
Project: ConceptualSpaces   Author: lbechberger   File: concept_test.py    (license) View Source Project 6 votes vote down vote up
def test_sample_two_dimensions_one_cuboid_property(self):
        random.seed(42)
        doms = {0:[0], 1:[1]}
        dom = {0:[0]}
        cs.init(2, doms)
        s = Core([Cuboid([0.5, float("-inf")],[0.7, float("inf")],dom)], dom)
        w = Weights({0:1}, {0:{0:1}})
        f = Concept(s, 1.0, 10.0, w)    
        
        expected_samples = [[0.671077246097072, -1.1182375118372132], [0.7223363669989505, 0.8182873448596939], 
                            [0.8341255198319808, 0.43652402266795276], [0.4349365229310276, 1.658190358962174], 
                            [0.6150663198218392, -1.6363623513048244], [0.47689201330881126, -1.7458891753921715], 
                            [0.5268116788866108, 1.8152637100843205], [0.8197557203077108, 0.43588084575268926], 
                            [0.6480058823075816, -1.997712415488226], [0.5778432024671717, -1.7231499261264656], 
                            [0.6787669258743846, -0.9397734842397636], [0.47843872817402455, -1.1528071782316718], 
                            [0.6277970899463485, -1.5159832165269371], [0.7123582792556478, -0.10931589475282344], 
                            [0.4909539247388911, -0.3056855079203169], [0.5187297023218571, -0.31247344066238325], 
                            [0.5772907067965353, -1.1450108032032733], [0.6882004507621521, 0.873633101185304], 
                            [0.6667338652830263, 0.9919022415162564], [0.4722500795674033, 0.3346891571648989]]
        samples = f.sample(20)
        self.assertEqual(samples, expected_samples) 
Example 35
Project: mesh_maze   Author: elfnor   File: mesh_maze.py    (license) View Source Project 6 votes vote down vote up
def generate_maze(bm, maze_params):
    """
    generate the maze on the bm bmesh
    """
    bm.verts.ensure_lookup_table()
    bm.edges.ensure_lookup_table()
    sel_geom, inner_edges = get_inner_edges(bm, maze_params['boundary_type'])
    if maze_params['maze_update']:
        all_edges = sorted(bm.edges, key=lambda edge: edge.index)
        full_mesh = inner_edges == all_edges
        random.seed(maze_params['rseed'])
        maze_path, maze_verts = recursive_back_tracker_maze(inner_edges, full_mesh)
        if maze_params['braid'] > 0.0:
            maze_path = do_braid(maze_path, maze_verts, maze_params['braid'])

        link_centers, vert_centers = get_maze_centers(maze_path, maze_verts)
    else:
        link_centers = maze_params['link_centers']
        vert_centers = maze_params['vert_centers']

    bevel_extrude(bm, sel_geom, maze_params, link_centers, vert_centers)
    return bm, link_centers, vert_centers 
Example 36
Project: BioQueue   Author: liyao001   File: install.py    (license) View Source Project 6 votes vote down vote up
def get_random_secret_key():
    import random
    import hashlib
    import time
    try:
        random = random.SystemRandom()
        using_sysrandom = True
    except NotImplementedError:
        import warnings
        warnings.warn('A secure pseudo-random number generator is not available '
                      'on your system. Falling back to Mersenne Twister.')
        using_sysrandom = False

    chars = '[email protected]#$%^&*(-_=+)'
    if not using_sysrandom:
        random.seed(
            hashlib.sha256(
                ("%s%s%s" % (
                    random.getstate(),
                    time.time(),
                    'BioQueue')).encode('utf-8')
            ).digest())
    return ''.join(random.choice(chars) for i in range(50)) 
Example 37
Project: coralillo   Author: getfleety   File: hashing.py    (license) View Source Project 6 votes vote down vote up
def get_random_string(length=12,
                      allowed_chars='abcdefghijklmnopqrstuvwxyz'
                                    'ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789'):
    """
    Return a securely generated random string.
    The default length of 12 with the a-z, A-Z, 0-9 character set returns
    a 71-bit value. log_2((26+26+10)^12) =~ 71 bits
    """
    if not using_sysrandom:
        # This is ugly, and a hack, but it makes things better than
        # the alternative of predictability. This re-seeds the PRNG
        # using a value that is hard for an attacker to predict, every
        # time a random string is required. This may change the
        # properties of the chosen random sequence slightly, but this
        # is better than absolute predictability.
        random.seed(
            hashlib.sha256(
                ('%s%s%s' % (random.getstate(), time.time(), settings.SECRET_KEY)).encode()
            ).digest()
        )
        return ''.join(random.choice(allowed_chars) for i in range(length)) 
Example 38
Project: turtle   Author: icse-turtle   File: Functions.py    (license) View Source Project 6 votes vote down vote up
def __init__(self):
        Module.__init__(self)
        self.add_method('+', self.addition)
        self.add_method('-', self.subtraction)
        self.add_method('*', self.multiplication)
        self.add_method('/', self.division)
        self.add_method('%', self.module)
        self.add_method('**', self.power)
        self.add_method('abs', self.abs)
        self.add_method('min', self.minimum)
        self.add_method('max', self.maximum)
        self.add_method('strcat', self.strcat)
        self.add_method('substr', self.substr)
        self.add_method('strlen', self.strlen)
        self.add_method('strindex', self.strindex)
        self.add_method('symcat', self.symcat)
        self.add_method('randint', self.randint)

        random.seed(time.time()) 
Example 39
Project: Steganography   Author: Ludisposed   File: Steganography.py    (license) View Source Project 6 votes vote down vote up
def retrieve_lsb(data, magic):
    '''
    A method that retrieves the least significant bits of the picture

    Args:
        data     (list): The list representation of the image
        magic    (str) : The password

    Returns:
        The list representation of the image with retrieved text from random lsb's
    '''
    print '[*] Retrieving message from image'

    retrieve_range = range(data.size)
    if not magic is None:
        random.seed(generate_seed(magic))
        retrieve_range = random_ints(data.size)

    return retrieve(data, retrieve_range) 
Example 40
Project: Maps   Author: DarkPurple141   File: name_gen.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def __init__(self,location = None):
        random.seed()
        self.name = generate_name()
        self.location = location
        self.cities = [] 
Example 41
Project: Maps   Author: DarkPurple141   File: voronoi.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def __init__(self,seed):
        random.seed(seed)
        self.ISLAND_FACTOR = 1.13 # 1.0 means no small islands; 2.0 leads to a lot
        self.bumps = random.randrange(1,7)
        self.startAngle = random.uniform(0,2*math.pi)
        self.dipAngle = random.uniform(0,2*math.pi)
        self.dipWidth = random.uniform(0.2,0.7) 
Example 42
Project: pylspm   Author: lseman   File: plsr2.py    (MIT License) View Source Project 5 votes vote down vote up
def HOCcat(data_, mvmodel, seed):
    response = data_.ix[:, 10:25]
    preditors = []
    preditors.append(data_.ix[:, 10:15])
    preditors.append(data_.ix[:, 15:20])
    preditors.append(data_.ix[:, 20:25])

    plsr_ = None
    for i in range(3):
        res_ = plsr2(preditors[i], response, seed=seed)[0]
        plsr_ = res_ if plsr_ is None else np.hstack((plsr_, res_))

    plsr_ = pd.DataFrame(plsr_)
    plsr_.index = range(len(plsr_))

    cols = list(plsr_.columns)
    for s in range(len(cols)):
        cols[cols.index(s)] = 'T' + str(s)
    plsr_.columns = cols

    data_ = pd.concat([data_, plsr_], axis=1)

    Variables = pd.read_csv(mvmodel)
    Variables = Variables[
        Variables.latent.str.contains("Humanização") == False]

    for i in range(len(cols)):
        df_ = pd.DataFrame([['Humanização', cols[i], 'A']],
                           columns=Variables.columns)
        Variables = Variables.append(df_)

    Variables.index = range(len(Variables))
    mvmodel = Variables

    return[data_, mvmodel] 
Example 43
Project: tree-gen   Author: friggog   File: gen.py    (GNU General Public License v3.0) View Source Project 5 votes vote down vote up
def construct(params, seed=0, render=False, out_path=None):
    """Construct the tree"""
    if seed == 0:
        seed = int(random.random() * 9999999)
        # print('Seed: ', seed)
    random.seed(seed)
    Tree(TreeParam(params)).make()
    if render:
        bpy.data.scenes['Scene'].render.filepath = out_path
        bpy.ops.render.render(write_still=True)

#mod = __import__('ch_trees.parametric.tree_params.quaking_aspen', fromlist=[''])
#reload(mod)
#construct(mod.params) 
Example 44
Project: nidaqmx-python   Author: ni   File: test_stream_counter_readers_writers.py    (license) View Source Project 5 votes vote down vote up
def test_one_sample_uint32(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        number_of_pulses = random.randint(2, 50)
        frequency = random.uniform(1000, 10000)

        # Select random counters from the device.
        counters = random.sample(self._get_device_counters(x_series_device), 2)

        with nidaqmx.Task() as write_task, nidaqmx.Task() as read_task:
            write_task.co_channels.add_co_pulse_chan_freq(
                counters[0], freq=frequency)
            write_task.timing.cfg_implicit_timing(
                samps_per_chan=number_of_pulses)

            read_task.ci_channels.add_ci_count_edges_chan(counters[1])
            read_task.ci_channels.all.ci_count_edges_term = (
                '/{0}InternalOutput'.format(counters[0]))

            reader = CounterReader(read_task.in_stream)

            read_task.start()
            write_task.start()

            write_task.wait_until_done(timeout=2)

            value_read = reader.read_one_sample_uint32()
            assert value_read == number_of_pulses 
Example 45
Project: nidaqmx-python   Author: ni   File: test_stream_counter_readers_writers.py    (license) View Source Project 5 votes vote down vote up
def test_one_sample_double(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        frequency = random.uniform(1000, 10000)

        # Select random counters from the device.
        counters = random.sample(
            self._get_device_counters(x_series_device), 2)

        with nidaqmx.Task() as write_task, nidaqmx.Task() as read_task:
            write_task.co_channels.add_co_pulse_chan_freq(
                counters[0], freq=frequency)
            write_task.timing.cfg_implicit_timing(
                sample_mode=AcquisitionType.CONTINUOUS)
            actual_frequency = write_task.co_channels.all.co_pulse_freq

            read_task.ci_channels.add_ci_freq_chan(
                counters[1], min_val=1000, max_val=10000)
            read_task.ci_channels.all.ci_freq_term = (
                '/{0}InternalOutput'.format(counters[0]))

            reader = CounterReader(read_task.in_stream)

            read_task.start()
            write_task.start()

            value_read = reader.read_one_sample_double()

            numpy.testing.assert_allclose(
                [value_read], [actual_frequency], rtol=0.05) 
Example 46
Project: nidaqmx-python   Author: ni   File: test_stream_counter_readers_writers.py    (license) View Source Project 5 votes vote down vote up
def test_multi_sample_double(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        number_of_samples = random.randint(2, 50)
        frequency = random.uniform(1000, 10000)

        # Select random counters from the device.
        counters = random.sample(
            self._get_device_counters(x_series_device), 3)

        with nidaqmx.Task() as write_task, nidaqmx.Task() as read_task:
            write_task.co_channels.add_co_pulse_chan_freq(
                counters[1], freq=frequency)
            write_task.timing.cfg_implicit_timing(
                samps_per_chan=number_of_samples + 1)

            read_task.ci_channels.add_ci_freq_chan(
                counters[2], min_val=1000, max_val=10000, edge=Edge.RISING)
            read_task.ci_channels.all.ci_freq_term = (
                '/{0}InternalOutput'.format(counters[1]))
            read_task.timing.cfg_implicit_timing(
                samps_per_chan=number_of_samples)

            read_task.start()
            write_task.start()
            write_task.wait_until_done(timeout=2)

            reader = CounterReader(read_task.in_stream)

            values_read = numpy.zeros(number_of_samples, dtype=numpy.float64)
            reader.read_many_sample_double(
                values_read, number_of_samples_per_channel=number_of_samples,
                timeout=2)

            expected_values = [frequency for _ in range(number_of_samples)]

            numpy.testing.assert_allclose(
                values_read, expected_values, rtol=0.05) 
Example 47
Project: nidaqmx-python   Author: ni   File: test_stream_counter_readers_writers.py    (license) View Source Project 5 votes vote down vote up
def test_one_sample_pulse_freq(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        frequency = random.uniform(1000, 10000)
        duty_cycle = random.uniform(0.2, 0.8)

        # Select random counters from the device.
        counters = random.sample(self._get_device_counters(x_series_device), 2)

        with nidaqmx.Task() as write_task, nidaqmx.Task() as read_task:
            write_task.co_channels.add_co_pulse_chan_freq(
                counters[0], freq=frequency, duty_cycle=duty_cycle)
            write_task.timing.cfg_implicit_timing(
                sample_mode=AcquisitionType.CONTINUOUS)

            read_task.ci_channels.add_ci_pulse_chan_freq(
                counters[1], min_val=1000, max_val=10000)
            read_task.ci_channels.all.ci_pulse_freq_term = (
                '/{0}InternalOutput'.format(counters[0]))

            read_task.start()
            write_task.start()

            reader = CounterReader(read_task.in_stream)

            value_read = reader.read_one_sample_pulse_frequency()
            write_task.stop()

            assert numpy.isclose(value_read.freq, frequency, rtol=0.05)
            assert numpy.isclose(value_read.duty_cycle, duty_cycle, rtol=0.05) 
Example 48
Project: nidaqmx-python   Author: ni   File: test_stream_counter_readers_writers.py    (license) View Source Project 5 votes vote down vote up
def test_one_sample_pulse_time(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        high_time = random.uniform(0.0001, 0.001)
        low_time = random.uniform(0.0001, 0.001)

        # Select random counters from the device.
        counters = random.sample(self._get_device_counters(x_series_device), 2)

        with nidaqmx.Task() as write_task, nidaqmx.Task() as read_task:
            write_task.co_channels.add_co_pulse_chan_time(
                counters[0], high_time=high_time, low_time=low_time)
            write_task.timing.cfg_implicit_timing(
                sample_mode=AcquisitionType.CONTINUOUS)

            read_task.ci_channels.add_ci_pulse_chan_time(
                counters[1], min_val=0.0001, max_val=0.001)
            read_task.ci_channels.all.ci_pulse_time_term = (
                '/{0}InternalOutput'.format(counters[0]))

            read_task.start()
            write_task.start()

            reader = CounterReader(read_task.in_stream)
            value_read = reader.read_one_sample_pulse_time()
            write_task.stop()

            assert numpy.isclose(value_read.high_time, high_time, rtol=0.05)
            assert numpy.isclose(value_read.low_time, low_time, rtol=0.05) 
Example 49
Project: nidaqmx-python   Author: ni   File: test_stream_counter_readers_writers.py    (license) View Source Project 5 votes vote down vote up
def test_pulse_ticks_1_samp(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        high_ticks = random.randint(100, 1000)
        low_ticks = random.randint(100, 1000)
        starting_edge = random.choice([Edge.RISING, Edge.FALLING])

        # Select random counters from the device.
        counters = random.sample(self._get_device_counters(x_series_device), 2)

        with nidaqmx.Task() as write_task, nidaqmx.Task() as read_task:
            write_task.co_channels.add_co_pulse_chan_ticks(
                counters[0],
                '/{0}/100kHzTimebase'.format(x_series_device.name),
                high_ticks=high_ticks, low_ticks=low_ticks)
            write_task.timing.cfg_implicit_timing(
                sample_mode=AcquisitionType.CONTINUOUS)

            read_task.ci_channels.add_ci_pulse_chan_ticks(
                counters[1], source_terminal='/{0}/100kHzTimebase'.format(
                    x_series_device.name),
                min_val=100, max_val=1000)
            read_task.ci_channels.all.ci_pulse_ticks_term = (
                '/{0}InternalOutput'.format(counters[0]))
            read_task.ci_channels.all.ci_pulse_ticks_starting_edge = (
                starting_edge)

            read_task.start()
            write_task.start()

            reader = CounterReader(read_task.in_stream)
            value_read = reader.read_one_sample_pulse_ticks()
            write_task.stop()

            assert numpy.isclose(
                value_read.high_tick, high_ticks, rtol=0.05, atol=1)
            assert numpy.isclose(
                value_read.low_tick, low_ticks, rtol=0.05, atol=1) 
Example 50
Project: nidaqmx-python   Author: ni   File: test_utils.py    (license) View Source Project 5 votes vote down vote up
def test_unflatten_channel_string(self, x_series_device, seed):
        # Reset the pseudorandom number generator with seed.
        random.seed(seed)

        channels = ['Dev1/ai0', 'Dev1/ai1', 'Dev1/ai3', 'Dev2/ai0']
        flattened_channels = 'Dev1/ai0:1,Dev1/ai3,Dev2/ai0'
        assert unflatten_channel_string(flattened_channels) == channels

        assert unflatten_channel_string('') == []