def findFFmpeg(self): fname = QFileDialog.getOpenFileName(self, "选择目录", QDir.currentPath()) if fname[0]: path = fname[0] self.ffmpegEdit.setText(path) GlobalConfig.instance().binPath = path GlobalConfig.instance().save()
def test_parse_training_labels(self): parsed = ingest.parse_training_labels( train_box_df=pd.read_csv( GlobalConfig.get('EXAMPLE_TRAIN_BOX_PATH')), train_image_dirpath=GlobalConfig.get( 'EXAMPLE_STAGE1_TRAIN_IMAGE_DIR')) # Negative Case self.assertEquals( parsed['0004cfab-14fd-4e49-80ba-63a80b6bddd6'], { 'dicom': 'data/example/stage_1_train_images/0004cfab-14fd-4e49-80ba-63a80b6bddd6.dcm', 'label': 0, 'boxes': [] }) # Positive Case self.assertEquals( parsed['00436515-870c-4b36-a041-de91049b9ab4'], { 'dicom': 'data/example/stage_1_train_images/00436515-870c-4b36-a041-de91049b9ab4.dcm', 'label': 1, 'boxes': [[264.0, 152.0, 213.0, 379.0], [562.0, 152.0, 256.0, 453.0]] })
def oDir(self): directory = QFileDialog.getExistingDirectory(self, "选择目录", QDir.currentPath()) if directory: self.oDirEdit.setText(directory) GlobalConfig.instance().outputDir = directory GlobalConfig.instance().save()
def initData(self): self.initDir() self.tempconfig = GlobalConfig(TEMP_FILE) if os.path.exists(TEMP_FILE): self.current_cluster_index = int( self.tempconfig.get("TEMP", "cluster_index")) else: self.current_cluster_index = 1 self.init_cluster_data(self.current_cluster_index)
def initDir(self): if not os.path.exists(ROOT_DIR): os.mkdir(ROOT_DIR) if not os.path.exists(CLUSTER_DIR): os.mkdir(CLUSTER_DIR) if not os.path.exists(TEMP_FILE): self.tempconfig = GlobalConfig(TEMP_FILE) self.tempconfig.add_section("TEMP") self.tempconfig.set("TEMP", "cluster_index", "1") self.tempconfig.save(TEMP_FILE)
def _retrieve_training_box_labels(self): if self.data_source == 'local': train_box_df = pd.read_csv(GlobalConfig.get('LOCAL_TRAIN_BOX_PATH')) elif self.data_source == 'example': train_box_df = pd.read_csv(GlobalConfig.get('EXAMPLE_TRAIN_BOX_PATH')) elif self.data_source == 's3': train_box_df = ingest.read_s3_df( bucket=GlobalConfig.get('S3_BUCKET_NAME'), file_key=GlobalConfig.get('S3_TRAIN_BOX_KEY')) return train_box_df
def __init__(self, tfrecords_path: str, weights_path: str, config: GlobalConfig): self._log = LogFactory.get_logger() self._tfrecords_path = tfrecords_path self._weights_path = weights_path self._batch_size = config.get_test_config().batch_size self._merge_repeated = config.get_test_config().merge_repeated_chars self._gpu_config = config.get_gpu_config() self._decoder = TextFeatureIO().reader self._recognition_time = None
def get_cross_validator(): """ Generates and returns the ShuffleSplit cross validator. This uses a fixed random_state=0, so that every time each cross fold contains the same subset of data. :return: sklearn.model_selection.ShuffleSplit with relevant parameters. """ return StratifiedShuffleSplit( n_splits=GlobalConfig.get('folds'), train_size=GlobalConfig.get('train_ratio'), random_state=0)
def _retrieve_annotation_dict(self, train_box_df): if self.data_source == 'local': dirpath = GlobalConfig.get('LOCAL_STAGE1_TRAIN_IMAGE_DIR') if self.data_source == 'example': dirpath = GlobalConfig.get('EXAMPLE_STAGE1_TRAIN_IMAGE_DIR') elif self.data_source == 's3': dirpath = GlobalConfig.get('S3_STAGE1_TRAIN_IMAGE_DIR') annotation_dict = ingest.parse_training_labels( train_box_df=train_box_df, train_image_dirpath=dirpath) return annotation_dict
def main(path_data, path_config): if not os.path.isfile(os.path.join(path_data, "0_segmentation_0_final.png")): raise FileNotFoundError("It seems that output from PlaneRCNN is missing!") logger.info(f"Loading config from {path_config}") GlobalConfig.load_config(path_config) logger.info(f"Loading data from {path_data}") image_data = ImageData(0, path_data) image_data.load_data() # Run refinement logger.info("Starting refinement procedure") result_dict = start_refinement_procedure(image_data) return result_dict
def __init__(self, num_classes: int, data_ratio: float): self.num_categories = num_classes self.data_ratio = data_ratio self.classes = [] self.train = [] self.test = [] if GlobalConfig.get('rotate'): print("Using rotated textures") if GlobalConfig.get('ECS'): self.KYLBERG_DIR = os.path.join('C:/', 'Local', 'data', 'kylberg-rotated') else: self.KYLBERG_DIR = os.path.join(GlobalConfig.get('CWD'), 'data', 'kylberg-rotated') else: print("Using non-rotated textures") if GlobalConfig.get('ECS'): self.KYLBERG_DIR = os.path.join('C:/', 'Local', 'data', 'kylberg') else: self.KYLBERG_DIR = os.path.join(GlobalConfig.get('CWD'), 'data', 'kylberg') print('Using {} scale'.format(GlobalConfig.get('scale'))) if GlobalConfig.get('noise') is not None: print('Applying {} noise'.format(GlobalConfig.get('noise')))
def make_classification_report(y_true, y_pred, classes, out_dir): # Get the full report rpt = classification_report(y_true, y_pred, labels=classes, output_dict=True) # Get the average results from all classes rpt_accuracy = rpt['accuracy'] rpt_macro_avg = rpt['macro avg'] rpt_weighted_avg = rpt['weighted avg'] # Get the per-class results only del rpt['accuracy'] del rpt['macro avg'] del rpt['weighted avg'] pandas_rpt = pd.DataFrame.from_dict(rpt, orient='index') pandas_rpt.rename(columns={'support': 'N Predictions'}, inplace=True) pandas_macro_avg = pd.DataFrame.from_dict(rpt_macro_avg, orient='index', columns=['Macro Average']) pandas_macro_avg.rename(columns={'support': 'N Predictions'}, inplace=True) pandas_weighted_avg = pd.DataFrame.from_dict(rpt_weighted_avg, orient='index', columns=['Weighted Average']) pandas_weighted_avg.rename(columns={'support': 'N Predictions'}, inplace=True) pandas_accuracy = pd.DataFrame({'': rpt_accuracy}, index=['overall accuracy']) if GlobalConfig.get('algorithm') == 'MRLBP': if GlobalConfig.get('mrlbp_classifier') == 'knn': out_file = os.path.join( out_dir, 'Classification Report{} - KNN.csv'.format( describe_test_setup())) else: out_file = os.path.join( out_dir, 'Classification Report{} - SVM.csv'.format( describe_test_setup())) else: out_file = os.path.join( out_dir, 'Classification Report{}.csv'.format(describe_test_setup())) pandas_rpt.to_csv(out_file) pandas_macro_avg.to_csv(out_file, mode='a', header=True) pandas_weighted_avg.to_csv(out_file, mode='a', header=True) pandas_accuracy.to_csv(out_file, mode='a', header=True)
def create(self, name): cost = [(money_text_to_item_id('diamond'), GlobalConfig.value("UNION_CREATE_COST"))] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) doc = MongoUnion.document() doc['_id'] = make_string_id() doc['create_at'] = arrow.utcnow().timestamp doc['name'] = name doc['owner'] = self.char_id try: MongoUnion.db(self.server_id).insert_one(doc) except DuplicateKeyError: raise GameException(ConfigErrorMessage.get_error_id("UNION_NAME_HAS_TAKEN")) MongoUnionMember.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'joined': doc['_id'], 'joined_at': arrow.utcnow().timestamp }} ) rc.remove(self.server_id, self.char_id, message="Union.create") Union(self.server_id, self.char_id).send_all_notify()
def speedup(self): if not self.doc['item_id']: raise GameException(ConfigErrorMessage.get_error_id("SPECIAL_EQUIPMENT_NOT_IN_PROCESS")) seconds = self.doc['finish_at'] - arrow.utcnow().timestamp if seconds <= 0: raise GameException(ConfigErrorMessage.get_error_id("SPECIAL_EQUIPMENT_ALREADY_FINISHED")) minutes, remained = divmod(seconds, 60) if remained: minutes += 1 diamond = minutes * GlobalConfig.value("EQUIPMENT_SPECIAL_SPEEDUP_PARAM") * 0.1 diamond = int(diamond) cost = [(money_text_to_item_id('diamond'), diamond)] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="SpecialEquipmentGenerator.speedup") # make sure is finished self.doc['finish_at'] = arrow.utcnow().timestamp - 1 MongoSpecialEquipment.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'finish_at': self.doc['finish_at'] }} ) self.send_notify()
def match(self, friend_id): friend_id = int(friend_id) if not self.check_friend_exist(friend_id): raise GameException( ConfigErrorMessage.get_error_id("FRIEND_NOT_OK")) club_one = Club(self.server_id, self.char_id) club_two = Club(self.server_id, friend_id) f_one = Formation(self.server_id, self.char_id) f_two = Formation(self.server_id, self.char_id) match = ClubMatch(club_one, club_two, 6, f_one.get_skill_sequence(), f_two.get_skill_sequence()) msg = match.start() msg.key = "" msg.map_name = GlobalConfig.value_string("MATCH_MAP_FRIEND") friend_match_signal.send(sender=None, server_id=self.server_id, char_id=self.char_id, target_id=friend_id, win=msg.club_one_win) return msg
def __init__(self, server_id, char_id): self.server_id = server_id self.char_id = char_id self.max_times = GlobalConfig.value("UNION_EXPLORE_TIMES") self.current_times = ValueLogUnionExploreTimes(server_id, char_id).count_of_today() self._calculate()
def destroy(self, using_sycee): if self.level == UNIT_INIT_LEVEL and self.step == UNIT_INIT_STEP: raise GameException(ConfigErrorMessage.get_error_id("UNIT_IS_INIT_CANNOT_DESTROY")) if using_sycee: need_diamond = GlobalConfig.value("UNIT_DESTROY_SYCEE") cost = [(money_text_to_item_id('diamond'), need_diamond), ] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id, message="Unit.destroy:{0}".format(self.id)) percent = 1 else: percent = 0.7 items = self.get_strengthen_cost() items = [(_id, int(_amount * percent)) for _id, _amount in items] rc = ResourceClassification.classify(items) rc.add(self.server_id, self.char_id, message="Unit.destroy:{0}".format(self.id)) self.level = UNIT_INIT_LEVEL self.step = UNIT_INIT_STEP MongoUnit.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'units.{0}.level'.format(self.id): self.level, 'units.{0}.step'.format(self.id): self.step, }} ) return rc
def __init__(self): self.config = GlobalConfig() os.environ["CUDA_VISIBLE_DEVICES"] = "0,1" print("torch.distributed.is_available: " + str(torch.distributed.is_available())) print("Device Count: {0}".format(torch.cuda.device_count())) transform = transforms.Compose([ transforms.Resize(self.config.Width), transforms.RandomCrop(self.config.Width), transforms.ToTensor(), transforms.Normalize(mean=self.config.mean, std=self.config.std) ]) # Creates training set self.train_loader = torch.utils.data.DataLoader( datasets.ImageFolder(self.config.TRAIN_PATH, transform), batch_size=self.config.train_batch_size, num_workers=4, pin_memory=True, shuffle=True, drop_last=True) self.train_dataset = MyDataset(root='F:\\ILSVRC2012_img_val\\', filename='./val.txt') print(len(self.train_dataset)) self.train_loader = data.DataLoader( dataset=self.train_dataset, batch_size=self.config.train_batch_size, shuffle=True, num_workers=4) self.net = HighQualityNet(config=self.config)
def match(self, friend_id): friend_id = int(friend_id) if not self.check_friend_exist(friend_id): raise GameException(ConfigErrorMessage.get_error_id("FRIEND_NOT_OK")) club_one = Club(self.server_id, self.char_id) club_two = Club(self.server_id, friend_id) f_one = Formation(self.server_id, self.char_id) f_two = Formation(self.server_id, self.char_id) match = ClubMatch(club_one, club_two, 6, f_one.get_skill_sequence(), f_two.get_skill_sequence()) msg = match.start() msg.key = "" msg.map_name = GlobalConfig.value_string("MATCH_MAP_FRIEND") friend_match_signal.send( sender=None, server_id=self.server_id, char_id=self.char_id, target_id=friend_id, win=msg.club_one_win ) return msg
def get_info(self): return { 'max_buy_times': GlobalConfig.value("PARTY_BUY_MAX_TIMES"), 'remained_create_times': self.get_remained_create_times(), 'remained_join_times': self.get_remained_join_times(), 'talent_id': self.doc['talent_id'], }
def create(self, name): cost = [(money_text_to_item_id('diamond'), GlobalConfig.value("UNION_CREATE_COST"))] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) doc = MongoUnion.document() doc['_id'] = make_string_id() doc['create_at'] = arrow.utcnow().timestamp doc['name'] = name doc['owner'] = self.char_id try: MongoUnion.db(self.server_id).insert_one(doc) except DuplicateKeyError: raise GameException( ConfigErrorMessage.get_error_id("UNION_NAME_HAS_TAKEN")) MongoUnionMember.db(self.server_id).update_one({'_id': self.char_id}, { '$set': { 'joined': doc['_id'], 'joined_at': arrow.utcnow().timestamp } }) rc.remove(self.server_id, self.char_id, message="Union.create") Union(self.server_id, self.char_id).send_all_notify()
def __init__(self, config=GlobalConfig()): super(Net, self).__init__() self.config = config self.device = config.device self.m1 = PrepNetwork().cuda() self.m2 = HidingNetwork().cuda() self.m3 = RevealNetwork().cuda()
def record(self): ValueLogUnionExploreTimes(self.server_id, self.char_id).record() UnionExploreCD(self.server_id, self.char_id).set( GlobalConfig.value("UNION_EXPLORE_CD")) self.current_times += 1 self._calculate()
def __init__(self, config=GlobalConfig(), resize_ratio_range=(0.5,2), interpolation_method='nearest'): super(Resize, self).__init__() self.config = config self.device = config.device self.resize_ratio_min = resize_ratio_range[0] self.resize_ratio_max = resize_ratio_range[1] self.interpolation_method = interpolation_method
def one_way_match(_club_one, _club_two, _skill_sequence_one, _skill_sequence_two): _match = ClubMatch(_club_one, _club_two, 3, _skill_sequence_one, _skill_sequence_two) _msg = _match.start(auto_load_staffs=False, check_empty=False) _msg.key = "" _msg.map_name = GlobalConfig.value_string("MATCH_MAP_CHAMPIONSHIP") _req = ClubMatchServerSideRequest() _req.match.MergeFrom(_msg) _data = _req.SerializeToString() _res = requests.post(match_server_url, headers=MATCH_SERVER_REQ_HEADERS, data=_data) response = ClubMatchServerSideResponse() response.ParseFromString(_res.content) if response.star > 0: _win = 1 else: _win = 0 return _win, _msg.SerializeToString(), response.record
def __init__(self, height, width, differentiable=True, quality=80, config=GlobalConfig()): ''' Initialize the DiffJPEG layer Inputs: height(int): Original image hieght width(int): Original image width differentiable(bool): If true uses custom differentiable rounding function, if false uses standrard torch.round quality(float): Quality factor for jpeg compression scheme. ''' super(DiffJPEG, self).__init__() self.config = config self.quality = quality if differentiable: rounding = diff_round else: rounding = torch.round factor = quality_to_factor(quality) self.compress = compress_jpeg(rounding=rounding, factor=factor) self.decompress = decompress_jpeg(height, width, rounding=rounding, factor=factor)
def help(self, friend_id, building_id): friend_id = int(friend_id) if not FriendManager(self.server_id, self.char_id).check_friend_exist(friend_id): raise GameException( ConfigErrorMessage.get_error_id("FRIEND_NOT_OK")) if not self.get_remained_help_times(): raise GameException( ConfigErrorMessage.get_error_id( "TERRITORY_NO_HELP_FRIEND_TIMES")) if not TerritoryFriend(self.server_id, friend_id).get_remained_got_help_times(): raise GameException( ConfigErrorMessage.get_error_id("TERRITORY_NO_GOT_HELP_TIMES")) t = Territory(self.server_id, friend_id) building = t.get_building_object(building_id, slots_ids=[]) event_id = building.event_id if not event_id: raise GameException( ConfigErrorMessage.get_error_id("TERRITORY_BUILDING_NO_EVENT")) MongoTerritory.db(self.server_id).update_one( {'_id': friend_id}, {'$set': { 'buildings.{0}.event_id'.format(building_id): 0 }}) config = ConfigTerritoryEvent.get(event_id) if not config.npc: resource_classified = ResourceClassification.classify( config.reward_win) resource_classified.add(self.server_id, self.char_id, message="TerritoryFriend.help") # NOTE: 战斗要等到结算的时候再记录次数 ValueLogTerritoryHelpFriendTimes(self.server_id, self.char_id).record() self.send_remained_times_notify() Territory(self.server_id, friend_id).got_help(self.char_id, building_id, config.target_exp) return None, resource_classified npc_club = ConfigNPCFormation.get(config.npc) my_club = Club(self.server_id, self.char_id) f = Formation(self.server_id, self.char_id) match = ClubMatch(my_club, npc_club, 6, f.get_skill_sequence(), {}) msg = match.start() msg.key = "{0}:{1}:{2}".format(friend_id, building_id, event_id) msg.map_name = GlobalConfig.value_string("MATCH_MAP_TERRITORY_FRIEND") return msg, None
def split_dataset_by_class(annotation_dict, subset_size, validation_split): """Split dataset for training and validation, preserving outcome class distribution.""" n_positive = sum(1 for v in annotation_dict.values() if v['label'] == 1) n_total = len(annotation_dict) p_positive = n_positive / n_total positive_ids = [k for k, v in annotation_dict.items() if v['label'] == 1] negative_ids = [k for k, v in annotation_dict.items() if v['label'] == 0] random.seed(GlobalConfig.get('RANDOM_SEED')) random.shuffle(positive_ids) random.shuffle(negative_ids) n_positive_subset = int(math.ceil(subset_size * p_positive)) n_negative_subset = int(subset_size - n_positive_subset) # ceilings & floors to ensure that we get exactly subset_size*validation_split train_pos_index = int(math.ceil(n_positive_subset * (1 - validation_split))) train_neg_index = int( math.floor(n_negative_subset * (1 - validation_split))) train_ids = positive_ids[:train_pos_index] + negative_ids[:train_neg_index] valid_ids = positive_ids[train_pos_index:n_positive_subset] + \ negative_ids[train_neg_index:n_negative_subset] print('Training count: %s' % len(train_ids)) print('Validation instance count: %s' % len(valid_ids)) return {'train_ids': train_ids, 'valid_ids': valid_ids}
def recognize(image_path: str, weights_path: str, config: GlobalConfig, is_vis=True): logger = LogFactory.get_logger() image = load_and_resize_image(image_path) inputdata = tf.placeholder(dtype=tf.float32, shape=[1, 32, 100, 3], name='input') net = CRNN(phase='Test', hidden_nums=256, seq_length=25, num_classes=37) with tf.variable_scope('shadow'): net_out = net.build(inputdata=inputdata) decodes, _ = tf.nn.ctc_beam_search_decoder(inputs=net_out, sequence_length=25 * np.ones(1), merge_repeated=False) decoder = TextFeatureIO() # config tf session sess_config = tf.ConfigProto() sess_config.gpu_options.per_process_gpu_memory_fraction = config.get_gpu_config( ).memory_fraction sess_config.gpu_options.allow_growth = config.get_gpu_config( ).is_tf_growth_allowed() # config tf saver saver = tf.train.Saver() sess = tf.Session(config=sess_config) with sess.as_default(): saver.restore(sess=sess, save_path=weights_path) preds = sess.run(decodes, feed_dict={inputdata: image}) preds = decoder.writer.sparse_tensor_to_str(preds[0]) logger.info('Predict image {:s} label {:s}'.format( ops.split(image_path)[1], preds[0])) if is_vis: plt.figure('CRNN Model Demo') plt.imshow( cv2.imread(image_path, cv2.IMREAD_COLOR)[:, :, (2, 1, 0)]) plt.show() sess.close()
def join(self): if self.doc['joined']: return diamond = GlobalConfig.value("LEVEL_GROWING_ACTIVITY_JOIN_COST_DIAMOND") vip_need = GlobalConfig.value("LEVEL_GROWING_ACTIVITY_JOIN_VIP_LIMIT") VIP(self.server_id, self.char_id).check(vip_need) cost = [(money_text_to_item_id('diamond'), diamond), ] rc = ResourceClassification.classify(cost) rc.check_exist(self.server_id, self.char_id) rc.remove(self.server_id, self.char_id) current_level = get_club_property(self.server_id, self.char_id, 'level') self._update(current_level, joined=True) self.send_notify()
def getCmd(self): outputfile = os.path.join( self.task.outputDir, self.task.outputFile + "." + self.task.preset.ext) cmdstr = "{} -i {} {} {} {} -strict experimental -preset medium -tune film -crf 0 -threads 4 {} ".format( GlobalConfig.instance().binPath, self.task.name, self.getVCodec(), self.getACodec(), self.getResulution(), outputfile) return cmdstr
def get_outdir(self, noisy_image: bool, scaled_image: bool): if noisy_image: noise_type = GlobalConfig.get('noise') noise_val = GlobalConfig.get('noise_val') else: noise_type = 'None' noise_val = 'None' if scaled_image: image_scale = int(GlobalConfig.get('test_scale') * 100) else: image_scale = int(GlobalConfig.get('scale') * 100) if GlobalConfig.get('train_noise'): return "scale-{}_noise-{}_noiseval-{}-trainnoise".format(image_scale, noise_type, noise_val) else: return "scale-{}_noise-{}_noiseval-{}".format(image_scale, noise_type, noise_val)
def __init__(self, server_id, char_id): self.server_id = server_id self.char_id = char_id self.max_times = GlobalConfig.value("UNION_EXPLORE_TIMES") self.current_times = ValueLogUnionExploreTimes( server_id, char_id).count_of_today() self._calculate()
def yaml_file_to_world_objects(file_path): tree = None with open(file_path, 'r') as f: tree = yaml.load(f, Loader=Loader) if tree is None: return [] rv = {'camera': None, 'lights': [], 'world': [], 'config': None} defines = {} extends_map = {} for obj in tree: if "define" in obj: k = obj["define"] v = obj.get("value") opt = obj.get("extend") defines[k] = v if opt is not None: extends_map[k] = opt # replace 'extends' in defines map for obj_name in extends_map: parent_name = extends_map[ obj_name] # name of object which will be extended parent_value = defines[parent_name] child_value = defines[ obj_name] # name of object with 'extends' keyword new_parent_value = deepcopy(parent_value) if type(new_parent_value) == dict: # assume child value is same type for k in child_value: new_parent_value[k] = child_value[k] defines[obj_name] = new_parent_value expand_defines_in_tree(tree, defines) for obj in tree: if "add" in obj: if obj["add"] == "camera": rv['camera'] = Camera.from_yaml(obj) elif obj["add"] == "light": rv['lights'].append(Light.from_yaml(obj)) elif obj['add'] == 'config': rv['config'] = GlobalConfig.from_yaml(obj) else: possible_item = recursive_add(obj, defines) if possible_item is not None: rv['world'].append(possible_item) g = Group(material=Material(), transform=matrix4x4identity(), children=rv['world']) rv['world'] = [g] return rv
def __init__(self, server_id, char_id): self.server_id = server_id self.char_id = char_id self.max_times = GlobalConfig.value("UNION_HARASS_TIMES") self.current_times = ValueLogUnionHarassTimes(server_id, char_id).count_of_today() self.current_buy_times = ValueLogUnionHarassBuyTimes(server_id, char_id).count_of_today() self.vip_max_buy_times = VIP(server_id, char_id).union_harass_buy_times self._calculate()
def get_reward(self): if self.doc['count'] < 1: raise GameException(ConfigErrorMessage.get_error_id("INVALID_OPERATE")) self.add_count(-1) item_id = GlobalConfig.value("PURCHASE_DAILY_REWARD_ITEM_ID") rc = ResourceClassification.classify(ConfigItemUse.get(item_id).using_result()) rc.add(self.server_id, self.char_id) return rc
def get_dataset_train(self): dataset_train = DetectorDataset( patient_ids=self.patient_id_train, annotation_dict=self.annotation_dict, orig_height=self.DICOM_HEIGHT, orig_width=self.DICOM_WIDTH, data_source=self.data_source, s3_bucket=(GlobalConfig.get('S3_BUCKET_NAME') if self.data_source == 's3' else None)) dataset_train.prepare() assert len(dataset_train.image_ids) == len(self.patient_id_train) return dataset_train
def auto_increase_product(cls, server_id): level_limit = GlobalConfig.value("TERRITORY_BUILDING_AUTO_INCREASE_LEVEL") level_condition = {'level': {'$gte': level_limit}} char_ids = Club.get_recent_login_char_ids(server_id, other_conditions=[level_condition]) char_ids = [i for i in char_ids] docs = MongoTerritory.db(server_id).find({'_id': {'$in': char_ids}}) for doc in docs: t = Territory(server_id, doc['_id'], doc) t.building_auto_increase_product()
def read_cluster_data(self, file): if not os.path.exists(file): file = os.path.join(CONFIG_DIR, "cluster.ini") self.cluster_config = GlobalConfig(file) self.steam_group_id.setText( self.cluster_config.get("STEAM", "steam_group_id")) self.steam_group_only.setChecked( self.cluster_config.getboolean("STEAM", "steam_group_only")) self.steam_group_admin.setChecked( self.cluster_config.getboolean("STEAM", "steam_group_admins")) self.pvp.setChecked(self.cluster_config.getboolean("GAMEPLAY", "pvp")) self.game_mode.setCurrentIndex( self.game_mode_value.index( self.cluster_config.get("GAMEPLAY", "game_mode"))) self.pause_when_empty.setChecked( self.cluster_config.getboolean("GAMEPLAY", "pause_when_empty")) self.vote.setChecked( self.cluster_config.getboolean("GAMEPLAY", "vote_enabled")) self.max_players.setText( self.cluster_config.get("GAMEPLAY", "max_players")) self.cluster_name.setText( self.cluster_config.get("NETWORK", "cluster_name")) self.cluster_description.setText( self.cluster_config.get("NETWORK", "cluster_description")) self.cluster_intention.setCurrentIndex( self.cluster_intention_value.index( self.cluster_config.get("NETWORK", "cluster_intention"))) if self.cluster_config.get("NETWORK", "cluster_language") == "zh": self.zh_rbtn.setChecked(True) else: self.en_rbtn.setChecked(True) self.white_players.setText( self.cluster_config.get("NETWORK", "whitelist_slots")) self.password.setText( self.cluster_config.get("NETWORK", "cluster_password")) self.setServerIP(self.masterip, self.cluster_config.get("SHARD", "master_ip"))
def getCmd(self): outputfile = os.path.join(self.task.outputDir, self.task.outputFile + "." + self.task.preset.ext) cmdstr= "{} -i {} {} {} {} -strict experimental -preset medium -tune film -crf 0 -threads 4 {} ".format( GlobalConfig.instance().binPath, self.task.name, self.getVCodec(), self.getACodec(), self.getResulution(), outputfile) return cmdstr
def __init__(self, name): super(ConvTask, self).__init__() self.name = name self.outputFile = os.path.split(os.path.splitext(name)[0])[-1]+"_Converted" print(self.outputFile) self.outputDir = GlobalConfig.instance().outputDir self.progressRate = 0 self.proc = None self.duration = self.getDuration() self.status = ConvTask.STOP self.error = False self.logfile = "tmp{}.txt".format(time.time()) self.preset = None
def getDuration(self): cmdstr = "{} -i {}".format(GlobalConfig.instance().binPath,self.name) print("getDuration cmd:{}".format(cmdstr)) proc = subprocess.Popen(cmdstr, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE ) output = proc.communicate(0)[1] print(output) duration_pat = "(Duration:\s*(?P<hour>[\d]+):(?P<minute>[\d]+):(?P<second>[\d]+)\.(\d)+,)" m = re.search(duration_pat, str(output)) seconds = int(m.group("hour")) * 3600 + int(m.group("minute"))*60 + int(m.group("second")) print("duration{0:d}".format(seconds)) return seconds
def post(self, content): from core.club import get_club_property if self.CD(self.server_id, self.char_id).get_cd_seconds(): raise GameException(ConfigErrorMessage.get_error_id("CHAT_TOO_FAST")) if len(content) > 300: raise GameException(ConfigErrorMessage.get_error_id("CHAT_TOO_LARGE")) try: with self.LOCK(self.server_id, self.char_id).lock(3, 3): now = arrow.utcnow().timestamp message = { 'msg_id': make_string_id(), 'club_id': str(self.char_id), 'name': get_club_property(self.server_id, self.char_id, 'name'), 'content': content, 'post_at': now, 'approval': 0, 'last_update_at': now, } _data = self.make_notify_data(message=message) self.broadcast(_data) self.doc['value'].insert(0, message) if len(self.doc['value']) > 100: self.doc['value'].sort(key=lambda item: -item['last_update_at']) removed = self.doc['value'].pop(-1) remove_notify = self.REMOVE_NOTIFY() remove_notify.msg_id = removed['msg_id'] WinningChatApprovalMark(self.server_id, self.char_id, removed['msg_id']).delete() self.broadcast(MessageFactory.pack(remove_notify)) MongoCommon.db(self.server_id).update_one( {'_id': self.get_id()}, {'$set': { 'value': self.doc['value'] }} ) except LockTimeOut: raise GameException(ConfigErrorMessage.get_error_id("SERVER_BUSY")) self.CD(self.server_id, self.char_id).set(GlobalConfig.value("LEADERBOARD_CHAT_INTERVAL"))
def equipment_destroy(self, slot_id, use_sycee): # 装备销毁 """ :rtype: ResourceClassification """ self._equipment_destroy_check(slot_id) this_slot = self.doc['slots'][slot_id] item_id = this_slot['item_id'] config = ConfigEquipmentNew.get(item_id) level = this_slot['level'] equip = Equipment.load_from_slot_data(this_slot) if use_sycee: if equip.is_special: min_level = 0 else: min_level = min(config.levels.keys()) if level == min_level: raise GameException(ConfigErrorMessage.get_error_id("EQUIPMENT_CANNOT_DESTROY_NO_LEVEL_UP")) diamond = GlobalConfig.value("EQUIPMENT_DESTROY_SYCEE") rf = ResourceClassification.classify([(money_text_to_item_id('diamond'), diamond)]) rf.check_exist(self.server_id, self.char_id) rf.remove(self.server_id, self.char_id) MongoBag.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'slots.{0}.level'.format(slot_id): 0 }} ) self.doc['slots'][slot_id]['level'] = 0 self.send_notify(slot_ids=[slot_id]) results = equip.get_destroy_back_items(is_normal_destroy=False) else: self.remove_by_slot_id(slot_id, 1) results = equip.get_destroy_back_items(is_normal_destroy=True) if config.renown: results.append((money_text_to_item_id('renown'), config.renown)) resource_classified = ResourceClassification.classify(results) resource_classified.add(self.server_id, self.char_id, message="Bag.equipment_destroy:{0}".format(item_id)) return resource_classified
def help(self, friend_id, building_id): friend_id = int(friend_id) if not FriendManager(self.server_id, self.char_id).check_friend_exist(friend_id): raise GameException(ConfigErrorMessage.get_error_id("FRIEND_NOT_OK")) if not self.get_remained_help_times(): raise GameException(ConfigErrorMessage.get_error_id("TERRITORY_NO_HELP_FRIEND_TIMES")) if not TerritoryFriend(self.server_id, friend_id).get_remained_got_help_times(): raise GameException(ConfigErrorMessage.get_error_id("TERRITORY_NO_GOT_HELP_TIMES")) t = Territory(self.server_id, friend_id) building = t.get_building_object(building_id, slots_ids=[]) event_id = building.event_id if not event_id: raise GameException(ConfigErrorMessage.get_error_id("TERRITORY_BUILDING_NO_EVENT")) MongoTerritory.db(self.server_id).update_one( {'_id': friend_id}, {'$set': { 'buildings.{0}.event_id'.format(building_id): 0 }} ) config = ConfigTerritoryEvent.get(event_id) if not config.npc: resource_classified = ResourceClassification.classify(config.reward_win) resource_classified.add(self.server_id, self.char_id, message="TerritoryFriend.help") # NOTE: 战斗要等到结算的时候再记录次数 ValueLogTerritoryHelpFriendTimes(self.server_id, self.char_id).record() self.send_remained_times_notify() Territory(self.server_id, friend_id).got_help(self.char_id, building_id, config.target_exp) return None, resource_classified npc_club = ConfigNPCFormation.get(config.npc) my_club = Club(self.server_id, self.char_id) f = Formation(self.server_id, self.char_id) match = ClubMatch(my_club, npc_club, 6, f.get_skill_sequence(), {}) msg = match.start() msg.key = "{0}:{1}:{2}".format(friend_id, building_id, event_id) msg.map_name = GlobalConfig.value_string("MATCH_MAP_TERRITORY_FRIEND") return msg, None
def send_notify(self): notify = ActivityPurchaseDailyNotify() if self.doc['count'] > 0: status = ACTIVITY_REWARD else: if Purchase(self.server_id, self.char_id).get_purchase_info_of_day_shift(): status = ACTIVITY_COMPLETE else: status = ACTIVITY_DOING notify.status = status item_id = GlobalConfig.value("PURCHASE_DAILY_REWARD_ITEM_ID") rc = ResourceClassification.classify(ConfigItemUse.get(item_id).using_result()) notify.items.MergeFrom(rc.make_protomsg()) MessagePipe(self.char_id).put(msg=notify)
def sweep(self): sweep_end_at = self.doc.get('sweep_end_at', 0) if sweep_end_at: raise GameException(ConfigErrorMessage.get_error_id("TOWER_ALREADY_IN_SWEEP")) levels_amount = self._sweep_check() end_at = arrow.utcnow().timestamp + levels_amount * GlobalConfig.value("TOWER_SWEEP_SECONDS_PER_LEVEL") self.doc['sweep_end_at'] = end_at MongoTower.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'sweep_end_at': end_at }} ) ValueLogTowerWinTimes(self.server_id, self.char_id).record(value=levels_amount) self.send_notify(act=ACT_UPDATE, levels=[])
def match_start(self, key, formation_slots=None): try: friend_id, building_id, event_id = key.split(':') friend_id = int(friend_id) building_id = int(building_id) event_id = int(event_id) except: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) f = Formation(self.server_id, self.char_id) if formation_slots: f.sync_slots(formation_slots) config = ConfigTerritoryEvent.get(event_id) npc_club = ConfigNPCFormation.get(config.npc) my_club = Club(self.server_id, self.char_id) match = ClubMatch(my_club, npc_club, 6, f.get_skill_sequence(), {}) msg = match.start() msg.key = "{0}:{1}:{2}".format(friend_id, building_id, event_id) msg.map_name = GlobalConfig.value_string("MATCH_MAP_TERRITORY_FRIEND") return msg
def match(self, formation_slots=None): doc = MongoArena.db(self.server_id).find_one( {'_id': str(self.char_id)}, {'rival': 1} ) rival_id = doc['rival'] if not rival_id: raise GameException(ConfigErrorMessage.get_error_id("ARENA_MATCH_NO_RIVAL")) f = Formation(self.server_id, self.char_id) if formation_slots: f.sync_slots(formation_slots) self.check_and_buy_times() club_one = Club(self.server_id, self.char_id) club_two = ArenaClub(self.server_id, rival_id) club_match = ClubMatch(club_one, club_two, 6, f.get_skill_sequence(), {}) msg = club_match.start() msg.key = rival_id msg.map_name = GlobalConfig.value_string("MATCH_MAP_ARENA") return msg
def __init__(self, server_id, char_id): self.server_id = server_id self.char_id = char_id self.is_active = Challenge(server_id, char_id).is_challenge_id_passed( GlobalConfig.value("PLUNDER_ACTIVE_CHALLENGE_ID")) self.doc = MongoPlunder.db(self.server_id).find_one({'_id': self.char_id}) if not self.doc: self.doc = MongoPlunder.document() self.doc['_id'] = self.char_id self.doc['plunder_remained_times'] = PLUNDER_TIMES_INIT_TIMES MongoPlunder.db(self.server_id).insert_one(self.doc) _, today_daily_reward_info = self.get_daily_reward_info() if not today_daily_reward_info: # 可以清理数据 self.doc['daily_reward'] = {} MongoPlunder.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': { 'daily_reward': {} }} )
def plunder_start(self, _id, tp, formation_slots=None, win=None): if tp not in [PLUNDER_TYPE_PLUNDER, PLUNDER_TYPE_REVENGE]: raise GameException(ConfigErrorMessage.get_error_id("BAD_MESSAGE")) for i in [0, 1, 2]: if self.doc['matching']['result'][i] == 0: way = i + 1 break else: # 都打完了 raise GameException(ConfigErrorMessage.get_error_id("PLUNDER_MATCH_ALL_FINISHED")) target_id = self.doc['matching']['id'] if not target_id: if tp == PLUNDER_TYPE_PLUNDER: _index = self.find_search_target_index_by_target_id(_id) target_id = self.doc['search'][_index]['id'] else: _index = self.find_revenge_target_index_by_target_id(_id) target_id = self.doc['revenge_list'][_index][0] else: # 要保证target_id 一样 if str(target_id) != _id: raise GameException(ConfigErrorMessage.get_error_id("PLUNDER_TARGET_ID_NOT_SAME")) updater = {} if not self.doc['matching']['id']: self.doc['matching']['id'] = target_id self.doc['matching']['tp'] = tp updater['matching.id'] = target_id updater['matching.tp'] = tp if way == 1: # 开始的第一路,这时候要判断次数 if tp == PLUNDER_TYPE_PLUNDER: if not self.doc['plunder_remained_times']: self.buy_plunder_times() PlunderMatchCD(self.server_id, self.char_id, target_id).set(GlobalConfig.value("PLUNDER_MATCH_CD")) else: if not self.get_revenge_remained_times(): raise GameException(ConfigErrorMessage.get_error_id("PLUNDER_REVENGE_NO_TIMES")) self.send_revenge_notify() if updater: MongoPlunder.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': updater} ) if win is not None: self.plunder_report(way, win) return None my_way = self.get_way_object(way) if formation_slots: my_way.sync_slots(formation_slots) my_way.load_formation_staffs() self.send_formation_notify() my_club = Club(self.server_id, self.char_id, load_staffs=False) my_club.formation_staffs = my_way.formation_staffs match = ClubMatch(my_club, None, 3, my_way.get_skill_sequence(), {}) msg = match.start(auto_load_staffs=False) msg.key = str(way) msg.map_name = GlobalConfig.value_string("MATCH_MAP_PLUNDER") return msg
@app.route('/fashion') def fashion_page(): return render_template('fashion.html') @app.route('/product/') def products(): products = json.loads(Product.objects.to_json()) result = dict(ok=True, result=products) return json.dumps(result) @app.route('/calendar') def calendar(): day_dico={0:"Monday",1:"Tuesday",2:"Wednesday",3:"Thursday",4:"Friday",5:"Saturday",6:"Sunday"} # if len(sys.argv) > 1: # config = GlobalConfig.from_json(sys.argv[1]) # database = mongoengine.connect(config.mongo_db) actuators = Actuator.objects() sensor_types = Sensor.__subclasses__() alarms=[{'name':ev.name,'minutes':ev.minutes, 'days':[day_dico[i] for i,day in enumerate([(ev.week_days_mask & (1 << i))!=0 for i in range(7)]) if day==True]} for ev in model.clock.Event.objects()] return render_template('clock.html', alarms = alarms , sensor_types=sensor_types, actuators=actuators) if __name__ == "__main__": if len(sys.argv) > 1: config = GlobalConfig.from_json(sys.argv[1]) db = mongoengine.connect(config.mongo_db) app.run(host="0.0.0.0", port=config.web_server.port, debug=True)
def report(self, key, win): rival_id = key my_rank = self.get_current_rank() my_max_rank = self.get_max_rank() doc = MongoArena.db(self.server_id).find_one( {'_id': str(self.char_id)}, { 'search_index': 1, 'continue_win': 1, } ) ArenaRefreshCD(self.server_id, self.char_id).clean() ArenaMatchCD(self.server_id, self.char_id, rival_id).set(GlobalConfig.value("ARENA_MATCH_CD")) config_search = ConfigArenaSearchRange.get(doc['search_index']) if win: score_changed = config_search.score_win new_search_index = doc['search_index'] + 1 continue_win = doc.get('continue_win', 0) + 1 else: score_changed = -config_search.score_lose new_search_index = doc['search_index'] - 1 continue_win = 0 if new_search_index > ConfigArenaSearchRange.MAX_INDEX: new_search_index = ConfigArenaSearchRange.MAX_INDEX if new_search_index < 0: new_search_index = 0 MongoArena.db(self.server_id).update_one( {'_id': str(self.char_id)}, { '$set': { 'search_index': new_search_index, 'rival': 0, 'continue_win': continue_win, }, '$inc': { 'match_times': 1, } } ) ass = ArenaScore(self.server_id, self.char_id) score_changed = ass.add_score(score_changed) new_rank = ass.rank max_rank_changed = False if new_rank > my_max_rank: my_max_rank = new_rank MongoArena.db(self.server_id).update_one( {'_id': str(self.char_id)}, {'$set': {'max_rank': new_rank}} ) max_rank_changed = True rank_changed = new_rank - my_rank rival_rank = Arena(self.server_id, rival_id).get_current_rank() if win: ValueLogArenaWinTimes(self.server_id, self.char_id).record() config_reward = ConfigArenaMatchReward.get(1) else: config_reward = ConfigArenaMatchReward.get(2) ValueLogArenaHonorPoints(self.server_id, self.char_id).record(value=config_reward.honor) ValueLogArenaMatchTimes(self.server_id, self.char_id).record() drop = config_reward.get_drop() resource_classified = ResourceClassification.classify(drop) resource_classified.add(self.server_id, self.char_id, message="Arena.report:{0}".format(win)) self.send_honor_notify() self.send_notify() arena_match_signal.send( sender=None, server_id=self.server_id, char_id=self.char_id, target_id=rival_id, target_name=ArenaClub(self.server_id, rival_id).name, my_rank=new_rank, target_rank=rival_rank, win=win, continue_win=continue_win, ) if max_rank_changed: task_condition_trig_signal.send( sender=None, server_id=self.server_id, char_id=self.char_id, condition_name='core.arena.Arena' ) WinningArena(self.server_id, self.char_id).set(win) return resource_classified, score_changed, -rank_changed, my_max_rank, new_rank, ass.score
def sweep_finish(self): # 加速或者领奖 都是这一个协议 start_level = self.get_current_level() sweep_end_at = self.doc.get('sweep_end_at', 0) if sweep_end_at == 0: # 没有扫荡过,直接 完成 levels_amount = self._sweep_check() else: # 已经扫荡了, 现在要加速完成 need_seconds = sweep_end_at - arrow.utcnow().timestamp if need_seconds <= 0: # 已经完成了, 直接领奖 levels_amount = 0 else: levels_amount, _remained = divmod(need_seconds, GlobalConfig.value("TOWER_SWEEP_SECONDS_PER_LEVEL")) if _remained: levels_amount += 1 if levels_amount: need_diamond = levels_amount * GlobalConfig.value("TOWER_SWEEP_DIAMOND_PER_LEVEL") resource_classified = ResourceClassification.classify([(money_text_to_item_id('diamond'), need_diamond)]) resource_classified.check_exist(self.server_id, self.char_id) resource_classified.remove(self.server_id, self.char_id, message="Tower.sweep_finish") drops = {} updater = {} for i in range(start_level, self.doc['max_star_level'] + 1): updater['levels.{0}'.format(i)] = 3 self.doc['levels'][str(i)] = 3 self.doc['current_star'] += 3 config = ConfigTowerLevel.get(i) drop = config.get_star_reward(3) for _id, _amount in drop: if _id in drops: drops[_id] += _amount else: drops[_id] = _amount turntable = config.get_turntable() if turntable: if self.doc['current_star'] >= 9: got = random.choice(turntable['9']) self.doc['talents'].append(got) self.doc['current_star'] -= 9 elif self.doc['current_star'] >= 6: got = random.choice(turntable['6']) self.doc['talents'].append(got) self.doc['current_star'] -= 6 elif self.doc['current_star'] >= 3: got = random.choice(turntable['3']) self.doc['talents'].append(got) self.doc['current_star'] -= 3 goods = config.get_sale_goods() if goods: self.doc['goods'].append([goods[0], 0]) self.doc['goods'].append([goods[1], 0]) self.doc['sweep_end_at'] = 0 updater['sweep_end_at'] = 0 updater['current_star'] = self.doc['current_star'] updater['talents'] = self.doc['talents'] updater['goods'] = self.doc['goods'] # 扫荡完下一关要可打 next_level = self.doc['max_star_level'] + 1 if next_level <= ConfigTowerLevel.MAX_LEVEL: self.doc['levels'][str(next_level)] = 0 updater['levels.{0}'.format(next_level)] = 0 self.set_today_max_star() total_star = self.get_total_current_star() if total_star > self.doc['history_max_star']: self.doc['history_max_star'] = total_star updater['history_max_star'] = total_star MongoTower.db(self.server_id).update_one( {'_id': self.char_id}, {'$set': updater} ) resource_classified = ResourceClassification.classify(drops.items()) resource_classified.add(self.server_id, self.char_id, message="Tower.sweep_finish") self.send_notify(act=ACT_UPDATE) self.send_goods_notify() return resource_classified
def loadFromConfig(self): self.oDirEdit.setText(GlobalConfig.instance().outputDir) self.ffmpegEdit.setText(GlobalConfig.instance().binPath)
def parseOptions(): parser = OptionParserEpilog(usage="virt-who [-d] [-i INTERVAL] [-o] [--sam|--satellite5|--satellite6] [--libvirt|--vdsm|--esx|--rhevm|--hyperv|--esx]", description="Agent for reporting virtual guest IDs to subscription manager", epilog="virt-who also reads enviroment variables. They have the same name as command line arguments but uppercased, with underscore instead of dash and prefixed with VIRTWHO_ (e.g. VIRTWHO_ONE_SHOT). Empty variables are considered as disabled, non-empty as enabled") parser.add_option("-d", "--debug", action="store_true", dest="debug", default=NotSetSentinel(), help="Enable debugging output") parser.add_option("-o", "--one-shot", action="store_true", dest="oneshot", default=NotSetSentinel(), help="Send the list of guest IDs and exit immediately") parser.add_option("-i", "--interval", type="int", dest="interval", default=NotSetSentinel(), help="Acquire list of virtual guest each N seconds. Send if changes are detected.") parser.add_option("-p", "--print", action="store_true", dest="print_", default=NotSetSentinel(), help="Print the host/guest association obtained from virtualization backend (implies oneshot)") parser.add_option("-c", "--config", action="append", dest="configs", default=[], help="Configuration file that will be processed, can be used multiple times") parser.add_option("-m", "--log-per-config", action="store_true", dest="log_per_config", default=NotSetSentinel(), help="Write one log file per configured virtualization backend.\nImplies a log_dir of %s/virtwho (Default: all messages are written to a single log file)" % log.DEFAULT_LOG_DIR) parser.add_option("-l", "--log-dir", action="store", dest="log_dir", default=log.DEFAULT_LOG_DIR, help="The absolute path of the directory to log to. (Default '%s')" % log.DEFAULT_LOG_DIR) parser.add_option("-f", "--log-file", action="store", dest="log_file", default=log.DEFAULT_LOG_FILE, help="The file name to write logs to. (Default '%s')" % log.DEFAULT_LOG_FILE) parser.add_option("-r", "--reporter-id", action="store", dest="reporter_id", default=NotSetSentinel(), help="Label host/guest associations obtained by this instance of virt-who with the provided id.") virtGroup = OptionGroup(parser, "Virtualization backend", "Choose virtualization backend that should be used to gather host/guest associations") virtGroup.add_option("--libvirt", action="store_const", dest="virtType", const="libvirt", default=None, help="Use libvirt to list virtual guests [default]") virtGroup.add_option("--vdsm", action="store_const", dest="virtType", const="vdsm", help="Use vdsm to list virtual guests") virtGroup.add_option("--esx", action="store_const", dest="virtType", const="esx", help="Register ESX machines using vCenter") virtGroup.add_option("--xen", action="store_const", dest="virtType", const="xen", help="Register XEN machines using XenServer") virtGroup.add_option("--rhevm", action="store_const", dest="virtType", const="rhevm", help="Register guests using RHEV-M") virtGroup.add_option("--hyperv", action="store_const", dest="virtType", const="hyperv", help="Register guests using Hyper-V") parser.add_option_group(virtGroup) managerGroup = OptionGroup(parser, "Subscription manager", "Choose where the host/guest associations should be reported") managerGroup.add_option("--sam", action="store_const", dest="smType", const=SAT6, default=SAT6, help="Report host/guest associations to the Subscription Asset Manager [default]") managerGroup.add_option("--satellite6", action="store_const", dest="smType", const=SAT6, help="Report host/guest associations to the Satellite 6 server") managerGroup.add_option("--satellite5", action="store_const", dest="smType", const=SAT5, help="Report host/guest associations to the Satellite 5 server") managerGroup.add_option("--satellite", action="store_const", dest="smType", const=SAT5, help=SUPPRESS_HELP) parser.add_option_group(managerGroup) libvirtGroup = OptionGroup(parser, "Libvirt options", "Use these options with --libvirt") libvirtGroup.add_option("--libvirt-owner", action="store", dest="owner", default="", help="Organization who has purchased subscriptions of the products, default is owner of current system") libvirtGroup.add_option("--libvirt-env", action="store", dest="env", default="", help="Environment where the server belongs to, default is environment of current system") libvirtGroup.add_option("--libvirt-server", action="store", dest="server", default="", help="URL of the libvirt server to connect to, default is empty for libvirt on local computer") libvirtGroup.add_option("--libvirt-username", action="store", dest="username", default="", help="Username for connecting to the libvirt daemon") libvirtGroup.add_option("--libvirt-password", action="store", dest="password", default="", help="Password for connecting to the libvirt daemon") parser.add_option_group(libvirtGroup) esxGroup = OptionGroup(parser, "vCenter/ESX options", "Use these options with --esx") esxGroup.add_option("--esx-owner", action="store", dest="owner", default="", help="Organization who has purchased subscriptions of the products") esxGroup.add_option("--esx-env", action="store", dest="env", default="", help="Environment where the vCenter server belongs to") esxGroup.add_option("--esx-server", action="store", dest="server", default="", help="URL of the vCenter server to connect to") esxGroup.add_option("--esx-username", action="store", dest="username", default="", help="Username for connecting to vCenter") esxGroup.add_option("--esx-password", action="store", dest="password", default="", help="Password for connecting to vCenter") parser.add_option_group(esxGroup) rhevmGroup = OptionGroup(parser, "RHEV-M options", "Use these options with --rhevm") rhevmGroup.add_option("--rhevm-owner", action="store", dest="owner", default="", help="Organization who has purchased subscriptions of the products") rhevmGroup.add_option("--rhevm-env", action="store", dest="env", default="", help="Environment where the RHEV-M belongs to") rhevmGroup.add_option("--rhevm-server", action="store", dest="server", default="", help="URL of the RHEV-M server to connect to (preferable use secure connection - https://<ip or domain name>:<secure port, usually 8443>)") rhevmGroup.add_option("--rhevm-username", action="store", dest="username", default="", help="Username for connecting to RHEV-M in the format username@domain") rhevmGroup.add_option("--rhevm-password", action="store", dest="password", default="", help="Password for connecting to RHEV-M") parser.add_option_group(rhevmGroup) hypervGroup = OptionGroup(parser, "Hyper-V options", "Use these options with --hyperv") hypervGroup.add_option("--hyperv-owner", action="store", dest="owner", default="", help="Organization who has purchased subscriptions of the products") hypervGroup.add_option("--hyperv-env", action="store", dest="env", default="", help="Environment where the Hyper-V belongs to") hypervGroup.add_option("--hyperv-server", action="store", dest="server", default="", help="URL of the Hyper-V server to connect to") hypervGroup.add_option("--hyperv-username", action="store", dest="username", default="", help="Username for connecting to Hyper-V") hypervGroup.add_option("--hyperv-password", action="store", dest="password", default="", help="Password for connecting to Hyper-V") parser.add_option_group(hypervGroup) satelliteGroup = OptionGroup(parser, "Satellite 5 options", "Use these options with --satellite5") satelliteGroup.add_option("--satellite-server", action="store", dest="sat_server", default="", help="Satellite server URL") satelliteGroup.add_option("--satellite-username", action="store", dest="sat_username", default="", help="Username for connecting to Satellite server") satelliteGroup.add_option("--satellite-password", action="store", dest="sat_password", default="", help="Password for connecting to Satellite server") parser.add_option_group(satelliteGroup) (cli_options, args) = parser.parse_args() options = GlobalConfig.fromFile(config.VIRTWHO_GENERAL_CONF_PATH) # Handle defaults from the command line options parser options.update(**parser.defaults) # Handle enviroment variables env = os.getenv("VIRTWHO_LOG_PER_CONFIG", "0").strip().lower() if env in ["1", "true"]: options.log_per_config = True env = os.getenv("VIRTWHO_LOG_DIR", log.DEFAULT_LOG_DIR).strip() if env != log.DEFAULT_LOG_DIR: options.log_dir = env elif options.log_per_config: options.log_dir = os.path.join(log.DEFAULT_LOG_DIR, 'virtwho') env = os.getenv("VIRTWHO_LOG_FILE", log.DEFAULT_LOG_FILE).strip() if env != log.DEFAULT_LOG_FILE: options.log_file = env env = os.getenv("VIRTWHO_REPORTER_ID", "").strip() if len(env) > 0: options.reporter_id = env env = os.getenv("VIRTWHO_DEBUG", "0").strip().lower() if env in ["1", "true"] or cli_options.debug is True: options.debug = True # Used only when starting as service (initscript sets it to 1, systemd to 0) env = os.getenv("VIRTWHO_BACKGROUND", "0").strip().lower() if env in ["1", "true"]: options.background = True log.init(options) logger = log.getLogger(name='init', queue=False) env = os.getenv("VIRTWHO_ONE_SHOT", "0").strip().lower() if env in ["1", "true"]: options.oneshot = True if options.print_: options.oneshot = True env = os.getenv("VIRTWHO_INTERVAL") if env: env = env.strip().lower() try: if env and int(env) >= MinimumSendInterval: options.interval = int(env) except ValueError: logger.warning("Interval is not number, ignoring") env = os.getenv("VIRTWHO_SAM", "0").strip().lower() if env in ["1", "true"]: options.smType = SAT6 env = os.getenv("VIRTWHO_SATELLITE6", "0").strip().lower() if env in ["1", "true"]: options.smType = SAT6 env = os.getenv("VIRTWHO_SATELLITE5", "0").strip().lower() if env in ["1", "true"]: options.smType = SAT5 env = os.getenv("VIRTWHO_SATELLITE", "0").strip().lower() if env in ["1", "true"]: options.smType = SAT5 env = os.getenv("VIRTWHO_LIBVIRT", "0").strip().lower() if env in ["1", "true"]: options.virtType = "libvirt" env = os.getenv("VIRTWHO_VDSM", "0").strip().lower() if env in ["1", "true"]: options.virtType = "vdsm" env = os.getenv("VIRTWHO_ESX", "0").strip().lower() if env in ["1", "true"]: options.virtType = "esx" env = os.getenv("VIRTWHO_XEN", "0").strip().lower() if env in ["1", "true"]: options.virtType = "xen" env = os.getenv("VIRTWHO_RHEVM", "0").strip().lower() if env in ["1", "true"]: options.virtType = "rhevm" env = os.getenv("VIRTWHO_HYPERV", "0").strip().lower() if env in ["1", "true"]: options.virtType = "hyperv" def getNonDefaultOptions(cli_options, defaults): return dict((option, value) for option, value in cli_options.iteritems() if defaults.get(option, NotSetSentinel()) != value) # Handle non-default command line options options.update(**getNonDefaultOptions(vars(cli_options), parser.defaults)) # Check Env def checkEnv(variable, option, name, required=True): """ If `option` is empty, check enviroment `variable` and return its value. Exit if it's still empty """ if not option or len(option) == 0: option = os.getenv(variable, "").strip() if required and (not option or len(option) == 0): raise OptionError("Required parameter '%s' is not set, exiting" % name) return option if options.smType == SAT5: options.sat_server = checkEnv("VIRTWHO_SATELLITE_SERVER", options.sat_server, "satellite-server") options.sat_username = checkEnv("VIRTWHO_SATELLITE_USERNAME", options.sat_username, "satellite-username") if len(options.sat_password) == 0: options.sat_password = os.getenv("VIRTWHO_SATELLITE_PASSWORD", "") if options.virtType == "libvirt": options.owner = checkEnv("VIRTWHO_LIBVIRT_OWNER", options.owner, "owner", required=False) options.env = checkEnv("VIRTWHO_LIBVIRT_ENV", options.env, "env", required=False) options.server = checkEnv("VIRTWHO_LIBVIRT_SERVER", options.server, "server", required=False) options.username = checkEnv("VIRTWHO_LIBVIRT_USERNAME", options.username, "username", required=False) if len(options.password) == 0: options.password = os.getenv("VIRTWHO_LIBVIRT_PASSWORD", "") if options.virtType == "esx": options.owner = checkEnv("VIRTWHO_ESX_OWNER", options.owner, "owner", required=False) options.env = checkEnv("VIRTWHO_ESX_ENV", options.env, "env", required=False) options.server = checkEnv("VIRTWHO_ESX_SERVER", options.server, "server") options.username = checkEnv("VIRTWHO_ESX_USERNAME", options.username, "username") if len(options.password) == 0: options.password = os.getenv("VIRTWHO_ESX_PASSWORD", "") if options.virtType == "xen": options.owner = checkEnv("VIRTWHO_XEN_OWNER", options.owner, "owner", required=False) options.env = checkEnv("VIRTWHO_XEN_ENV", options.env, "env", required=False) options.server = checkEnv("VIRTWHO_XEN_SERVER", options.server, "server") options.username = checkEnv("VIRTWHO_XEN_USERNAME", options.username, "username") if len(options.password) == 0: options.password = os.getenv("VIRTWHO_XEN_PASSWORD", "") if options.virtType == "rhevm": options.owner = checkEnv("VIRTWHO_RHEVM_OWNER", options.owner, "owner", required=False) options.env = checkEnv("VIRTWHO_RHEVM_ENV", options.env, "env", required=False) options.server = checkEnv("VIRTWHO_RHEVM_SERVER", options.server, "server") options.username = checkEnv("VIRTWHO_RHEVM_USERNAME", options.username, "username") if len(options.password) == 0: options.password = os.getenv("VIRTWHO_RHEVM_PASSWORD", "") if options.virtType == "hyperv": options.owner = checkEnv("VIRTWHO_HYPERV_OWNER", options.owner, "owner", required=False) options.env = checkEnv("VIRTWHO_HYPERV_ENV", options.env, "env", required=False) options.server = checkEnv("VIRTWHO_HYPERV_SERVER", options.server, "server") options.username = checkEnv("VIRTWHO_HYPERV_USERNAME", options.username, "username") if len(options.password) == 0: options.password = os.getenv("VIRTWHO_HYPERV_PASSWORD", "") if options.smType == 'sam' and options.virtType in ('esx', 'rhevm', 'hyperv'): if not options.owner: raise OptionError("Option --%s-owner (or VIRTWHO_%s_OWNER environment variable) needs to be set" % (options.virtType, options.virtType.upper())) if not options.env: raise OptionError("Option --%s-env (or VIRTWHO_%s_ENV environment variable) needs to be set" % (options.virtType, options.virtType.upper())) if options.background and options.oneshot: logger.error("Background and oneshot can't be used together, using background mode") options.oneshot = False if options.interval < MinimumSendInterval: if not options.interval or options.interval == parser.defaults['interval']: logger.info("Interval set to the default of %s seconds." % str(DefaultInterval)) else: logger.warning("Interval value may not be set below the default of %s seconds. Will use default value." % str(MinimumSendInterval)) options.interval = MinimumSendInterval logger.info("Using reporter_id='%s'" % options.reporter_id) return (logger, options)
self.generate_location(name="Villeurbanne, France", lat=45.771944, lon=4.8901709) #generate alarms self.generate_alarm("Work", 6,42,[0,1,2,3,4]) self.generate_alarm("Music lesson", 17,29,[4]) self.generate_alarm("GHome presentation", 8,10,[2]) # generating a phone phone = Phone(device_id=112233445566, name="Twilio Phone") phone.save() def generate_rooms(self): Room(x=-2.5, y=-2.5, width=5, height=5).save() Room(x=+2.5, y=-2.5, width=5, height=4).save() @property def unique_id(self): self.id += 1 return self.id if __name__ == '__main__': configuration = GlobalConfig() if len(sys.argv) > 1 and sys.argv[1] != 'fashion': configuration = GlobalConfig.from_json(sys.argv[1]) g = Generator(configuration) if 'fashion' in sys.argv: fetch_fashion()