Python random.getrandbits函数代码示例

def main(args):
  random.seed()
  if (len(args) < 3):
    print 'Please provide a server and a port'
    return
  cacheClient = CacheClient(args[1], int(args[2]))

  cnt = 0
  numFailedPuts = 0
  numFailedGets = 0

  key = "asdf"
  val = ""
  cacheClient.put(key,val)

  while True:
    key = str(random.getrandbits(9))
    if (bool(random.getrandbits(1))):
      value = str(random.getrandbits(10))
      try:
        cacheClient.put(key, value)
      except:
        numFailedPuts += 1
    else:
      try: 
        cacheClient.get(key)
      except:
        numFailedGets += 1

    def generateRandoms(self, filterCount, traffic, seed):
        """
        should generate random IP's, Port numbers
        """
        dectionary = {"sourcIP": [], "destIP": [],
                      "sourcePortNo": [], "destPortNo": []}
        sourceIP = ""
        destIP = ""
        random.seed(seed)

        for i in range(0, filterCount):

            if "IPV4" in traffic[i]:
                sourceIP = socket.inet_ntoa(struct
                                            .pack('>I',
                                                  random
                                                  .randint(1, 0xffffffff)))
                destIP = socket.inet_ntoa(struct
                                          .pack('>I',
                                                random
                                                .randint(1, 0xffffffff)))
            else:
                sourceIP = str(IPAddress('0::0:0') + random.getrandbits(16))
                destIP = str(IPAddress('0::0:0') + random.getrandbits(16))

            sourcePort = random.randint(0, 0xffff)
            destPort = random.randint(0, 0xffff)
            dectionary["sourcIP"].append(sourceIP)
            dectionary["destIP"].append(destIP)
            dectionary["sourcePortNo"].append(sourcePort)
            dectionary["destPortNo"].append(destPort)

        return dectionary

    def copyWithOffset(cls, entity, copyOffset, regenerateUUID=False):
        eTag = deepcopy(entity)

        # Need to check the content of the copy to regenerate the possible sub entities UUIDs.
        # A simple fix for the 1.9+ minecarts is proposed.

        positionTags = map(lambda p, co: nbt.TAG_Double(p.value + co), eTag["Pos"], copyOffset)
        eTag["Pos"] = nbt.TAG_List(positionTags)

        if eTag["id"].value in ("Painting", "ItemFrame"):
            eTag["TileX"].value += copyOffset[0]
            eTag["TileY"].value += copyOffset[1]
            eTag["TileZ"].value += copyOffset[2]

        if "Riding" in eTag:
            eTag["Riding"] = Entity.copyWithOffset(eTag["Riding"], copyOffset)

        # # Fix for 1.9+ minecarts
        if "Passengers" in eTag:
            passengers = nbt.TAG_List()
            for passenger in eTag["Passengers"]:
                passengers.append(Entity.copyWithOffset(passenger, copyOffset, regenerateUUID))
            eTag["Passengers"] = passengers
        # #

        if regenerateUUID:
            # Courtesy of SethBling
            eTag["UUIDMost"] = nbt.TAG_Long((random.getrandbits(47) << 16) | (1 << 12) | random.getrandbits(12))
            eTag["UUIDLeast"] = nbt.TAG_Long(-((7 << 60) | random.getrandbits(60)))
        return eTag

 def test_numeric(self):
     """Test data insertion and retrieval to numeric columns."""
     conn = self.database.connection()
     cursor = conn.cursor()
     dialect = self.database.dialect()
     dbapi = self.database.dbapi()
     query = dialect.translate('DROP TABLE test_numeric')
     try:
         cursor.execute(query)
     except dbapi.Error:
         conn.rollback()
     query = dialect.translate('CREATE TABLE test_numeric ' \
                               '( value NUMERIC(100,50) NOT NULL )')
     cursor.execute(query)
     data = []
     query = 'INSERT INTO test_numeric VALUES (%s)'
     for i in range(100):
         int = random.getrandbits(150)
         frac = random.getrandbits(150)
         item = decimal.Decimal('%d.%s' % (int, frac))
         data.append(item)
         cursor.execute(query, (item,))
     query = 'SELECT * FROM test_numeric'
     cursor.execute(query)
     result = cursor.fetchall()
     for row in result:
         item = row[0]
         assert isinstance(item, decimal.Decimal)
         assert item in data
         data.remove(item)
     query = dialect.translate('DELETE FROM test_numeric')
     cursor.execute(query)
     query = dialect.translate('DROP TABLE test_numeric')
     cursor.execute(query)
     conn.commit()

 def createRequest(self,m,username=None,auth=None,cid=None,cseq=1,fromaddr=None,toaddr=None,contact=None):
     from base64 import b64encode
     from libs.svhelper import makeRequest
     from libs.svhelper import createTag
     if cid is None:
         cid='%s' % str(random.getrandbits(32))
     branchunique = '%s' % random.getrandbits(32)
     localtag=createTag(username)
     if not contact:
         contact = 'sip:%[email protected]%s' % (username,self.domain)
     if not fromaddr: 
         fromaddr = '"%s"<sip:%[email protected]%s>' % (username,username,self.domain)
     if not toaddr: 
         toaddr = '"%s"<sip:%[email protected]%s>' % (username,username,self.domain)        
     request = makeRequest(
                             m,
                             fromaddr,
                             toaddr,
                             self.domain,
                             self.dstport,
                             cid,
                             self.externalip,
                             branchunique,
                             cseq,
                             auth,
                             localtag,
                             self.compact,
                             contact=contact,
                             localport=self.localport,
                             extension=username
                           )
     return request

 def save(self, *args, **kwargs):
     if self.uid is None or self.uid == "":
         key = hex(random.getrandbits(32)).rstrip("L").lstrip("0x")
         while Group.objects.filter(uid=key).count() > 0:
             key = hex(random.getrandbits(32)).rstrip("L").lstrip("0x")
         self.uid = key
     super(Group, self).save(*args, **kwargs)

def generate_random_prime(n):
    def isProbablePrime(n, t = 7):
        def isComposite(a):
            if pow(a, d, n) == 1:
                return False
            for i in range(s):
                if pow(a, 2 ** i * d, n) == n - 1:
                    return False
            return True

        assert n > 0
        if n < 3:
            return [False, False, True][n]
        elif not n & 1:
            return False
        else:
            s, d = 0, n - 1
            while not d & 1:
                s += 1
                d >>= 1
        for _ in itertools.repeat(None, t):
            if isComposite(random.randrange(2, n)):
                return False
        return True

    p = random.getrandbits(n)
    while not isProbablePrime(p):
        p = random.getrandbits(n)
    return p

    def test_leave_unbinding_failure(self, GivenException):
        fake_docker_network_id = hashlib.sha256(str(random.getrandbits(256))).hexdigest()
        fake_docker_endpoint_id = hashlib.sha256(str(random.getrandbits(256))).hexdigest()

        fake_neutron_network_id = str(uuid.uuid4())
        self._mock_out_network(fake_neutron_network_id, fake_docker_network_id)
        fake_neutron_port_id = str(uuid.uuid4())
        self.mox.StubOutWithMock(app.neutron, "list_ports")
        neutron_port_name = utils.get_neutron_port_name(fake_docker_endpoint_id)
        fake_neutron_v4_subnet_id = str(uuid.uuid4())
        fake_neutron_v6_subnet_id = str(uuid.uuid4())
        fake_neutron_ports_response = self._get_fake_ports(
            fake_docker_endpoint_id,
            fake_neutron_network_id,
            fake_neutron_port_id,
            fake_neutron_v4_subnet_id,
            fake_neutron_v6_subnet_id,
        )
        app.neutron.list_ports(name=neutron_port_name).AndReturn(fake_neutron_ports_response)
        fake_neutron_port = fake_neutron_ports_response["ports"][0]

        fake_message = "fake message"
        fake_exception = GivenException(fake_message)
        self._port_unbind_with_exception(fake_docker_endpoint_id, fake_neutron_port, fake_exception)

        response = self._invoke_leave_request(fake_docker_network_id, fake_docker_endpoint_id)

        self.assertEqual(w_exceptions.InternalServerError.code, response.status_code)
        decoded_json = jsonutils.loads(response.data)
        self.assertTrue("Err" in decoded_json)
        self.assertTrue(fake_message in decoded_json["Err"])

    def __init__(self,mmC,rloc):        
        self.accessLock = rloc
        
        self.tid = str(random.getrandbits(128))
        #System vars
        self.userID = "1"
        self.authenticated = False
        self.disconnect = False
        self.randomHash = str(random.getrandbits(64))

        #MM vars
        self.searchingClash = False
        self.searchingClashFound = False
                
        #Game vars
        self.questionsRequested = False
        
        #db connection
        self.dbM = ServiceDBMinor()
        
        #MM
        self.mmControl = mmC
        
        debugElo = 1000
        #Player ELo
        self.mmClient = MMGameClient(debugElo,self.tid)

    def test_delete_endpiont_port_failures(self, GivenException):
        fake_docker_network_id = hashlib.sha256(
            str(random.getrandbits(256))).hexdigest()
        fake_docker_endpoint_id = hashlib.sha256(
            str(random.getrandbits(256))).hexdigest()
        fake_neutron_network_id = str(uuid.uuid4())
        fake_neutron_subnet_v4_id = str(uuid.uuid4())
        fake_neutron_subnet_v6_id = str(uuid.uuid4())
        fake_neutron_port_id = str(uuid.uuid4())

        self._mock_out_network(fake_neutron_network_id, fake_docker_network_id)
        self.mox.StubOutWithMock(app.neutron, 'list_ports')
        fake_ports = self._get_fake_ports(
            fake_docker_endpoint_id, fake_neutron_network_id,
            fake_neutron_port_id,
            fake_neutron_subnet_v4_id, fake_neutron_subnet_v6_id)
        app.neutron.list_ports(
            network_id=fake_neutron_network_id).AndReturn(fake_ports)
        self._delete_port_with_exception(fake_neutron_port_id, GivenException)

        response = self._invoke_delete_request(
            fake_docker_network_id, fake_docker_endpoint_id)

        self.assertEqual(GivenException.status_code, response.status_code)
        decoded_json = jsonutils.loads(response.data)
        self.assertTrue('Err' in decoded_json)
        self.assertEqual({'Err': GivenException.message}, decoded_json)

def mate_random_cross(chrom1, chrom2):
	""" 
	Mating function with random gene exchange
	Parameters:
	-----------
	chrom1: array-like (list, tuple)
			First chromosome
	chrom2: array-like (list, tuple)
			Second chromosome
	Returns:
	-------
	offspring1: tuple
			First offspring
	offspring2: tuple
			Second offspring
	"""

	l = len(chrom1)

	offspring1 = [True] * l
	offspring2 = [True] * l

	for i in range(l):
		if random.getrandbits(1) == 0:
			offspring1[i] = chrom1[i]
		else:
			offspring1[i] = chrom2[i]

		if random.getrandbits(1) == 0:
			offspring2[i] = chrom1[i]
		else:
			offspring2[i] = chrom2[i]
	return tuple(offspring1), tuple(offspring2)

    def test_create_endpoint_subnet_failures(self, GivenException):
        fake_docker_network_id = hashlib.sha256(
            str(random.getrandbits(256))).hexdigest()
        fake_docker_endpoint_id = hashlib.sha256(
            str(random.getrandbits(256))).hexdigest()
        fake_neutron_network_id = str(uuid.uuid4())

        self.mox.StubOutWithMock(app.neutron, 'list_subnets')
        app.neutron.list_subnets(
            network_id=fake_neutron_network_id,
            cidr='192.168.1.0/24').AndReturn({'subnets': []})
        app.neutron.list_subnets(
            network_id=fake_neutron_network_id,
            cidr='fe80::/64').AndReturn({'subnets': []})

        self._create_subnet_with_exception(
            fake_neutron_network_id, fake_docker_endpoint_id, GivenException())
        self._mock_out_network(fake_neutron_network_id, fake_docker_network_id)

        response = self._invoke_create_request(
            fake_docker_network_id, fake_docker_endpoint_id)

        self.assertEqual(GivenException.status_code, response.status_code)
        decoded_json = jsonutils.loads(response.data)
        self.assertTrue('Err' in decoded_json)
        self.assertEqual({'Err': GivenException.message}, decoded_json)

def comment(userID, theArticleID):
    connect("sns", host = "")
    token = request.headers.get("Token")
    authStatus = authenticateUser(token)
    if(authStatus == 412):
        return Response("Must supply an authentication token", status=authStatus)
    elif(authStatus == 401):
        return Response("Authorization required", status = authStatus)
    elif(authStatus == 200):
        user = User.objects(emailAddress=unicode(userID)).first()
        article = Article.objects(articleID=unicode(theArticleID)).first()
        if(user != None and article != None):
            if(request.method == "POST"):
                print "Current comments:", article.comments
                print "Comment to add =", str(request.data)
                theCommentID = str(random.getrandbits(64))
                while(Comment.objects(commentID = theCommentID).first() != None):
                    theCommentID = str(random.getrandbits(64))
                comment = Comment(commentID=theCommentID, authorID=userID, articleID=theArticleID, comment=request.data)
                comment.save()
                article.comments.append(theCommentID)
                article.save()
                print "Comment saved"
                return Response("Saved Comment", status=authStatus, mimetype="application/json")
            elif(request.method == "GET"):
                result = []
                comments = Comment.objects(articleID=theArticleID)
                for comment in comments:
                    result.append({key:comment[key] for key in ("authorID", "comment")})
                result = {"comments":result}
                jsonString = json.dumps(result)
                return Response(jsonString, status=authStatus)
        else:
            return Response(status=500)

 def test_read_and_write(self):
     # word space
     self.assertEqual(self.client.read_holding_registers(0), [0], 'Default value is 0 when server start')
     self.assertEqual(self.client.read_input_registers(0), [0], 'Default value is 0 when server start')
     # single read/write
     self.assertEqual(self.client.write_single_register(0, 0xffff), True)
     self.assertEqual(self.client.read_input_registers(0), [0xffff])
     # multi-write at max size
     words_l = [randint(0, 0xffff)] * 0x7b
     self.assertEqual(self.client.write_multiple_registers(0, words_l), True)
     self.assertEqual(self.client.read_holding_registers(0, len(words_l)), words_l)
     self.assertEqual(self.client.read_input_registers(0, len(words_l)), words_l)
     # write over sized
     words_l = [randint(0, 0xffff)] * 0x7c
     self.assertEqual(self.client.write_multiple_registers(0, words_l), None)
     # bit space
     self.assertEqual(self.client.read_coils(0), [False], 'Default value is False when server start')
     self.assertEqual(self.client.read_discrete_inputs(0), [False], 'Default value is False when server start')
     # single read/write
     self.assertEqual(self.client.write_single_coil(0, True), True)
     self.assertEqual(self.client.read_coils(0), [True])
     self.assertEqual(self.client.read_discrete_inputs(0), [True])
     # multi-write at min size
     bits_l = [getrandbits(1)] * 0x1
     self.assertEqual(self.client.write_multiple_coils(0, bits_l), True)
     self.assertEqual(self.client.read_coils(0, len(bits_l)), bits_l)
     self.assertEqual(self.client.read_discrete_inputs(0, len(bits_l)), bits_l)
     # multi-write at max size
     bits_l = [getrandbits(1)] * 0x7b0
     self.assertEqual(self.client.write_multiple_coils(0, bits_l), True)
     self.assertEqual(self.client.read_coils(0, len(bits_l)), bits_l)
     self.assertEqual(self.client.read_discrete_inputs(0, len(bits_l)), bits_l)
     # multi-write over sized
     bits_l = [getrandbits(1)] * 0x7b1
     self.assertEqual(self.client.write_multiple_coils(0, bits_l), None)

def generate_primes():

    
    bits = int(bit_number.get())
    if bit_number == None:
        bit_number = 10
    feedback_label =  Label(gui,text = 'Generating {0}bit Keys . . . . . . . '.format(bits)).place(x = 10, y = 40)


    
    prime1 = random.getrandbits(bits)
    prime2 = random.getrandbits(bits)
    check_prime(prime1)
    while check_prime(prime1) == False:
        prime1 = random.getrandbits(bits)
        
    
    check_prime(prime2)
    while check_prime(prime2) == False:
        prime2 = random.getrandbits(bits)
        
    fie_function = 0
    N = 0
    decryption_key = 0
    encryption_key = 0
    fie_function,N,decryption_key,encryption_key = generating_keys(prime1,prime2)
    print(prime1,prime2)
    feedback_label =  Label(gui,text = 'Keys Generated').place(x = 10, y = 40)
    return[fie_function,N,decryption_key,encryption_key]