def checkEvent(self):
        pass
        random.seed()

        event_value = random.uniform(0, 1)
        encounter_chance = 0.03 + BASE_ENEMY_ENCOUNTER_CHANCE * self.danger 
        
        if self.player.hiding: 
            h_event_value = random.uniform(0, 1)
            h_encounter_chance = 0.03 + BASE_HIDE_ENCOUNTER_CHANCE * self.hide_danger 
            if h_event_value <= h_encounter_chance:
                encounter_chance = 1
            else:
                encounter_chance = -1
        
        if STORY_MODE and self.map.stevendorf and not self.map.boss_fight:
            self.map.boss_fight = True
            self.current_enemy = self.enemy_factory.generateEnemy(self.level, boss=self.map.stevendorf or self.encounter_sdorf, dorfweap=14)
            self.runEvent()

        elif event_value <= encounter_chance and not self.invuln_turns:
            # spawn an enemy TODO generator
            self.current_enemy = self.enemy_factory.get_next_enemy()
            self.runEvent()
            self.current_enemy = None

        if self.invuln_turns: self.invuln_turns -= 1
        self.player.hiding = False

    def setup(self, bottom, top):
        # config
        params = eval(self.param_str)
        self.data_root_dir = params['data_root_dir']
        self.mean = np.array((104.00699, 116.66877, 122.67892), dtype=np.float32)
        self.random = params.get('randomize', True)
        self.seed = params.get('seed', None)

        # two tops: data and label
        if len(top) != 2:
            raise Exception("Need to define two tops: data, and label.")
        # data layers have no bottoms
        if len(bottom) != 0:
            raise Exception("Do not define a bottom.")

        # load indices for images and labels
        split_f  = '{}/train_pairs.txt'.format(self.data_root_dir)
        self.indices = open(split_f, 'r').read().splitlines()
        self.idx = 0

        # make eval deterministic
        #if 'train' not in self.split:
        #    self.random = False

        # randomization: seed and pick
        if self.random:
            random.seed(self.seed)
            self.idx = random.randint(0, len(self.indices)-1)

    def __init__(self):
        global ARGS, CONFIG, CONFIG_DIR
        parser = argparse.ArgumentParser(description=(
            "osquery python integration testing."
        ))
        parser.add_argument(
            "--config", metavar="FILE", default=None,
            help="Use special options from a config."
        )
        parser.add_argument(
            "--verbose", default=False, action="store_true",
            help="Run daemons and extensions with --verbose"
        )

        # Directory structure options
        parser.add_argument(
            "--build", metavar="PATH", default=".",
            help="Path to osquery build (./build/<sys>/)."
        )
        ARGS = parser.parse_args()

        if not os.path.exists(ARGS.build):
            print("Cannot find --build: %s" % ARGS.build)
            print("You must first run: make")
            exit(1)

        # Write config
        random.seed(time.time())

        utils.reset_dir(CONFIG_DIR)
        CONFIG = read_config(ARGS.config) if ARGS.config else DEFAULT_CONFIG

    def test_rotational_alignment(self):
        """ Test the rotational alignment in 2D routine (new) """
        random.seed()
        name=self.get_input_file_name("1z5s-projection-2.spi")
        srw = IMP.em2d.SpiderImageReaderWriter()
        image=IMP.em2d.Image()
        image.read(name,srw)
        rotated=IMP.em2d.Image()
        # random rotation
        angle=random.random()*2*pi
        rot=IMP.algebra.Rotation2D(angle)
        transformation = IMP.algebra.Transformation2D(rot)
        IMP.em2d.get_transformed(image.get_data(),rotated.get_data(),
                                 transformation)

        fn_rotated = self.get_input_file_name("rotated.spi")
#        rotated.write(fn_rotated,srw)
        result=IMP.em2d.get_rotational_alignment(
                image.get_data(),rotated.get_data(),True)
        fn_aligned = self.get_input_file_name("rot_aligned.spi")
 #       rotated.write(fn_aligned,srw)
        determined_angle=result[0].get_rotation().get_angle()
        # approximately 6 degrees tolerance, 0.1 rad.
        x = angle+determined_angle
        modulo = (abs(x % (2*pi)) < 0.1) or (abs(x % (2*pi)-2*pi) < 0.1)
        self.assertEqual(modulo,True,msg="Angles applied %f and "
          "determined %f are different, difference %f" % (angle
                                                      ,determined_angle,x))

    def test_complete_alignment(self):
        """ Test the complete alignment in 2D routine (new) """
        random.seed()
        name=self.get_input_file_name("1z5s-projection-2.spi")
        srw = IMP.em2d.SpiderImageReaderWriter()
        image=IMP.em2d.Image()
        image.read(name,srw)
        transformed=IMP.em2d.Image()

        rot=IMP.algebra.Rotation2D(random.random()*2*pi)
        trans=IMP.algebra.Vector2D(random.random()*10,random.random()*10)

        T=IMP.algebra.Transformation2D(rot,trans)
        IMP.em2d.get_transformed(image.get_data(),transformed.get_data(),T)
        fn_transformed = self.get_input_file_name("transformed.spi")
#       transformed.write(fn_transformed,srw)

        result=IMP.em2d.get_complete_alignment(image.get_data(),
                                         transformed.get_data(),True)
        fn_aligned = self.get_input_file_name("aligned_complete.spi")
#       transformed.write(fn_aligned,srw)
        cross_correlation_coefficient = result.second
        # Tolerate 1 pixel error
        self.assertAlmostEqual(cross_correlation_coefficient,1, delta=0.03,
              msg="Error in the complete aligment routine,"
                  "ccc %f less than 0.97" % (cross_correlation_coefficient))

def main():
    """Main function to initialize databases to analysize Yelp data."""
    import random

    # ------------ Save Yelp Data as Pandas DataFrames to pickle ------------
    # Save all Yelp restaurant data in Arizona (Phoenix area)
    #restaurant_data = read_yelp('business',state=['AZ'],open=[True],categories='restaurants')
    #review_data = read_yelp('review',business_id=restaurant_data.business_id.unique())
    restaurant_data = pd.read_pickle('../data/pandas/business.pkl')
    review_data = pd.read_pickle('../data/pandas/review.pkl')
    result = save2pickle(restaurant_data,review_data)
    result = py2mysql(restaurant_data,review_data)

    # Save information for mexican restaurants only
    restaurant_data = restaurant_data[restaurant_data['categories'].map(lambda x: 'mexican' in [cat.lower() for cat in x])]
    review_data = review_data[review_data['business_id'].isin(restaurant_data.business_id.unique())]
    result = save2pickle(restaurant_data,review_data,append_string='_mexican')
    result = py2mysql(restaurant_data,review_data,append_string='_mexican')

    # Segment some data for training
    random.seed(1234)
    trainids = random.sample(restaurant_data.business_id,20)
    restaurant_data = restaurant_data[restaurant_data['business_id'].isin(trainids)]
    review_data = review_data[review_data['business_id'].isin(trainids)]
    result = save2pickle(restaurant_data,review_data,append_string='_mexican_train')

    # Make database of individual sentences from review data
    sentences = process_text.reviews_to_sentences(review_data)
    sentences = process_text.add_training_label(sentences,review_data)
    sentences.to_pickle('../data/pandas/sentences_mexican.pkl')
    result = sentence2mysql(sentences,review_data,append_string='_mexican')

def main(scrape_file, gen_file, min_wait=1.0, max_wait=3.5, **kwargs):
	# seed for waiting
	random.seed()

	if gen_file == scrape_file:
		raise IOError("HEY! Don't use the same file for two things!!!")

	try:
		with open(scrape_file, 'r') as to_scrape:
			if (gen_file):
				genfile = open(gen_file[0], 'w+')
			site_counter = kwargs['site_counter'] # loop break, default=1
			result_number = 1 # counter for filtered set
			for site in to_scrape:
				url = site.rsplit(',')[1].strip()
				url_num = site.rsplit(',')[0].strip()
				# --skip option takes effect here
				if int(url_num) == int(site_counter):
					# get the result, None = failure
					site_result = scrape(url)
					if site_result:
						# record the results
						report_results(url, site_result, gen_file,
							result_number, kwargs['writeout'],
							kwargs['logfile'])
						result_number += 1
					if site_counter >= int(kwargs['site_counter']) +\
					 int(kwargs['max_sites'] - 1):
						break
					# don't want to DoS...
					sleep(random.uniform(min_wait, max_wait))
					site_counter += 1
			
	except IOError, e:
		raise IOError("File " + e.filename + " does not exist!")

def testPrimes(mag=12):
  import random
  random.seed()
  minNum = 10**((mag-1)/2)
  maxNum = 10**((mag)/ 2)
  num1, num2, numProd = (random.randint(minNum, maxNum) for n in range(3))
  num1 *= numProd
  num2 *= numProd
  factors = list(genPrimeFactors(num1))
  factorStr = ' '.join('%d' % f for f in factors)
  if num1 == prod(factors):
    # it worked!
    print('Prime factors of %d are %s' % (num1, factorStr))
    divisorStr = ' '.join('%d' % d for d in sorted(getDivisors(num1)))
    print('Divisors of %d are %s' % (num1, divisorStr))
  else:
    print('Failure. Incorrectly reports prime factors of %d are %s'
      % (num1, factorStr))
  
  gcd = getGreatestCommonDivisor(num1, num2)
  lcm = getLeastCommonMultiple(num1, num2)
  if num1 * num2 / gcd == lcm:
    print('Greatest common divisor of %d and %d is %d' % (num1, num2, gcd))
    print('Least common multiple of %d and %d is %d' % (num1, num2, lcm))
  else:
    print('Failure: found greatest common divisor of %d and %d is %d'
          % (num1, num2, gcd))
    print('Failure: found least common multiple of %d and %d is %d'
          % (num1, num2, lcm))
    factors = list(genPrimeFactors(num2))
    factorStr = ' '.join('%d' % f for f in factors)
    print('Prime factors of %d are %s' % (num2, factorStr))

    def xtest_004_decim_random_vals(self):
        MAX_TAPS = 9
        MAX_DECIM = 7
        OUTPUT_LEN = 9

        random.seed(0)    # we want reproducibility

        for ntaps in xrange(1, MAX_TAPS + 1):
            for decim in xrange(1, MAX_DECIM+1):
                for ilen in xrange(ntaps + decim, ntaps + OUTPUT_LEN*decim):
                    src_data = random_floats(ilen)
                    taps = random_floats(ntaps)
                    expected_result = reference_dec_filter(src_data, decim, taps)

                    tb = gr.top_block()
                    src = gr.vector_source_f(src_data)
                    op = gr.rational_resampler_base_fff(1, decim, taps)
                    dst = gr.vector_sink_f()
                    tb.connect(src, op, dst)
                    tb.run()
                    tb = None
                    result_data = dst.data()
                    L1 = len(result_data)
                    L2 = len(expected_result)
                    L = min(L1, L2)
                    if False:
                        sys.stderr.write('delta = %2d: ntaps = %d decim = %d ilen = %d\n' % (L2 - L1, ntaps, decim, ilen))
                        sys.stderr.write('  len(result_data) = %d  len(expected_result) = %d\n' %
                                         (len(result_data), len(expected_result)))
                    self.assertEqual(expected_result[0:L], result_data[0:L])

def                     Generate():
  random.seed()

  code = "".join([ random.choice(string.ascii_letters + string.punctuation)
                   for x in range(128) ])

  return code

def test_arb():
    random.seed(42)
    s = SetlxSet([42])

    result = stlx_arb(s)
    eq_(result, 42)
    eq_(s, SetlxSet([42]))

def bootstrapRealization(genTable, pathOutput, realization): #Input is table to give Kriging
  import random
  lines = []
  for jj in genTable:
    lines.append(jj)
  # 
  #Shuffling
  #
  newList = []
  for jj in numpy.arange(len(lines)):
    random.seed()
    select = choice(lines)
    # To avoid duplicates, if the line already exists, the positions RA and Dec are  
    # offset by a random value in the range -0.5<D<0.5 arcsec.
    if select in numpy.array(newList):
      select[0] += random.random()-0.5
      select[1] += random.random()-0.5
    #
    if len(select) == 4:
      newList.append([select[0],select[1],select[2],select[3]])
    else:
      newList.append([select[0],select[1],select[2]])
#
  newList = numpy.array(newList)
# Save in dir
  if not(os.path.exists(pathOutput+'/MC'+str(realization))):
    os.mkdir(pathOutput+'/MC'+str(realization))
# Savetxt file
  listTmp = []
  for jj in newList:
    listTmp.append('\t'.join(map(str, jj))) #Join elements of the same line
  fileTMP = open(pathOutput+'/MC'+str(realization)+'/realization_'+str(int(realization))+'_Points.txt', 'wb')
  fileTMP.write("\n".join(listTmp))
  fileTMP.close()
  return True

def _define_forest (ns):
  random.seed(random_seed if isinstance(random_seed,int) else None);
  if not mssel.msname:
    raise RuntimeError,"MS not set up in compile-time options";
  if run_purr:
    print mssel.msname;
    import os.path
    purrlog = os.path.normpath(mssel.msname)+".purrlog";
    Timba.TDL.GUI.purr(purrlog,[mssel.msname,'.']);
  # setup contexts properly
  array,observation = mssel.setup_observation_context(ns);

  # setup imaging options (now that we have an imaging size set up)
  imsel = mssel.imaging_selector(npix=512,arcmin=meqmaker.estimate_image_size());
  TDLRuntimeMenu("Imaging options",*imsel.option_list());

  # reading in model?
  if read_ms_model:
    model_spigots = array.spigots(column="PREDICT",corr=mssel.get_corr_index());
    meqmaker.make_per_ifr_bookmarks(model_spigots,"UV-model visibilities");
  else:
    model_spigots = None;

  # get a predict tree from the MeqMaker
  output = meqmaker.make_predict_tree(ns,uvdata=model_spigots);

  # throw in a bit of noise
  if noise_stddev:
    noisedef = Meq.GaussNoise(stddev=noise_stddev,dims=[2,2],complex=True)
    for p,q in array.ifrs():
      ns.noisy_predict(p,q) << output(p,q) + ( ns.noise(p,q)<<noisedef );
    output = ns.noisy_predict;

  # in add or subtract sim mode, make some spigots and add/subtract visibilities
  if sim_mode == ADD_MS:
    spigots = array.spigots(corr=mssel.get_corr_index());
    for p,q in array.ifrs():
      ns.sum(p,q) << output(p,q) + spigots(p,q);
    output = ns.sum;
  elif sim_mode == SUB_MS:
    spigots = array.spigots(corr=mssel.get_corr_index());
    for p,q in array.ifrs():
      ns.diff(p,q) << spigots(p,q) - output(p,q);
    output = ns.diff;
  else:
    spigots = False;

  meqmaker.make_per_ifr_bookmarks(output,"Output visibilities");

  # make sinks and vdm.
  # The list of inspectors comes in handy here
  Meow.StdTrees.make_sinks(ns,output,spigots=spigots,post=meqmaker.get_inspectors(),corr_index=mssel.get_corr_index());

  # very important -- insert meqmaker's options properly
  TDLRuntimeOptions(*meqmaker.runtime_options());

  TDLRuntimeJob(_tdl_job_1_simulate_MS,"Run simulation",job_id="simulate");

  # close the meqmaker. This produces annotations, etc.
  meqmaker.close();

  def generateSequenceSet(self, numSequenceGroups, sequenceLength, seed):
    sequences = []
    random.seed(seed)
    symbolPool = range(self.symbolPoolSize)

    for i in range(numSequenceGroups):
      shuffledPool = copy.copy(symbolPool)
      random.shuffle(shuffledPool)
      startElement1 = [shuffledPool[0]]
      startElement2 = [shuffledPool[1]]
      endElement1 = [shuffledPool[2]]
      endElement2 = [shuffledPool[3]]
      sequenceElements = shuffledPool[4:(4+sequenceLength-2)]

      sharedSubsequence1 = copy.copy(sequenceElements)
      sharedSubsequence2 = copy.copy(sequenceElements)
      while sharedSubsequence1 == sharedSubsequence2:
        random.shuffle(sharedSubsequence1)
        random.shuffle(sharedSubsequence2)

      sequences.append(startElement1+sharedSubsequence1+endElement1)
      sequences.append(startElement2+sharedSubsequence1+endElement2)
      # sequences.append(startElement1+sharedSubsequence2+endElement2)
      # sequences.append(startElement2+sharedSubsequence2+endElement1)
    return sequences

def main():
	


	random.seed(RANDOM_SEED)
	for arrival_rate in [0.01, 0.02, 0.03, 0.04, 0.05, 0.06, 0.07, 0.08, 0.09]:

		host_current_slot = 1 
		host_num_backoffs = 0 
		

		env = simpy.Environment()
		Packet_Delay = StatObject()
		Server_Idle_Periods = StatObject()
		
		Host1 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host2 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host3 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host4 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host5 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host6 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host7 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host8 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host9 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)
		Host10 = server_queue(env, arrival_rate, Packet_Delay, Server_Idle_Periods, host_current_slot, host_num_backoffs, 1)

		result = store_result()

		list_of_host = [Host1,Host2,Host3,Host4,Host5,Host6,Host7,Host8,Host9,Host10]
		sim = simulation(env,list_of_host, result)
		env.process(sim.run_process(env, list_of_host, result))		
		env.run(until=SIM_TIME)

		print ("Lambda Value: %f" % arrival_rate)
		print ("Throughput: %f" % result.get_throughput())

    def xtest_005_interp_random_vals(self):
        MAX_TAPS = 9
        MAX_INTERP = 7
        INPUT_LEN = 9

        random.seed(0)    # we want reproducibility

        for ntaps in xrange(1, MAX_TAPS + 1):
            for interp in xrange(1, MAX_INTERP+1):
                for ilen in xrange(ntaps, ntaps + INPUT_LEN):
                    src_data = random_floats(ilen)
                    taps = random_floats(ntaps)
                    expected_result = reference_interp_filter(src_data, interp, taps)

                    tb = gr.top_block()
                    src = gr.vector_source_f(src_data)
                    op = gr.rational_resampler_base_fff(interp, 1, taps)
                    dst = gr.vector_sink_f()
                    tb.connect(src, op, dst)
                    tb.run()
                    tb = None
                    result_data = dst.data()
                    L1 = len(result_data)
                    L2 = len(expected_result)
                    L = min(L1, L2)
                    #if True or abs(L1-L2) > 1:
                    if False:
                        sys.stderr.write('delta = %2d: ntaps = %d interp = %d ilen = %d\n' % (L2 - L1, ntaps, interp, ilen))
                        #sys.stderr.write('  len(result_data) = %d  len(expected_result) = %d\n' %
                        #                 (len(result_data), len(expected_result)))
                    #self.assertEqual(expected_result[0:L], result_data[0:L])
                    # FIXME check first ntaps+1 answers
                    self.assertEqual(expected_result[ntaps+1:L], result_data[ntaps+1:L])

def lorem(randseed=None, count=1, method=None):
    u"""
    Creates Lorem Ipsum text.

    Usage format:

        {% lorem [randseed] [count] [method] %}

    ``randseed`` is any hashable object used to initialize the random numbers generator.
    If ``randseed`` is not given the common "Lorem ipsum dolor sit..." text is used.

    ``count`` is a number of paragraphs or sentences to generate (default is 1).

    ``method`` is either ``p`` for HTML paragraphs enclosed in ``<p>`` tags, or ``b`` for
    plain-text paragraph blocks (default is ``b``).

    Notice: This filter is rewrited ``lorem`` filter from ``webdesign`` modul from default Django
    package ``django.contrib.webdesign``. The original ``lorem`` filter does not give stable random
    text, thus its generated paragraphs change on every page refresh. We stabilize the generated
    text by setting a fixed randseed before generating the paragraph.
    """

    state = random.getstate()
    random.seed(randseed)
    res = paragraphs(count, common=(randseed is None))
    random.setstate(state)

    if method == u'p':
        res = [u'<p>{}</p>'.format(p) for p in res]
    return u'\n'.join(res)

def _serve_one(s, listener, alive_r, handlers):
    # close unnecessary stuff and reset signal handlers
    listener.close()
    os.close(alive_r)
    for sig, val in handlers.items():
        signal.signal(sig, val)

    # receive fds from parent process
    fds = reduction.recvfds(s, MAXFDS_TO_SEND + 1)
    s.close()
    assert len(fds) <= MAXFDS_TO_SEND
    (child_r, child_w, _forkserver._forkserver_alive_fd,
     stfd, *_forkserver._inherited_fds) = fds
    semaphore_tracker._semaphore_tracker._fd = stfd

    # send pid to client processes
    write_unsigned(child_w, os.getpid())

    # reseed random number generator
    if 'random' in sys.modules:
        import random
        random.seed()

    # run process object received over pipe
    code = spawn._main(child_r)

    # write the exit code to the pipe
    write_unsigned(child_w, code)

    def _generate_task_id_part(cls, task_id, length):
        # NOTE(stpierre): the first part of the random name is a
        # subset of the task ID
        task_id_part = task_id.replace("-", "")[0:length]

        if len(task_id_part) < length:
            LOG.debug("Task ID %(task_id)s cannot be included in a random "
                      "name because it is too short. Format: %(format)s" %
                      {"task_id": task_id,
                       "format": cls.RESOURCE_NAME_FORMAT})
        elif any(char not in cls.RESOURCE_NAME_ALLOWED_CHARACTERS
                 for char in task_id_part):
            LOG.debug("Task ID %(task_id)s cannot be included in a random "
                      "name because it includes disallowed characters. "
                      "Allowed characters are: %(chars)s" %
                      {"task_id": task_id,
                       "chars": cls.RESOURCE_NAME_ALLOWED_CHARACTERS})
        else:
            return task_id_part

        # NOTE(stpierre): either the task UUID is shorter than the
        # task portion; or the portion of the task ID that we
        # would use contains only characters in
        # resource_name_allowed_characters.
        try:
            # NOTE(stpierre): seed pRNG with task ID so that all random
            # names with the same task ID have the same task ID part
            random.seed(task_id)
            return cls._generate_random_part(length)
        finally:
            random.seed()

def random_fill_cells(seed, fill_percent):
    global cells
    random.seed(seed)

    for x in range(G_WIDTH):
        for y in range(G_HEIGHT):
            cells[x][y] = 1 if random.random() < fill_percent else 0