def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.PRINCIPAL = config('PRINCIPAL', default=self.PRINCIPAL) self.METHODS_PREFIX = config('METHODS_PREFIX', default=self.METHODS_PREFIX) self.METHODS_SUFFIX = config('METHODS_SUFFIX', default=self.METHODS_SUFFIX) self.instance_id = ulid.new().str self.health_check_topic = f'system.app.{self.APP_NAME}.alive' self.exit_status = 0 self.init() self.methods = {} self.thread_pool_executor = ThreadPoolExecutor() self.tasks_queue = asyncio.Queue() for thing_name in dir(self): thing = getattr(self, thing_name) method_name = getattr(thing, 'wamp_name', None) if method_name: self.methods[method_name] = (thing, thing.wamp_options) self.post_init()
def save(self, user_id: str = None): if self.id is None: self.id = str(ulid.new()) self.created_at = int(datetime.now().timestamp()) self.updated_at = int(datetime.now().timestamp()) item = self.to_savable_object() item['id'] = 'Task:{}'.format(self.id) try: table.put_item(Item=item, ConditionExpression='attribute_not_exists(id)') return self.to_returnable_object() except ClientError as e: logging.error(e) raise e except Exception as e: logging.error(e) raise e else: if user_id is None or user_id != self.owner: raise NotTaskOwnerError self.updated_at = int(datetime.now().timestamp()) item = self.to_savable_object() item['id'] = 'Task:{}'.format(self.id) try: table.put_item(Item=item, ConditionExpression='attribute_exists(id)') return self.to_returnable_object() except ClientError as e: logging.error(e) raise e except Exception as e: logging.error(e) raise e
def test_add_tasks(self): job_key = ulid.new().str TestLiveJobLog.job_log.add_job(job_key, 'an_image', 'www.example.com') tasks = [{ 'task_name': 'first', 'task_args': [1, 2, 3] }, { 'task_name': 'second', 'task_args': [3, 4, 5] }] TestLiveJobLog.job_log.add_tasks(job_key, tasks) actual = TestLiveJobLog.job_log.get_job(job_key) assert actual == { '__callback': 'www.example.com', '__image': 'an_image', '__task_count_complete': '0', '__task_count_started': '0', '__task_count_total': '2', 'tasks': '[{"args": [1, 2, 3], "status": 500, "result": {"stdout": null, "stderr": null}, "name": "first"}, {"args": [3, 4, 5], "status": 500, "result": {"stdout": null, "stderr": null}, "name": "second"}]' } TestLiveJobLog.job_log.clear_job(job_key) with pytest.raises(ValueError): TestLiveJobLog.job_log.get_job(job_key) is None
def register(name, query): print('register') print(f'"name": "{name}"') print(f'"query": "{query}"') assert name assert query data = ( # ulid.new().int, ulid.new().str, name, query, # int(hashlib.sha256(name.encode()).hexdigest(), 16) hashlib.sha256(name.encode()).digest()) conn = sqlite3.connect(os.environ.get('INTERNAL_STORAGE')) cursor = None try: cursor = conn.cursor() cursor.execute( 'INSERT INTO queries (id, name, query, hashed_name) VALUES (?, ?, ?, ?)', data) result = cursor.fetchall() conn.commit() except Exception: conn.rollback() raise finally: if cursor: cursor.close() conn.close()
async def mcstop(ctx): transaction_id = ulid.new().str update_transaction_id(handler, transaction_id) logger.info(f'start transaction {transaction_id}') logger.info('call mcstop') await ctx.send('停止する') shutdown = Shutdown(logger) try: logger.info('stop minecraft server...') res = shutdown.stop_instance(project, gcp_zone, instance) logger.info('done stopping minecraft server. ') except Exception as e: logger.warning(f'{e}') await ctx.send('失敗した') exit(1) try: logger.info('unregister dns...') res = shutdown.delete_dns_record(dns_auth_email, dns_zone_id, dns_auth_key, dns_name) logger.info('done unregistering dns. ') except IndexError as e: logger.warning(f'{e}') # await ctx.send('停止してた') await ctx.send('停止した') logger.info(f'end transaction {transaction_id}')
def insert_user(email, password): """ Insert a new 'users' record. """ try: new_id = ulid.new().str hashed_password = bcrypt.hashpw(bytes(password, 'utf-8'), bcrypt.gensalt()).decode('utf-8') db.insert( 'users', { 'email': email.lower(), 'display_email': email, 'password': hashed_password }) user_dict = {'user_id': new_id, 'email': email} return user_dict except Exception as e: log.error('db_users.py::insert_user', str(e)) con.commit() return None
def guid(formatter=None): """Generate a new unique ID""" id = ulid.new().str if formatter: return formatter.format(id=id) else: return id
async def mcstart(ctx): transaction_id = ulid.new().str update_transaction_id(handler, transaction_id) logger.info(f'start transaction {transaction_id}') logger.info('call mcstart') await ctx.send('起動する') standup = Standup(logger) try: logger.info('start minecraft server...') res = standup.start_instance(project, gcp_zone, instance) logger.info('done starting minecraft server. ') except Exception as e: logger.warning(f'{e}') await ctx.send('失敗した') logger.info('get instance external ip...') ip = standup.get_instance_external_ip_address(project, gcp_zone, instance) logger.info(f'done getting instance external ip {ip}') logger.info('register dns...') res = standup.add_dns_record(dns_auth_email, dns_zone_id, dns_auth_key, dns_name, ip) logger.info('done registering dns. ') if res: await ctx.send(f'起動した 接続先-> {dns_name}') else: await ctx.send(f'起動してた 接続先-> {dns_name}') logger.info(f'end transaction {transaction_id}')
class Model: """Base data model schema for Cannlytics data models.""" created_at: datetime = datetime.now() updated_at: datetime = datetime.now() uid: str = ulid.new().str.lower() ref: str = '' @classmethod def from_dict(cls, data): """Initiate a document from a dictionary.""" # Split the kwargs into native ones and new ones. native_args, new_args = {}, {} for key, value in data.items(): if key in cls.__annotations__: native_args[key] = value else: new_args[key] = value # Use the native arguments to create the class. ret = cls(**native_args) # Add the arguments to the model. for new_name, new_val in new_args.items(): setattr(ret, new_name, new_val) return ret def to_dict(self) -> dict: """Returns the model's properties as a dictionary.""" return vars(self).copy()
def add_pass(request): try: pass_id = ulid.new() master_pass = request.session['master_pass'] operation = manager.DBOperation(master_pass) e_pass = operation.encrypt_pass(request.POST['password']) pw_user = request.user Password.objects.create(pw_user=pw_user, pass_id=pass_id, pw=e_pass, purpose=request.POST['purpose'], description=request.POST['description']) try: pw_dict = request.session['pw_dict'] except KeyError: return redirect('p_manager:index') pw_dict.append({ 'id': pass_id.str, 'password': request.POST['password'], 'purpose': request.POST['purpose'], 'description': request.POST['description'] }) request.session['pw_dict'] = pw_dict print(pw_dict) return redirect('p_manager:index') except KeyError: return render(request, 'p_manager/add.html')
def new(self, last_fulid=None): """ Method to create a new friendly ulid Arguments: last_ulid (ulid): The last ulid created Returns: fulid (ulid object): Friendly ulid object """ temp_ulid = ulid.new() if last_fulid is None: id = 7 * self.charset[0].upper() else: last_fulid = fulid(self.charset, self.forbidden_charset, last_fulid) id = self._encode_id( self._decode_id(last_fulid.id()) + 1, pad=7, ) self.str = ''.join([ temp_ulid.timestamp().str, temp_ulid.randomness().str[:9], id, ]) return fulid(self.charset, self.forbidden_charset, self.str)
def get_book_by_title(title: str): request_id = request.headers.get('Request-Id', str(ulid.new())) log = logger.new(request_id=request_id) log.info("Looking up the book {title}.", data={'title': title}) time.sleep(2) log.info("We have {numCopy} copies of the book {title}.", data={'title': title, 'numCopy': 4}) return flask.jsonify({'requestId': request_id, 'book': title})
def test_can_specify_delete_subcommand(self): arguments = [ 'del', ulid.new().str ] parsed = self.parser.parse_args(arguments) assert parsed.subcommand == arguments[0] assert parsed.ulid == arguments[1]
def before_request(): """ Before request gather log details """ g.start_time = time.time() g.request_id = str(ulid.new()) get_log().info("CorrelationId", correlationId=request.headers.get("x-linz-correlation-id", str(ulid.new())))
def test_delete_subcomand_deletes_task(self): arguments = ['del', ulid.new().str] self.parser_args.subcommand = arguments[0] self.parser_args.ulid = arguments[1] main() self.tm.return_value.delete.assert_called_once_with(id=arguments[1])
def test_write_read_log() -> None: wal = new_wal(state_transition_noop) block_number = BlockNumber(1337) block_hash = make_block_hash() block = Block(block_number=block_number, gas_limit=BlockGasLimit(1), block_hash=block_hash) unlocked_amount = TokenAmount(10) returned_amount = TokenAmount(5) participant = make_address() partner = make_address() locksroot = make_locksroot() contract_receive_unlock = ContractReceiveChannelBatchUnlock( transaction_hash=make_transaction_hash(), canonical_identifier=make_canonical_identifier( token_network_address=make_address()), receiver=participant, sender=partner, locksroot=locksroot, unlocked_amount=unlocked_amount, returned_tokens=returned_amount, block_number=block_number, block_hash=block_hash, ) state_changes1 = wal.storage.get_statechanges_by_range( RANGE_ALL_STATE_CHANGES) count1 = len(state_changes1) dispatch(wal, [block]) state_changes2 = wal.storage.get_statechanges_by_range( RANGE_ALL_STATE_CHANGES) count2 = len(state_changes2) assert count1 + 1 == count2 dispatch(wal, [contract_receive_unlock]) state_changes3 = wal.storage.get_statechanges_by_range( RANGE_ALL_STATE_CHANGES) count3 = len(state_changes3) assert count2 + 1 == count3 result1, result2 = state_changes3[-2:] assert isinstance(result1, Block) assert result1.block_number == block_number assert isinstance(result2, ContractReceiveChannelBatchUnlock) assert result2.receiver == participant assert result2.sender == partner assert result2.locksroot == locksroot assert result2.unlocked_amount == unlocked_amount assert result2.returned_tokens == returned_amount # Make sure state snapshot can only go for corresponding state change ids with pytest.raises(sqlite3.IntegrityError): wal.storage.write_state_snapshot(State(), StateChangeID(ulid.new()), 1)
def create_new_job(self, image_name, callback, tasks): self._log_operation( 'Creating new job with image {img} and callback {cb}'.format( img=image_name, cb=callback)) identifier = ulid.new().str self._job_queue.add_new_job(identifier, image_name, callback, tasks) self._run_tasks() return identifier
def post(self): """ Insert an issue into the database. Parse the provided JSON data to validate that we have the correct fields. Additional server-side validation is left for a future exercise. """ args = self.parser.parse_args(strict=True) query_db('INSERT INTO issues(id, data) VALUES(?, ?)', (str(ulid.new()), json.dumps(args))) return { "message": "Success" }, 200
def _generate_id() -> str: """Create ULID See: https://github.com/ahawker/ulid Returns: str: ULID random, unique identifier """ return ulid.new()
class Holding(Consumer): class Meta(Consumer.Meta): table_name = os.environ['STAGE'] + '-stonks-holding' holdingId = UnicodeAttribute(hash_key=True, default_for_new=str(ulid.new())) symbol = UnicodeAttribute(default="fresh") symbolIndex = SymbolIndex() units = NumberAttribute(default=0) averagePrice = NumberAttribute(default=0) latestTradePrice = NumberAttribute(default=0) bookCost = NumberAttribute(default=0) # Consumes the event @classmethod def consume(cls, event, consumer=None): if (consumer == None): symbol = event['symbol'] results = cls.symbolIndex.query(symbol) results = [result for result in results] if (len(results) == 0): consumer = cls(symbol=symbol, holdingId=str(ulid.new())) consumer.save() else: consumer = results[0] consumer.refresh(consistent_read=True) # Bit of business logic action = event['action'] units = int(event['units']) tradePrice = int(event['tradePrice']) holdingBookCost = int(consumer.averagePrice) * int(consumer.units) eventAveragePrice = int(event['averagePrice']) eventTotalCost = eventAveragePrice * units if (action == ActionEnum.BUY): units += int(consumer.units) holdingBookCost += eventTotalCost elif (action == ActionEnum.SELL): units = int(consumer.units) - units holdingBookCost -= eventTotalCost try: averagePrice = int(holdingBookCost / units) except ZeroDivisionError: averagePrice = 0 # Update fields consumer.update(actions=[ cls.units.set(units), cls.averagePrice.set(averagePrice), cls.bookCost.set(holdingBookCost), cls.latestTradePrice.set(tradePrice), cls.version.set(event['eventId']) ])
def new( self, name: str, id: str = None, created_at: datetime = None, ) -> Org: return Org( id=ulid.new().str if id is None else id, created_at=datetime.now() if created_at is None else created_at, name=name, )
def __init__(self, builder_cats=(), source_object=None, builder_predicate=None): self.builder_predicate = builder_predicate self.id = ulid.new().str # link class with builder cat # insert in the class for cat in builder_cats: BuilderGraph.add_edge(cat.id, self.id, weight=None) ClassSet[self.id] = self
def main(): # outputディレクトリ配下のjsonファイルを順番に読み込みデータベースに投入する for json_file_name in listup_files('./output/*'): with open(json_file_name, 'r', encoding='utf-8') as f: print(f) dict_data = dict() for data in json.load(f): dict_data[str(ulid.new())] = data print(data) import_to_db(dict_data)
def index(): """ index req """ dt = datetime.datetime.now() dtstr = str(dt) myulid = ulid.new() strmyulid = myulid.str intmyulid = myulid.int bmyulid = bazed_ulid(intmyulid) return template(tpl, **params)
async def index(): dt = datetime.datetime.now() dtstr = str(dt) myulid = ulid.new() strmyulid = myulid.str intmyulid = myulid.int bmyulid = bazed_ulid(intmyulid) return await render_template_string( "<tt>The %s hello from engine %s with ver.%s at %s<br />as long %s [len%d] and short %s [len%d]</tt>" % (params["web_mode"], params["web_driver"], version, dtstr, strmyulid, len(strmyulid), bmyulid, len(bmyulid)))
def test_freeze_subcommand_freezes_task(self): arguments = ['freeze', ulid.new().str] self.parser_args.subcommand = arguments[0] self.parser_args.ulid = arguments[1] self.parser_args.parent = False main() self.tm.return_value.freeze.assert_called_once_with( id=arguments[1], parent=False, )
def test_add_job_and_delete(self): job_key = ulid.new().str TestLiveJobLog.job_log.add_job(job_key, 'an_image', 'www.example.com') actual = TestLiveJobLog.job_log.get_job(job_key) assert actual == { '__image': 'an_image', '__callback': 'www.example.com', 'tasks': '[]' } TestLiveJobLog.job_log.clear_job(job_key) with pytest.raises(ValueError): TestLiveJobLog.job_log.get_job(job_key) is None
def test_unfreeze_parent_subcommand_unfreezes_task(self): arguments = ['unfreeze', '-p', ulid.new().str] self.parser_args.subcommand = arguments[0] self.parser_args.ulid = arguments[1] self.parser_args.parent = True main() self.tm.return_value.unfreeze.assert_called_once_with( id=arguments[1], parent=True, )
def index(): """ index req """ dt = datetime.datetime.now() dtstr = str(dt) myulid = ulid.new() strmyulid = myulid.str intmyulid = myulid.int bmyulid = bazed_ulid(intmyulid) return "<tt>The {{python_mode}} hello from engine ver.%s at %s<br />as long %s [len%d] and short %s [len%d]</tt>" % ( version, dtstr, strmyulid, len(strmyulid), bmyulid, len(bmyulid))
def generate_rand(author, authorId): likes = random.randint(0, 20000) reads = random.randint(0, 10000) + likes popularity = round(random.random(), 2) id = ulid.new().str tags = Post.generate_tags() return Post(author, authorId, id, likes, popularity, reads, tags).generate() # print(Post.generate_rand())