def create_server(self, zone, startup_script_location, proxy_username_identifier, proxy_username, proxy_password_identifier, proxy_password): name_generator = haikunator.Haikunator() title = name_generator.haikunate() server = { "server": { "zone": zone, "title": title, "hostname": title, "plan": "1xCPU-1GB", # smallest plan "storage_devices": { "storage_device": [ { "action": "clone", "storage": "01000000-0000-4000-8000-000030060200", # ubuntu 16.04 lts "title": title + "-disk", "size": 25, "tier": "maxiops" } ] }, "user_data": self.get_startup_script(startup_script_location, proxy_username_identifier, proxy_username, proxy_password_identifier, proxy_password) } } response = json.loads(requests.post(self.base_url + '/server', json.dumps(server), auth=self.api_authentication, headers={"content-type": "application/json"}).text) return proxymodels.UpcloudServer(response['server']['uuid'], response['server']['ip_addresses']['ip_address'][1]['address'], proxy_username, proxy_password, 80)
def create_vm(self, zone, startup_script): name_gen = haikunator.Haikunator() image_response = self.compute_client.images().getFromFamily(project='ubuntu-os-cloud', family='ubuntu-1604-lts').execute() vm_name = name_gen.haikunate() server = { 'name': vm_name, 'machineType': f"zones/{zone}/machineTypes/n1-standard-1", 'disks': [ { 'boot': True, 'autoDelete': True, 'initializeParams': { 'sourceImage': image_response['selfLink'] } } ], 'networkInterfaces': [ { 'network': '/global/networks/default', 'accessConfigs': [ {'type': 'ONE_TO_ONE_NAT', 'name': 'external nat'} ] } ], 'metadata': { 'items': [ { 'key': 'startup-script', 'value': startup_script } ] } } creation_result = self.compute_client.instances().insert(project=self.project, zone=zone, body=server).execute() return vm_name
def __init__(self, args, random_state=42, subdir=''): ops.reset_default_graph() np.random.seed(random_state) tf.set_random_seed(random_state) self.batch_size = args['batch_size'] self.classes = args['classes'] self.opt = args['optimizer'] self.learning_rate = args['learning_rate'] self.run = haikunator.Haikunator().haikunate(token_length=0) self.name = '' self.data = args['data'] self.subdir = subdir for i, (key, val) in enumerate(args.items()): if type(val) is TupleType or type(val) is ListType: if isinstance(val[0], CNN_description) or isinstance( val[0], FF_description): tmp_val = val val = '' for v in tmp_val: val += v.printit() + '_' val = val[:-1] else: tmp_val = val val = '' for v in tmp_val: val += str(v) + '_' val = val[:-1] if type(val) is FunctionType: val = val.__name__ if val.__class__ == type: val = val.__name__ self.name += str(key)[:3] + '_' + str(val) + '_' self.name = self.name[:-1]
def __init__(self, graph=None, *args, **kwargs): # Constant seed for uniform results tf.set_random_seed(42) np.random.seed(42) ## ## Model Configuration if kwargs is not None: self.folder = kwargs['type'] self.S = kwargs['nb_speakers'] self.args = kwargs self.learning_rate = kwargs['learning_rate'] else: raise Exception( 'Keyword Arguments missing ! Please add the right arguments in input | check doc' ) if graph is None: # Run ID self.runID = haikunator.Haikunator().haikunate() print 'ID : {}'.format(self.runID) #Create a graph for this model self.graph = tf.Graph() with self.graph.as_default(): with tf.name_scope('inputs'): # Boolean placeholder signaling if the model is in learning/training mode self.training = tf.placeholder(tf.bool, name='is_training') # Batch of raw non-mixed audio # shape = [ batch size , number of speakers, samples ] = [ B, S, L] self.x_non_mix = tf.placeholder("float", [None, None, None], name='non_mix_input') # Batch of raw mixed audio - Input data # shape = [ batch size , samples ] = [ B , L ] self.x_mix = tf.placeholder("float", [None, None], name='mix_input') # Speakers indicies used in the mixtures # shape = [ batch size, #speakers] self.I = tf.placeholder(tf.int32, [None, None], name='indicies') shape_in = tf.shape(self.x_mix) self.B = shape_in[0] self.L = shape_in[1] # Create a session for this model based on the constructed graph config_ = tf.ConfigProto() config_.gpu_options.allow_growth = True config_.allow_soft_placement = True self.sess = tf.Session(graph=self.graph, config=config_)
def create_proxies(user_option, region): name_gen = haikunator.Haikunator() proxy_list = [] proxy_list_name = input("Proxy list name: ") proxy_count = int(input("How many proxies would you like to generate: ")) proxy_list_file = open( os.path.join(os.path.realpath(''), f'proxylists\\{proxy_list_name}.json'), 'a') if (user_option == 1): proxy_gen = awsproxygen.AWSProxyGen() cloud_provider = 'aws' elif (user_option == 2): proxy_gen = azureproxygen.AzureProxyGen() cloud_provider = 'azure' elif (user_option == 3): cloud_provider = '100tb' proxy_gen = proxygen100tb.ProxyGen100TB() elif (user_option == 4): cloud_provider = 'gcs' proxy_gen = googlecloudproxygen.GoogleCloudProxyGen() elif (user_option == 5): cloud_provider = 'upcloud' proxy_gen = upcloudproxygen.UpcloudProxyGen() elif (user_option == 6): cloud_provider = 'linode' proxy_gen = linodeproxygen.LinodeProxygen() elif (user_option == 7): cloud_provider = 'vultr' proxy_gen = vultrproxygen.VultrProxyGen() elif (user_option == 8): cloud_provider = 'digitalocean' proxy_gen = digitaloceanproxygen.DigitalOceanProxyGen() elif (user_option == 9): cloud_provider = 'vpsie' proxy_gen = vpsieproxygen.VpsieProxyGen() servers = proxy_gen.create_proxies(region, proxy_count, name_gen.haikunate(), name_gen.haikunate()) print("Here are your generated proxies: ") for x in servers: proxy_list.append(x.to_dict()) print(x.to_string()) proxy_list_dict = { 'cloud_provider': cloud_provider, 'region': region, 'hourly_cost': len(proxy_list) * get_proxy_price(cloud_provider, str(region)), 'proxies': proxy_list } json.dump(proxy_list_dict, proxy_list_file) proxy_list_file.close()
def new_room(request): name_generator = haikunator.Haikunator() new_room = None while not new_room: with transaction.atomic(): name = name_generator.haikunate() if Room.objects.filter(label=name).exists(): continue new_room = Room.objects.create(label=name) return redirect(chat_room, label=name)
def main(): name_generator = haikunator.Haikunator() proxy_gen = ProxyGen100TB() proxy_count = int(input('How many proxies do you want? ')) proxies, servers = proxy_gen.create_proxies(proxy_count, 2, name_generator.haikunate(), name_generator.haikunate()) for x in proxies: print(x) input('type anything when ready to delete vms') proxy_gen.delete_vms(servers)
def new_room(request): """ Randomly create a new room, and redirect to it. """ new_room = None while not new_room: with transaction.atomic(): label = haikunator.Haikunator().haikunate() if Room.objects.filter(label=label).exists(): continue new_room = Room.objects.create(label=label) return redirect(reverse('chatroom:chat_room', args=(label, )))
def create_vm(self, region, startup_script): name_gen = haikunator.Haikunator() server = { "name": name_gen.haikunate(), "region": region, "size": "1gb", "image": 49549315, "user_data": startup_script, } response = json.loads( requests.post(self.base_url + '/v2/droplets', json.dumps(server), headers=self.request_headers).text) return response['droplet']['id']
def create_vm(self, location_id, proxy_username, proxy_password): name_gen = haikunator.Haikunator() header = {"Authorization": f"Bearer {self.access_token}"} request = { 'hostname': name_gen.haikunate(), 'offer_id': '9a0e49c6-9f22-11e3-8af5-005056aa8af7', # 1 cpu, 768mb ram 'datacenter_id': location_id, 'os_id': 'fbbb3371-283b-11e8-b4ba-005056aadd24' # ubuntu 16.04 } response = json.loads( requests.post(self.base_url + '/vpsie', request, headers=header).text) return proxymodels.VpsieServer(response['vpsie_id'], 'root', response['password'], response['ipv4'], proxy_username, proxy_password, 80)
def create_server(self, location, proxy_username, proxy_password, stack_script_id): name_gen = haikunator.Haikunator() headers = { "Authorization": f"Bearer {self.access_token}", "content-type": "application/json" } server = { "region": location, "type": "g6-nanode-1", "backups_enabled": False, "booted": True, "image": "linode/ubuntu16.04lts", "root_pass": name_gen.haikunate(), "stackscript_id": stack_script_id } response = json.loads( requests.post(self.base_url + '/linode/instances', json.dumps(server), headers=headers).text) return proxymodels.LinodeServer(response['id'], response['ipv4'][0], proxy_username, proxy_password, 80)
def create_vm(self, location_id, proxy_username, proxy_password): name_generator = haikunator.Haikunator() vm_name = name_generator.haikunate() password = name_generator.haikunate() request_url = f'https://cp.100tb.com/rest-api/vps.json?api_key={self.api_key}' request_params = { 'planId': 2698, # v1-19 server 'locationId': location_id, # a number 2-20 corresponding to a location 'templateId': self.get_template_id(location_id), 'label': vm_name, 'hostname': vm_name, 'password': password, 'billHourly': 'true' } creation_result = json.loads( requests.post(request_url, request_params).text) return proxymodels.Server100TB(location_id, creation_result['server'], vm_name, creation_result['ip'], 'root', password, proxy_username, proxy_password, 80)
def __init__(self, graph=None, *args, **kwargs): # Constant seed for uniform results tf.set_random_seed(42) np.random.seed(42) ## ## Model Configuration if kwargs is not None: self.folder = kwargs['type'] self.S = kwargs['nb_speakers'] self.args = kwargs self.learning_rate = kwargs['learning_rate'] else: raise Exception('Keyword Arguments missing ! Please add the right arguments in input | check doc') if graph is None: # Run ID self.runID = haikunator.Haikunator().haikunate() print 'ID : {}'.format(self.runID) if not kwargs['pipeline']: #Create a graph for this model self.graph = tf.Graph() with self.graph.as_default(): with tf.name_scope('inputs'): # Boolean placeholder signaling if the model is in learning/training mode self.training = tf.placeholder(tf.bool, name='is_training') # Batch of raw non-mixed audio # shape = [ batch size , number of speakers, samples ] = [ B, S, L] self.x_non_mix = tf.placeholder("float", [None, None, None], name='non_mix_input') # Batch of raw mixed audio - Input data # shape = [ batch size , samples ] = [ B , L ] self.x_mix = tf.placeholder("float", [None, None], name='mix_input') # Speakers indicies used in the mixtures # shape = [ batch size, #speakers] self.I = tf.placeholder(tf.int32, [None, None], name='indicies') shape_in = tf.shape(self.x_mix) self.B = shape_in[0] self.L = shape_in[1] else: with tf.get_default_graph().as_default(): with tf.name_scope('inputs'): # Boolean placeholder signaling if the model is in learning/training mode self.training = tf.placeholder(tf.bool, name='is_training') # Batch of raw non-mixed audio # shape = [ batch size , number of speakers, samples ] = [ B, S, L] self.x_non_mix = tf.identity(kwargs['non_mix'], name='non_mix_input') # Batch of raw mixed audio - Input data # shape = [ batch size , samples ] = [ B , L ] self.x_mix = tf.identity(kwargs['mix'], name='mix_input') # Speakers indicies used in the mixtures # shape = [ batch size, #speakers] self.I = tf.identity(kwargs['ind'], name='indicies') shape_in = tf.shape(self.x_mix) self.B = shape_in[0] self.L = shape_in[1] tf.summary.audio(name= "audio/input/non-mixed", tensor = tf.reshape(self.x_non_mix, [-1, self.L]), sample_rate = config.fs, max_outputs=2) tf.summary.audio(name= "audio/input/mixed", tensor = self.x_mix[:self.B], sample_rate = config.fs, max_outputs=1)
from django.shortcuts import render, redirect from django.db import transaction import haikunator from .models import Room hai = haikunator.Haikunator() def about(request): """ Starting page. """ return render(request, 'chat/about.html') def new_room(request): new_room = None while not new_room: with transaction.atomic(): label = hai.haikunate() if Room.objects.filter(label=label).exists(): continue new_room = Room.objects.create(label=label) return redirect('chat:chat_room', label=label) def chat_room(request, label): room, created = Room.objects.get_or_create(label=label) messages = reversed(room.messages.order_by('-timestamp')[:50]) template = 'chat/room.html' context = { 'room': room,
import string import secrets import haikunator haikunator = haikunator.Haikunator() def append_random_haiku(name): haiku = haikunator.haikunate(token_length=0, delimiter='') return "{}_{}".format(name, haiku) def generate_random_token(size): # allow upper and lowercase alphanumerics characters = string.ascii_letters + string.digits token = ''.join(secrets.choice(characters) for i in range(size)) return token def iterate_pod_number(course): total_pods = course.get_total_number_pods() if total_pods == 0: return 1 else: # iterate from last pod number return course.pods.order_by('-number')[0].number + 1