def __init__(self, *args, **kwargs): fk_fs_type = kwargs.get('fk_fs_type', None) if fk_fs_type != None: self.fk_fs_type = uuid.uuid() fs_uuid = kwargs.get('fs_uuid', None) if fs_uuid != None: self.fs_uuid = uuid.uuid()
def test_simple_add(self): # Add one slot together with a timespan allocation = Allocation(raster=15, resource=uuid()) allocation.start = datetime(2011, 1, 1, 15) allocation.end = datetime(2011, 1, 1, 15, 59) allocation.group = uuid() reservation = uuid() slot = ReservedSlot(resource=allocation.resource) slot.start = allocation.start slot.end = allocation.end slot.allocation = allocation slot.reservation = reservation allocation.reserved_slots.append(slot) # Ensure that the same slot cannot be doubly used anotherslot = ReservedSlot(resource=allocation.resource) anotherslot.start = allocation.start anotherslot.end = allocation.end anotherslot.allocation = allocation anotherslot.reservation = reservation Session.add(anotherslot) self.assertRaises(IntegrityError, Session.flush)
def get_visitor_id(): prev_visitors= set(os.listdir(results_dir)) new_id= uuid().hex while new_id in prev_visitors: new_id=uuid().hex return new_id
def __init__(self, *args, **kwargs): fk_block = kwargs.get('fk_block', None) if fk_block != None: self.fk_block = uuid.uuid() name_FileSystemType = kwargs.get('name_FileSystemType', None) if name_FileSystemType != None: self.name_FileSystemType = uuid.uuid()
def add_something(resource=None): resource = resource or uuid() allocation = Allocation(raster=15, resource=resource, mirror_of=resource) allocation.start = datetime(2011, 1, 1, 15) allocation.end = datetime(2011, 1, 1, 15, 59) allocation.group = uuid() Session.add(allocation)
def _create_allocation(self): allocation = Allocation(raster=15, resource=uuid()) allocation.start = datetime(2011, 1, 1, 15, 00) allocation.end = datetime(2011, 1, 1, 16, 00) allocation.group = str(uuid()) allocation.mirror_of = allocation.resource Session.add(allocation) return allocation
def getLock(name = None): if not name: name = str(uuid()) while name in locks: name = str(uuid()) if not name in locks: locks[name] = SingleLock() if name[0] == '#' else ReentLock() return locks[name]
def test_export(self): commitish = uuid().hex dest = '/home/' + uuid().hex self.git.export(commitish, dest) self.subprocess.assertExistsCommand( lambda c: c.startswith('git archive') and commitish in c) self.subprocess.assertExistsCommand( lambda c: dest in c)
def test_local_config(self): k = uuid().hex v = uuid().hex self.git.set_local_config(k, v) self.subprocess.assertLastCommandStartsWith('git config') self.subprocess.assertLastCommandContains(k) pred = lambda c: c.startswith('git config') and k in c self.subprocess.provideResult(pred, v) self.assertEqual(v, self.git.get_local_config(k))
def write(self): message_header = ET.Element('MessageHeader') self.__add_element_with_text(message_header, "MessageThreadId", str(uuid())) self.__add_element_with_text(message_header, "MessageId", str(uuid())) message_header.append(self.sender.write()) message_header.append(self.recipient.write()) created_date = ET.SubElement(message_header, "MessageCreatedDateTime") created_date.text = d.datetime.now().replace(microsecond=0).isoformat()+ "Z" return message_header
def setUp(self): super(TestUserTransaction, self).setUp() self.currency = CurrencyModel.query.filter_by(code='USD').first() self.fee = FeeModel.query.get(1) n = uuid().hex self.user_a = self.create_user(n, '%s %s' % (n[:16], n[16:])) self.user_a_balance = self.create_balance(user=self.user_a, currency_code='USD') self.campaign_a = self.create_campaign(uuid().hex, uuid().hex) self.campaign_a_balance = self.create_balance(campaign=self.campaign_a, currency_code='USD')
def setUp(self): super(TestExternalLedgerEntryWithFullName, self).setUp() self.currency = CurrencyModel.query.filter_by(code='USD').first() self.fee = FeeModel.query.get(1) n = uuid().hex self.user = self.create_user(n, '%s %s' % (n[:16], n[16:])) self.user_balance = self.create_balance(user=self.user, currency_code='USD') self.campaign = self.create_campaign(uuid().hex, uuid().hex) self.campaign_balance = self.create_balance(campaign=self.campaign, currency_code='USD')
def make_commit(self): """ Makes a random commit in the current branch. """ fragment = uuid().hex[:8] filename = join(self.repodir, fragment) with open(filename, 'w') as fh: fh.write(uuid().hex) self.repo.index.add([basename(filename)]) self.repo.index.commit('Adding {0}'.format(basename(filename)))
def __init__(self, server, port=6667, nick="", realname=""): self.server = server self.port = 6667 self.nickname = nick self.realname = nick self.conn = None self.version = "IRC python generic custom bot 2014" self.events= { "ctcp":{ uuid(): lambda is_request, origin, command, message: None if command.upper()!="PING" else self.ctcp_reply(origin,command,(message,)), uuid(): lambda is_request, origin, command, message: None if command.upper()!="VERSION" else self.ctcp_reply(origin,command,(self.version,)) } }
def setUp(self): self.SMTP_patcher = patch("pooldlib.api.communication.mail.smtplib") self.SMTP_patcher.start() self.email = email.Email(None, None) self.addCleanup(self.SMTP_patcher.stop) self.username_a = uuid().hex self.name_a = "%s %s" % (self.username_a[:16], self.username_a[16:]) self.email_a = "*****@*****.**" % self.username_a self.user_a = self.create_user(self.username_a, self.name_a, self.email_a) self.username_b = uuid().hex self.name_b = "%s %s" % (self.username_b[:16], self.username_b[16:]) self.email_b = "*****@*****.**" % self.username_b self.user_b = self.create_user(self.username_b, self.name_b, self.email_b)
def getCounter(name = None, start = 0, unique = False): if name: base = name idx = 1 while unique and name in counters: idx += 1 name = "%s-%d" % (base, idx) else: name = str(uuid()) while name in counters: name = str(uuid()) if not name in counters: counters[name] = Counter(start) return counters[name]
def add_handler(self, event_name, handler): id= uuid() if event_name in self.events.keys(): self.events[event_name][id] = handler else: self.events[event_name] = {id: handler} return id
def open(self): print "New connection opened." self._id = str(uuid()) self.write_message(self._id) WSTask.connections[self._id] = self print WSTask.connections
def get_path (session_key, filename = None): if not filename: filename = str (uuid ()) path_to = os.path.join (settings.MEDIA_DATA, session_key) if not os.path.exists (path_to): os.mkdir (path_to) return os.path.join (path_to, filename)
def _parse_geoms (self, root_xml): for geom_xml in root_xml.iterfind ('library_geometries/geometry'): mesh_xml = geom_xml.find ('mesh') poly_xml = mesh_xml.find ('polylist') assert all (int(v) == 3 for v in poly_xml.find ('vcount').text.split ()),\ 'Mesh {} is not triangulated'.format (geom_xml.attrib['name']) inputs = {} for input_xml in poly_xml.iterfind ('input'): input = self.Input (input_xml.attrib['source'].lstrip ('#'), int (input_xml.attrib['offset'])) inputs[input_xml.attrib['semantic']] = input input_xml = mesh_xml.find ("vertices[@id='{}']/input[@semantic='POSITION']".format (inputs['VERTEX'].source)) input = self.Input (input_xml.attrib['source'].lstrip ('#'), inputs['VERTEX'].offset) inputs['POSITION'] = input del inputs['VERTEX'] vertices = self._parse_source (mesh_xml, inputs['POSITION'].source) normals = self._parse_source (mesh_xml, inputs['NORMAL'].source) faces = [] stride = len (inputs) faces_idx = map (int, poly_xml.find ('p').text.split ()) for i in xrange (0, len (faces_idx), stride * 3): face_vertices = [] face_normals = [] for j in xrange (i, i + stride * 3, stride): face_vertices.append (faces_idx[j + inputs['POSITION'].offset]) face_normals.append (faces_idx[j + inputs['NORMAL'].offset]) faces.append (self.Face (face_vertices, face_normals)) geom = self.Geometry (str (uuid ()), faces, vertices, normals) self.geoms[geom_xml.attrib['id']] = geom
def setupClass(cls): """SFTP (RSE/PROTOCOLS): Creating necessary directories and files """ # Creating local files cls.tmpdir = tempfile.mkdtemp() cls.user = uuid() with open("%s/data.raw" % cls.tmpdir, "wb") as out: out.seek((1024 * 1024) - 1) # 1 MB out.write('\0') for f in MgrTestCases.files_local: os.symlink('%s/data.raw' % cls.tmpdir, '%s/%s' % (cls.tmpdir, f)) # Load local credentials from file with open('etc/rse-accounts.cfg') as f: data = json.load(f) credentials = data['LXPLUS'] lxplus = pysftp.Connection(**credentials) with open('etc/rse_repository.json') as f: prefix = json.load(f)['LXPLUS']['protocols']['supported']['sftp']['prefix'] lxplus.execute('mkdir %s' % prefix) lxplus.execute('dd if=/dev/urandom of=%s/data.raw bs=1024 count=1024' % prefix) cls.static_file = 'sftp://lxplus.cern.ch:22%sdata.raw' % prefix protocol = mgr.create_protocol(mgr.get_rse_info('LXPLUS'), 'write') for f in MgrTestCases.files_remote: tmp = protocol.parse_pfns(protocol.lfns2pfns({'name': f, 'scope': 'user.%s' % cls.user}).values()[0]).values()[0] for cmd in ['mkdir -p %s' % ''.join([tmp['prefix'], tmp['path']]), 'ln -s %sdata.raw %s' % (prefix, ''.join([tmp['prefix'], tmp['path'], tmp['name']]))]: lxplus.execute(cmd) lxplus.close()
def canvas1(name=None, x=750, y=535): """ creates a new TCanvas 750px wide, usual aspect ratio """ title = name or str(uuid()) c = ROOT.TCanvas(title, title, x, y) return c
def start(self, process=False, link=None): """ Start a new thread or process that invokes this manager's ``run()`` method. The invocation of this method returns immediately after the task or process has been started. """ if process: # Parent<->Child Bridge if link is not None: from circuits.net.sockets import Pipe from circuits.core.bridge import Bridge channels = (uuid(),) * 2 parent, child = Pipe(*channels) bridge = Bridge(parent, channel=channels[0]).register(link) args = (child,) else: args = () bridge = None self.__process = Process(target=self.run, args=args, name=self.name) self.__process.daemon = True self.__process.start() return self.__process, bridge else: self.__thread = Thread(target=self.run, name=self.name) self.__thread.daemon = True self.__thread.start() return self.__thread, None
def tempname(self): name = os.path.join(tempfile.gettempdir(), uuid().hex) yield name try: self.unlink(name) except OSError: pass
def generate(): width = 720 height = 300 white = (255, 255, 255) rexp = ["sin(pi*i/x)","cos(pi*i/x)"][randint(0,1)] gexp = ["cos((pi*i*j)/x)","sin((pi*i*j)/x)"][randint(0,1)] bexp = ["sin(pi*j/x)","cos(pi*j/x)"][randint(0,1)] tileSize = randint(2,5) x = float([3,5,7,11,13,17,19,21][randint(0,7)]) image = Image.new("RGB", (width, height), white) draw = ImageDraw.Draw(image) for i in xrange(0,720,tileSize): for j in xrange(0,480,tileSize): r = int(eval(rexp)*1000%255) g = int(eval(gexp)*1000%255) b = int(eval(bexp)*1000%255) tileColor = "#"+hex(r)[2:].zfill(2)+hex(g)[2:].zfill(2)+hex(b)[2:].zfill(2) draw.rectangle([(i,j),(i+tileSize,j+tileSize)], tileColor, None) path = "static/img/" fileName = str(uuid().int)+".jpg" image.save(path+fileName, 'JPEG') return path+fileName
def put(self): """ Upload an ECG datafile to the server. The file should be labled as "data" when uploaded Example URL **PUT http://hrsdb/ecgdata** Example response:: { "response": { "id": 1 } } """ args = self.put_parser.parse_args(strict=True) ecgfile = args.data # Save the file on disk using a uuid filename = "%s%s.dat" % (self.file_prefix, uuid()) ecgfile.save(os.path.join(current_app.config['UPLOAD_FOLDER'], filename)) # Create a new database record for this file with open_session() as session: ecgdata = ECGData(filename) session.add(ecgdata) session.flush() session.commit() print(ecgdata.id) return gen_response({"id": ecgdata.id})
def new_id(): """Generate a new graph element id. :return: new graph element id. :rtype: str """ return str(uuid())
def __init__(self, *args, **kwargs): super(YahooContactImporter, self).__init__(*args, **kwargs) self.request_token_url = REQUEST_TOKEN_URL self.request_auth_url = REQUEST_AUTH_URL self.token_url = TOKEN_URL self.oauth_timestamp = int(time()) self.oauth_nonce = md5("%s%s" % (uuid(), self.oauth_timestamp)).hexdigest()
def pre_save_parameter(sender, **kwargs): # the object can be accessed via kwargs 'instance' key. parameter = kwargs['instance'] if parameter.name.units.startswith('image') \ and parameter.name.data_type == ParameterName.FILENAME: if parameter.string_value: from base64 import b64decode from os import mkdir from os.path import exists, join from uuid import uuid4 as uuid exp_id = parameter.getExpId() dirname = join(settings.FILE_STORE_PATH, str(exp_id)) filename = str(uuid()) filepath = join(dirname, filename) b64 = parameter.string_value modulo = len(b64) % 4 if modulo: b64 += (4 - modulo) * '=' if not exists(dirname): mkdir(dirname) f = open(filepath, 'w') try: f.write(b64decode(b64)) except TypeError: f.write(b64) f.close() parameter.string_value = filename
def login_post(): username = req.POST.get("username") password = req.POST.get("password") meta = get_twbot_meta(c) valid = True if username == meta["username"]: if not password_matches(password.encode(), meta["password"]): valid = False else: valid = False if valid: # generate a UUID (Universally Unique IDentifier). Each one is unique # except in exceptional circumstances, and so it will be infeasible for # someone to forge one that authenticates them into the system session = str(uuid()) resp.set_cookie("session", session, httponly=True) c.execute("UPDATE meta SET session = ?;", (session,)) conn.commit() b.redirect("/questions") else: b.redirect("/login?" + urlencode({"message": "Incorrect login"}))
def _serialize_criteria(criteria_root, criteria_list): """ Serialize rubric criteria as XML, adding children to the XML with root node `criteria_root`. We don't make any assumptions about the contents of `criteria_list`, and we handle unexpected inputs gracefully. Args: critera_root (lxml.etree.Element): The root node of the tree. criteria_list (list): List of criteria dictionaries. Returns: None """ # Sort the criteria by order number, then serialize as XML for criterion in _sort_by_order_num(criteria_list): criterion_el = etree.SubElement(criteria_root, 'criterion') # Criterion name (default to a UUID) criterion_name = etree.SubElement(criterion_el, u'name') if 'name' in criterion: criterion_name.text = six.text_type(criterion['name']) else: criterion_name.text = six.text_type(uuid().hex) # Criterion label (default to the name, then an empty string) criterion_label = etree.SubElement(criterion_el, 'label') criterion_label.text = six.text_type(criterion.get('label', criterion.get('name', u''))) # Criterion prompt (default to empty string) criterion_prompt = etree.SubElement(criterion_el, 'prompt') criterion_prompt.text = six.text_type(criterion.get('prompt', u'')) # Criterion feedback disabled, optional, or required # If disabled, do not set the attribute. if criterion.get('feedback') in ["optional", "required"]: criterion_el.set('feedback', criterion['feedback']) # Criterion options options_list = criterion.get('options', None) if isinstance(options_list, list): _serialize_options(criterion_el, options_list)
def connectProxy(self): """ initialize thrift rpc client, check for ssl, check auth, setup dispatcher, connect error signals, check server version """ if self.internal: return True err = None try: client = ThriftClient(self.host, self.port, self.user, self.password) except WrongLogin: err = _("bad login credentials") except NoSSL: err = _("no ssl support") except NoConnection: err = _("can't connect to host") if err: if not Connector.firstAttempt: self.emit(SIGNAL("errorBox"), err) Connector.firstAttempt = False return False self.proxy = DispatchRPC(self.mutex, client) self.connect(self.proxy, SIGNAL("connectionLost"), self, SIGNAL("connectionLost")) server_version = self.proxy.getServerVersion() self.connectionID = uuid().hex if not server_version == SERVER_VERSION: self.emit( SIGNAL("errorBox"), _("server is version %(new)s client accepts version %(current)s" ) % { "new": server_version, "current": SERVER_VERSION }) return False return True
def setUpClass(cls): """XROOTD (RSE/PROTOCOLS): Creating necessary directories and files """ # Getting info for the test environment rse_id, prefix, hostname, port = cls.get_rse_info() try: os.mkdir(prefix) except Exception as e: print(e) # Creating local files cls.tmpdir = tempfile.mkdtemp() cls.user = uuid() with open("%s/data.raw" % cls.tmpdir, "wb") as out: out.seek((1024 * 1024) - 1) # 1 MB out.write(b'\0') for f in MgrTestCases.files_local: shutil.copy('%s/data.raw' % cls.tmpdir, '%s/%s' % (cls.tmpdir, f)) protocol = rsemanager.create_protocol(rsemanager.get_rse_info(rse_id), 'write') protocol.connect() os.system('dd if=/dev/urandom of=%s/data.raw bs=1024 count=1024' % prefix) cls.static_file = 'xroot://%s:%d/%s/data.raw' % (hostname, port, prefix) cmd = 'xrdcp %s/data.raw %s' % (prefix, cls.static_file) execute(cmd) for f in MgrTestCases.files_remote: path = protocol.path2pfn( prefix + protocol._get_path('user.%s' % cls.user, f)) cmd = 'xrdcp %s/data.raw %s' % (prefix, path) execute(cmd) for f in MgrTestCases.files_local_and_remote: shutil.copy('%s/data.raw' % cls.tmpdir, '%s/%s' % (cls.tmpdir, f)) path = protocol.path2pfn( prefix + protocol._get_path('user.%s' % cls.user, f)) cmd = 'xrdcp %s/%s %s' % (cls.tmpdir, f, path) execute(cmd)
def __launch_worker(self, task_data, index): url = task_data['url'] token = str(uuid.uuid4()) try: # prepare log path o = urlparse.urlparse(url) host = o.netloc dir_path_name = os.path.join(self.__log_dir, token) while os.path.exists(dir_path_name): token = str(uuid.uuid()) dir_path_name = os.path.join(self.__log_dir, token) os.makedirs(dir_path_name) # prepar args args = ['phantomjs'] args[1:1] = [ self.__worker_script_path, url, str(self.__user_agent) ] # start worker process worker = subprocess.Popen( args, stdout=open(os.path.join(dir_path_name, 'stdout.txt'), 'w'), stderr=open(os.path.join(dir_path_name, 'stderr.txt'), 'w')) worker_info = { 'timestamp': int(time.time()), 'index': index, 'process': worker, 'url': url, 'path': dir_path_name } #(,task.url, index, worker, dir_path_name) #time.sleep(1) # update worker info self.__total_worker_instances += 1 self.__workers.append(worker_info) logger.info("[MAIN] successfully run " + url + ' : ' + str(worker_info['index']) + " withpid:" + str(worker.pid) + ", dir_path:" + dir_path_name) except Exception as e: logger.error("failed to launch worker " + str(e))
def __create_new_file(self, db_session, repository_id, language): """Create new file record in database if not exists Args: db_session: ^^ repository_id: language: Returns: created file """ file_orm = File( id=uuid().hex, repository_id=repository_id, language=language ) db_session.add(file_orm) return file_orm
async def job_lifecycle_wait(session): job_id = str(uuid()) json_dict = create_payload(job_id) async with session.post(f'{_SHEPHERD_URL}/start-job', json=json_dict) as resp: assert resp.status == 200 async with session.get(f'{_SHEPHERD_URL}/jobs/{job_id}/status') as resp: assert resp.status == 200 async with session.get( f'{_SHEPHERD_URL}/jobs/{job_id}/wait_ready') as resp: assert resp.status == 200 async with session.get(f'{_SHEPHERD_URL}/jobs/{job_id}/result') as resp: response = await resp.text() response = json.loads(response) assert response['result'] == '42'
def test_wrong_credentials(self): container = str(uuid()) conn_string = \ 'DefaultEndpointsProtocol=https;AccountName={};AccountKey={}'.\ format("testaccount", "wrongsecret") store = AzureBlockBlobStore(conn_string=conn_string, container=container, create_if_missing=False) if hasattr(store, 'block_blob_service'): from azure.storage.common.retry import ExponentialRetry store.block_blob_service.retry = ExponentialRetry( max_attempts=0).retry else: store.blob_container_client._config.retry_policy.total_retries = 0 with pytest.raises(IOError) as exc: store.put(u"key", b"data") assert u"Incorrect padding" in str(exc.value)
def test_not_kicked_during_game(db_session): game = WurwolvesGame(GAME_ID) # Add four players player_ids = [uuid() for _ in range(4)] roles = [ PlayerRole.MEDIC, PlayerRole.VILLAGER, PlayerRole.SPECTATOR, PlayerRole.WOLF, ] for p in player_ids: game.join(p) db_session = game._session game.start_game() for p, r in zip(player_ids, roles): game.set_player_role(game.get_player_id(p), r) timeout_player_id = player_ids[0] villager_id = player_ids[1] spectator_id = player_ids[2] wolf_id = player_ids[3] # Kill the medic with the wolf game.wolf_night_action(wolf_id, timeout_player_id) # Have the idler do something too game.medic_night_action(timeout_player_id, wolf_id) # Set medic to have joined ages ago timeout_player = game.get_player(timeout_player_id) db_session.add(timeout_player) timeout_player.last_seen = datetime(1, 1, 1) db_session.commit() db_session.expire_all() # Keepalive one of the other players, which should not kick the idler since it's a game game.player_keepalive(wolf_id) db_session.expire_all() assert game.get_player(timeout_player_id)
def get_path(self, state: GameState) -> Path: """ Get the path of a state. The path is determined by the filepath attribute of the sate. If the filepath attribute is None, an unique UUID is generated and stored as the filepath. :param state: the state to get the path :return: the path where the state is saved """ path = state.filepath if path is None: logger.warning( "filepath for state '%s' was not set, creating uuid", state) path = self.save_dir / (str(uuid()) + ".json") state.filepath = path logger.warning("uuid filepath for state '%s': '%s'", state, path) return path
def __create_new_order_single(cls) -> Fix.Messages.NewOrderSingle: """ Create a new order single :return: New order single """ new_order_single = Fix.Messages.NewOrderSingle() instmt = cls.__create_instrument() side = Fix.Tags.Side.Values.BUY new_order_single.Instrument.Symbol.value = instmt.instmt_name new_order_single.Instrument.SecurityExchange.value = instmt.exchange new_order_single.Price.value = TRiskManager.price new_order_single.TriggeringInstruction.TriggerPrice.value = TRiskManager.price new_order_single.Side.value = side new_order_single.ClOrdID.value = uuid() new_order_single.OrderQtyData.OrderQty.value = TRiskManager.qty new_order_single.OrdType.value = Fix.Tags.OrdType.Values.LIMIT new_order_single.TimeInForce.value = Fix.Tags.TimeInForce.Values.DAY return new_order_single
def canvas3(name=None): """ TCanvas with 4 pads -- top 2 for histograms, bottom 2 for errors """ title = name or str(uuid()) c = ROOT.TCanvas(title, title, 750, 400) pads = [ # name, title, x1, y1, x2, y2, color, bordersize, bordermode ROOT.TPad(c.GetName() + '_pad1', '', 0.0, 0.3, 0.5, 1.0, 10, 5, 0), ROOT.TPad(c.GetName() + '_pad2', '', 0.5, 0.3, 1.0, 1.0, 10, 5, 0), ROOT.TPad(c.GetName() + '_pad3', '', 0.0, 0.0, 0.5, 0.3, 10, 5, 0), ROOT.TPad(c.GetName() + '_pad4', '', 0.5, 0.0, 1.0, 0.3, 10, 5, 0) ] for i, p in enumerate(pads): p.SetNumber(i + 1) p.SetCanvas(c) p.Draw() ROOT.SetOwnership(p, False) return c
def error_response(code, error, message): """ Returns a error response. @param code: Status code. @param error: Error type. @param message: Error message. @return: Response. """ response = make_response( render_template( 'generic_error.xml', response_type='Response', error=error, message=message, request_id=uuid() ) ) return _create_response(response, int(code))
def _render_node(self, node): if isinstance(node, (str, numbers.Number)) or node is None: node_id = uuid() else: node_id = id(node) node_id = str(node_id) if node_id not in self._rendered_nodes: self._rendered_nodes.add(node_id) if isinstance(node, dict): self._render_dict(node, node_id) elif isinstance(node, list): self._render_list(node, node_id) else: self._graph.node(node_id, label=self._escape_dot_label( self._shorten_string(repr(node)))) return node_id
def __init__(self, user_agent, token=None, token_updater=None, hardware_id=None): """ :type token: Optional[Dict[str, str]] :type token_updater: Optional[Callable[[str], None]] """ self.user_agent = user_agent self.hardware_id = hardware_id if self.hardware_id is None: self.hardware_id = str(uuid()) self.token_updater = token_updater self._oauth = OAuth2Session( client=LegacyApplicationClient(client_id=OAuth.CLIENT_ID), token=token)
def process_background_image(imgfile, dirname=None): """ Scales image. This images are then used as background for location and profile pages. Function takes image file (usually from request.FILES['file']) as argument and changes it's size and name. If `dirname` is provided as path relative to MEDIA_ROOT settings, image will be saved on this path. If not ,`img` folder will be used instead. """ img = Image.open(imgfile) pathname = dirname or 'img' dirname = os.path.join(settings.MEDIA_ROOT, pathname) imgname = str(uuid()) + str(len(os.listdir(dirname))) + '.jpg' if img.size[0] > settings.BACKGROUND_IMAGE_SIZE: img.thumbnail( (settings.BACKGROUND_IMAGE_SIZE, settings.BACKGROUND_IMAGE_SIZE)) img.save(os.path.join(dirname, imgname), 'JPEG') return File(open(os.path.join(dirname, imgname)))
def schedule(self, task, metadata=None): """Schedule a task for later execution. The task is saved to the `{directory}/todo` directory. Use `run` to execute all the tasks in the `{directory}/todo} directory. If you want, you can attach metadata to the task, which you can retrieve as `task.metadata` after the task has been run. """ if metadata is not None: task.metadata = metadata taskfilename = (str(uuid()) + '.pkl') with (self._directory / 'todo' / taskfilename).open('wb') as f: dill.dump(task, f) self._log('schedule', taskfilename)
def insert_category(category_name, user_id, category_type, **kwargs): """Insert Category.""" sess = kwargs.get('sess') category_id = str(uuid()) new_category = Category(category_id=category_id, user_id=user_id, category_name=category_name, category_type=category_type, category_order=0, create_time=int(time.time())) sess.add(new_category) sess.commit() return dict(result=1, status=0, msg='Successfully.', data=dict(category_id=category_id))
def test_send_cross_group_not_allowed(self): new_room_id = str(uuid()) self.create_and_join_room() self.create_channel_and_room(room_id=new_room_id, room_name='asdf') self.remove_owner() self.remove_owner_channel() self.set_acl({ApiActions.CROSSROOM: { 'disallow': '' }}, room_id=new_room_id) activity = self.activity_for_message() activity['target']['objectType'] = 'room' activity['target']['id'] = new_room_id activity['actor']['url'] = BaseTest.ROOM_ID response_data = request.on_message(as_parser(activity)) self.assertEqual(False, response_data[0])
def __init__(self, name, port=5555, *args, **kwargs): """Initialize broker state.""" super(MDPBroker, self).__init__(name, *args, **kwargs) self.blockdiag_config["shape"] = "cloud" self.port = port self.broker_identity = uuid().get_hex() self.services = {} self.workers = {} self.context = zmq.Context() self.broker_socket = self.context.socket(zmq.ROUTER) self.broker_socket.linger = 0 self.broker_socket.identity = self.broker_identity self.poller = zmq.Poller() self.poller.register(self.broker_socket, zmq.POLLIN) self.logger.info( "MDPBroker {0} initialized. Client/Worker ID will be {1}".format( self.broker_identity, self.broker_identity)) self.bind(self.port, *args, **kwargs)
def share_data(self, data, shared_id=None, share_extended=False, cache=False): """Set input data as a shared data with input shared id. :param data: one data :param str shared_id: unique shared id. If None, the id is generated. :param bool share_extended: if True (False by default), set shared value to all shared data with input data :param bool cache: use query cache if True (False by default). :return: shared_id value (generated if None) """ result = str(uuid()) if shared_id is None else shared_id # get an iterable version of input data if isinstance(data, dict): data_to_share = [data] else: data_to_share = data for dts in data_to_share: # update extended data if necessary if share_extended: path, name = self.get_path_with_name(dts) extended_data = self.get(path=path, names=name, shared=True) # decompose extended data into a list dts = [] for ed in extended_data: dts.append(ed) else: dts = [dts] for dt in dts: path, name = self.get_path_with_name(dt) dt[CompositeStorage.SHARED] = result self.put(path=path, name=name, data=dt, cache=cache) return result
def __init__( self, obj: AssemblyObjects = None, loc: Optional[Location] = None, name: Optional[str] = None, color: Optional[Color] = None, metadata: Optional[Dict[str, Any]] = None, ): """ construct an assembly :param obj: root object of the assembly (default: None) :param loc: location of the root object (default: None, interpreted as identity transformation) :param name: unique name of the root object (default: None, resulting in an UUID being generated) :param color: color of the added object (default: None) :param metadata: a store for user-defined metadata (default: None) :return: An Assembly object. To create an empty assembly use:: assy = Assembly(None) To create one constraint a root object:: b = Workplane().box(1,1,1) assy = Assembly(b, Location(Vector(0,0,1)), name="root") """ self.obj = obj self.loc = loc if loc else Location() self.name = name if name else str(uuid()) self.color = color if color else None self.metadata = metadata if metadata else {} self.parent = None self.children = [] self.constraints = [] self.objects = {self.name: self} self._solve_result = None
def __enter__(self): super(ProcessingContext, self).__enter__() # Get the DRS facet keys from pattern self.facets = self.cfg.get_facets('directory_format') # Check if --commands-file argument specifies existing file self.check_existing_commands_file() # Raise error when %(version)s is not part of the final directory format if 'version' not in self.facets: raise NoVersionPattern(self.cfg.get('directory_format'), self.facets) # Consider hard-coded elements in directory format idx = 0 for pattern_element in self.cfg.get('directory_format').strip().split( "/"): try: # If pattern is %(...)s, get its index in the list of facets key = re.match(re.compile(r'%\(([\w]+)\)s'), pattern_element).groups()[0] idx = self.facets.index(key) except AttributeError: # If pattern is not %(...)s, generate a uuid() key = str(uuid()) # Insert hard-coded string in self.facets to be part of DRS path self.facets.insert(idx + 1, key) # Set the value using --set-value self.set_values[key] = pattern_element # Add the uuid to the ignored keys IGNORED_KEYS.append(key) self.pattern = self.cfg.translate('filename_format') # Init DRS tree self.tree = DRSTree(self.root, self.version, self.mode, self.commands_file) # Init data collector self.sources = Collector(sources=self.directory) # Init file filter # Only supports netCDF files self.sources.FileFilter.add(regex='^.*\.nc$') # And exclude hidden files self.sources.FileFilter.add(regex='^\..*$', inclusive=False) # Get number of sources self.nbsources = len(self.sources) return self
def post(self, *_args, **_kwargs): params = yield self.check_auth() file_meta = self.request.files file_list = [] for fp in file_meta['file']: filename, ext = os.path.splitext(fp['filename']) ext = ext.lower() image_id = uuid().hex md5_code = md5(fp['body']).hexdigest() sha1_code = sha1(fp['body']).hexdigest() exist = self.image.find_one({ 'md5_code': md5_code, 'sha1_code': sha1_code }) if exist: file_list.append( dict(image_id=exist.get('image_id'), path=exist.get('path'), name=filename + ext)) continue self.image.insert( dict(image_id=image_id, user_id=params.user_id, md5_code=md5_code, sha1_code=sha1_code, name=filename + ext, path='/image/' + image_id + ext, update_time=int(time.time()))) qcos_bucket.put_object(path='/image/' + image_id + ext.lower(), body=fp['body']) file_list.append( dict(image_id=image_id, path='/image/' + image_id + ext, name=filename + ext)) self.success(dict(file_list=file_list))
def output(): uid = str(uuid()) fontsize = request.args['fontsize'] choice = request.args['choice'] text1 = request.args['text1'] text2 = request.args['text2'] X1 = int(request.args['X1']) Y1 = int(request.args['Y1']) useD = request.args['useD'] basedir = os.path.dirname(__file__) im = Image.open(os.path.join(basedir, 'static/images', choice)) width, height = im.size xConst = width / 700 yConst = height / 700 newX = xConst * X1 newY = yConst * Y1 ''' img cont = 700px ''' draw = ImageDraw.Draw(im) font = ImageFont.truetype( os.path.join(basedir, 'fonts', 'Roboto-Regular.ttf'), int(fontsize)) draw.text((int(newX), int(newY)), text1, (0, 0, 0), font=font) if useD == "True": X2 = int(request.args['X2']) Y2 = int(request.args['Y2']) newX2 = xConst * X2 newY2 = yConst * Y2 draw.text((int(newX2), int(newY2)), text2, (0, 0, 0), font=font) path = os.path.join(basedir, 'static/memes', '{}.jpg'.format(uid)) im.save(path) app.logger.debug('X1: %s', X1) app.logger.debug('Y1: %s', Y1) return render_template('output.html', fontsize=fontsize, text1=text1, text2=text2, X1=X1, Y1=Y1, uid=uid, id=id)
def get_content_prop(): content_properties = { 'coll_id': None, 'scope': 'test_scope', 'name': 'test_file_name_%s' % str(uuid()), 'min_id': 0, 'max_id': 100, 'content_type': ContentType.File, 'status': ContentStatus.New, 'bytes': 1, 'md5': None, 'adler32': None, 'processing_id': None, 'storage_id': None, 'retries': 0, 'path': None, 'expired_at': datetime.datetime.utcnow().replace(microsecond=0), 'collcontent_metadata': {'id': 123} } return content_properties
def new_article(): # 新建文章 if request.method == 'POST': article_id = uuid().hex article_title = request.form['title'] article_content = request.form['content'] article_poster = request.form['poster'] article_created = int(time()) r.zadd('time', {article_id: article_created}) r.zadd('votes', {article_id: 0}) r.hset('article:' + article_id, 'title', article_title) r.hset('article:' + article_id, 'content', article_content) r.hset('article:' + article_id, 'created', article_created) r.hset('article:' + article_id, 'poster', article_poster) r.hset('article:' + article_id, 'votes', 0) return redirect('/') return render_template('new.html')
def enrich(extra: dict) -> dict: if 'id' in extra: ActivityBuilder.warn_field('id', extra) else: extra['id'] = str(uuid()) if 'published' in extra: ActivityBuilder.warn_field('published', extra) else: extra['published'] = datetime.utcnow().strftime( ConfigKeys.DEFAULT_DATE_FORMAT) if 'provider' in extra: ActivityBuilder.warn_field('provider', extra) else: extra['provider'] = { 'id': environ.env.config.get(ConfigKeys.ENVIRONMENT, 'testing') } return extra
def add_photo(request, rock_id): photo_file = request.FILES.get('photo-file', None) if photo_file: s3 = boto3.client('s3') key = uuid.uuid().hex[:6] + photo_file.name[photo_file.name.rfind('.'):] try: s3.upload_fileobj(photo_file, BUCKET, key) url = f"{S3_BASE_URL}{BUCKET}/{key" photo = photo(url=url, rock_id=rock_id) photo.save() except: print('An error occured uploading file to s3') return redirect('detail', rock_id=rock_id)
def upload_file_for(cls): if 'file' not in request.files: abort(400) file = request.files['file'] if file.filename == '': abort(400) if file: file_extension = _file_extension(file.filename) if file_extension == None or file_extension not in config.get( 'uploads', 'extensions'): abort(400) filename = str(uuid()) + '.' + file_extension file.save(os.path.join(cls.path(), filename)) return cls(filename=filename) return jsonify(uploaded_file)
def put(self, *_args, **_kwargs): res = self.check_auth(3) if not res: return else: _user_id, _params = res args = self.parse_json_arguments(['message', 'chat_id']) self.message_list.insert_one({ 'msg_id': uuid().hex, 'message': args.message, 'chat_id': args.chat_id, 'msg_time': int(time.time() * 1000), 'date': datetime.utcnow(), 'nickname': _params.nickname, 'user_ip': _params.user_ip }) res = dict(result=1, status=0, msg='successfully.', data=None) self.finish_with_json(res)