def set_between_dates_filter(self, key, *args, **kwargs): """Sets filter that checks if key field is between two dates given dates. The date comparators must be passed by the args compare_date_time_one and compare_date_time_two. An other modfier can be the arg not_between.""" try: if ('compare_date_time_one' in kwargs and 'compare_date_time_two' in kwargs and kwargs['compare_date_time_one'] and kwargs['compare_date_time_two']): date_time_one = Helper().get_date_from_string( kwargs['compare_date_time_one']) date_time_two = Helper().get_date_from_string( kwargs['compare_date_time_two']) if ('not_between' in kwargs and kwargs['not_between'] == '1'): self.filter += (not_( self.get_context_attr(key, kwargs).between( date_time_one, date_time_two)), ) else: self.filter += (self.get_context_attr(key, kwargs).between( date_time_one, date_time_two), ) except Exception as e: raise Exception(str(e))
def run(self, ctx): print("Running Script " + self.__class__.__name__) engctx = ctx.getEnginesContext() if not engctx: print('Back-end engines not initialized') return projects = engctx.getProjects() if not projects: print('There is no opened project') return prj = projects[0] helper = Helper(prj) print("exported".center(15, ' ').center(60, '-')) exported = helper.getComponentClasses(Helper.COMPONENT_SERVICE, True) for s in exported: print(s.getAddress()) print("unexported".center(15, ' ').center(60, '-')) unexported = helper.getComponentClasses(Helper.COMPONENT_SERVICE, False) for s in unexported: print(s.getAddress()) print("total %d services, %d exported" % (len(exported) + len(unexported), len(exported)))
def process(session, data): post = Post() Helper().fill_object_from_data(post, data, ['name', 'title', 'description', 'status', 'is_protected', 'has_comments']) post.publish_on = Helper().get_null_if_empty(data['publish_on']) post.expire_on = Helper().get_null_if_empty(data['expire_on']) post.created = Helper().get_current_datetime() post.edited = Helper().get_current_datetime() self.add_foreign_keys(post, data, session, [('parent_id', Post), ('post_type_id', PostType), ('language_id', Language), ('user_id', User)]) self.raise_if_has_term_and_not_is_post_page(data, session) self.add_many_to_many_relationship('terms', post, data, Term, session) session.add(post) session.commit() return self.handle_success(None, None, 'create', 'Post', post.id)
def fn(session, post): Helper().fill_object_from_data(post, data, ['name', 'title', 'description', 'status', 'is_protected', 'has_comments']) post.publish_on = Helper().get_null_if_empty(data['publish_on']) post.expire_on = Helper().get_null_if_empty(data['expire_on']) post.edited = Helper().get_current_datetime() self.add_foreign_keys(post, data, session, [('parent_id', Post), ('post_type_id', PostType), ('language_id', Language), ('user_id', User)]) self.raise_if_has_term_and_not_is_post_page(data, session) self.edit_many_to_many_relationship('terms', post, data, Term, session) if post.parent_id and int(post.parent_id) == int(id): raise BadRequestError('The Post cannot be parent of yourself.') session.commit() return self.handle_success(None, None, 'update', 'Post', post.id)
def valid_file_type(self, key, config): """Validates if the field has valid base64 mimetype.""" if ('valid_file_type' in config and key in self.request and self.request[key] != ''): try: file_type_data = Helper().get_file_type_and_data( self.request[key]) file_type = file_type_data[0] valid_types = Helper().get_valid_mimetypes() if (file_type not in valid_types): self.handle_validation_error('Invalid file type.') except Exception as e: self.handle_validation_error(str(e))
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(TemplateController, self).__init__() self.args = Helper().add_request_data(self.parser, ['s', 'get_post_types']) self.repo = TemplateRepository(session=self.session)
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(MediaController, self).__init__() self.args = Helper().add_request_data(self.parser, [ 'download_file', 'return_file_data', 's', 'type', 'origin', 'created', 'user_id', 'get_user']) self.repo = MediaRepository(session=self.session)
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(BlacklistController, self).__init__() self.args = Helper().add_request_data(self.parser, ['value', 'type', 'target']) self.repo = BlacklistRepository(session=self.session)
def test_Helper_get_file_details_from_request(self): data = { 'file': self.file_b64 } payload = base64.b64decode('iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==') response = Helper().get_file_details_from_request(data)['data'] self.assertEqual(payload, response, 'Helper().get_file_details_from_request does not match the binary data.')
def update(self, id, request): """Updates the row whose id corresponding with the requested id. The data comes from the request object.""" def process(session, data): def fn(session, term): Helper().fill_object_from_data(term, data, [ 'name', 'display_name', 'description', 'parent_id', 'page_id', 'taxonomy_id', 'language_id' ]) self.add_foreign_keys(term, data, session, [('parent_id', Term), ('page_id', Post), ('language_id', Language), ('taxonomy_id', Taxonomy)]) if term.parent_id and int(term.parent_id) == int(id): raise BadRequestError( 'The Term cannot be parent of yourself.') session.commit() return self.handle_success(None, None, 'update', 'Term', term.id) return self.run_if_exists(fn, Term, id, session) return self.validate_before(process, Helper().get_with_slug( request.get_json(), 'name'), TermValidator, self.session, id=id)
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(FieldFileController, self).__init__() self.args = Helper().add_request_data( self.parser, ['field_id', 'media_id', 'grouper_id', 'post_id']) self.repo = FieldFileRepository(session=self.session)
def set_range_of_dates_filter(self, *args, **kwargs): """Sets filter that get items whose current date fit with publish_on and expire_on dates.""" try: today = Helper().get_current_datetime() exp_kwargs = kwargs if 'joined_key' in kwargs: exp_kwargs = { 'joined': kwargs['joined'], 'joined_key': 'expire_on' } self.filter += (or_( and_( self.get_context_attr('publish_on', kwargs) <= today, self.get_context_attr('expire_on', exp_kwargs) >= today, ), or_( self.get_context_attr('publish_on', kwargs) == None, self.get_context_attr('expire_on', exp_kwargs) == None), ), ) except Exception as e: raise Exception(str(e))
def test_Helper_get_with_slug(self): data = { 'name': 'JOão Caçou a RÃ à noite' } payload = 'joao-cacou-a-ra-a-noite' response = Helper().get_with_slug(data, 'name')['name'] self.assertEqual(payload, response, 'Helper().get_with_slug does not return \'joao-cacou-a-ra-a-noite\'.')
def process(session, data): role = Role() Helper().fill_object_from_data(role, data, ['name', 'description', 'can_access_admin']) self.add_many_to_many_relationship('capabilities', role, data, Capability, session) session.add(role) session.commit() return self.handle_success(None, None, 'create', 'Role', role.id)
def process(session, data): field_content = FieldContent() Helper().fill_object_from_data(field_content, data, ['content']) self.raise_if_has_different_parent_reference(data, session, [('field_id', 'grouper_id', Field), ('field_id', 'post_id', Field)]) self.add_foreign_keys_field_type('long-text', field_content, data, session, [('field_id', Field), ('grouper_id', Grouper), ('post_id', Post)]) session.add(field_content) session.commit() return self.handle_success(None, None, 'create', 'FieldContent', field_content.id)
def process(session, data): taxonomy = Taxonomy() Helper().fill_object_from_data( taxonomy, data, ['name', 'description', 'has_child']) session.add(taxonomy) session.commit() return self.handle_success(None, None, 'create', 'Taxonomy', taxonomy.id)
def load_data(self, file_list: list, max_len=None): # 对出现过的单词进行onehot编码,并形成字典 for idx, file in enumerate(file_list): self.personDictionary.addPerson(idx, file) label = [0] * len(file_list) label[idx] = 1 self.one_hot(file, label) # 将字典保存 self.save_dict() # 计算原始数据长度的均值和方差 count = [len(x) for x in self.X] mean, var = Helper.analysis(count) Helper.debug("[INFORMATION] MEAN: %f\tVAR: %f" % (mean, var)) # 对每个句子进行pad操作 self.pad_sequences(max_len, 0) Helper.debug("[SUCCESS] Load data from file") return np.array(self.X), np.array(self.Y)
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(PostTypeController, self).__init__() self.args = Helper().add_request_data( self.parser, ['name', 'type', 'get_template', 'get_nests', 'get_taxonomies']) self.repo = PostTypeRepository(session=self.session)
def process(session, data): template = Template() Helper().fill_object_from_data(template, data, ['name', 'description', 'value']) session.add(template) session.commit() return self.handle_success(None, None, 'create', 'Template', template.id)
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(CommentController, self).__init__() self.args = Helper().add_request_data(self.parser, [ 'comment', 'status', 'origin_ip', 'origin_agent', 'created', 'parent_id', 'user_id', 'post_id', 'language_id', 'get_user', 'get_language', 'get_post', 'get_parent', 'get_children']) self.repo = CommentRepository(session=self.session)
def process(session, data): sector = Sector() Helper().fill_object_from_data(sector, data, ['name', 'description']) session.add(sector) session.commit() return self.handle_success(None, None, 'create', 'Sector', sector.id)
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(SocialController, self).__init__() self.args = Helper().add_request_data( self.parser, ['name', 'origin', 'user_id', 'get_user', 'get_configuration']) self.repo = SocialRepository(session=self.session)
def process(session, data): comment = Comment() Helper().fill_object_from_data( comment, data, ['comment', 'status', 'origin_ip', 'origin_agent']) comment.created = Helper().get_current_datetime() self.raise_if_has_different_parent_reference( data, session, [('parent_id', 'post_id', Comment), ('parent_id', 'language_id', Comment)]) self.add_foreign_keys(comment, data, session, [('user_id', User), ('post_id', Post), ('language_id', Language), ('parent_id', Comment)]) session.add(comment) session.commit() return self.handle_success(None, None, 'create', 'Comment', comment.id)
def valid_file_extension(self, key, config): """Validates if the field has valid file extension.""" if ('valid_file_extension' in config and key in self.request and self.request[key] != ''): extensions = Helper().get_valid_extensions() if (self.request[key] not in extensions): self.handle_validation_error('Invalid file extension.')
def int_words(words): with open('../Model/wordDictionary.pkl', 'rb') as file: one_hot_dict = pickle.load(file).one_hot_dict str_words = Helper.splitSentence(words) int_words = [] dismiss_cnt = 0 total_cnt = 0 for word in str_words: total_cnt += 1 if word not in one_hot_dict: int_words.append(0) dismiss_cnt += 1 else: int_words.append(one_hot_dict[word]) int_words = pad_sequence(int_words, Meta.max_string_len) Helper.debug('[WARNING] dismiss: %d\ttotal: %d' % (dismiss_cnt, total_cnt)) return int_words
def one_hot(self, filename, label): with open(filename, "r", encoding='utf-8') as f: reader = csv.DictReader(f) for row in reader: words = Helper.splitSentence(row['text']) features = [] for word in words: # 去除标点符号 # word = word.strip(string.punctuation) if 'http' in word: continue if self.wordDictionary.isFull(): Helper.debug("[WARNING] Missing word:" + word) continue features.append(self.wordDictionary.lookup(word)) self.X.append(features) self.Y.append(label) Helper.debug("[INFORMATION] Total One Hot: %d" % self.wordDictionary.count())
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(GrouperController, self).__init__() self.args = Helper().add_request_data(self.parser, [ 's', 'parent_id', 'post_id', 'get_parent', 'get_children', 'get_post', 'get_fields' ]) self.repo = GrouperRepository(session=self.session)
def max_file_size(self, key, config): """Validates if the field has valid base64 size.""" if ('max_file_size' in config and key in self.request and self.request[key] != ''): if (int(Helper().get_base64_size(self.request[key])) > int( app.config['MAX_UPLOAD_SIZE'])): self.handle_validation_error( 'The file size cannot exceed 5 MB.')
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(MenuItemController, self).__init__() self.args = Helper().add_request_data(self.parser, [ 'type', 'behavior', 'url', 'title', 'parent_id', 'menu_id', 'get_menu', 'get_parent', 'get_children' ]) self.repo = MenuItemRepository(session=self.session)
def fn(session, configuration): Helper().fill_object_from_data( configuration, data, ['title', 'description', 'has_comments', 'email']) self.add_foreign_keys(configuration, data, session, [('language_id', Language)]) session.commit() return self.handle_success(None, None, 'update', 'Configuration', configuration.id)
def __init__(self): """Starts the repository from which data will be written or retrieved.""" super(TermController, self).__init__() self.args = Helper().add_request_data(self.parser, [ 's', 'parent_id', 'taxonomy_id', 'language_id', 'get_language', 'get_parent', 'get_children', 'get_taxonomy' ]) self.repo = TermRepository(session=self.session)