def field_does_not_exist(field: str, empty_value=None, is_list=False) -> Q: """ Creates a query object used for finding a field that doesn't exist, or has None or an empty value. :param field: Field name :param empty_value: The empty value to test for (None means no specific empty value will be used) :param is_list: Is this a list (array) field. In this case, instead of testing for an empty value, the length of the array will be used (len==0 means empty) :return: """ query = (Q(**{f"{field}__exists": False}) | Q(**{f"{field}__in": {empty_value, None}})) if is_list: query |= Q(**{f"{field}__size": 0}) return query
def check_duplicate_strategy(qr): if isinstance(qr, QR): try: cursor = QR.objects( Q(stock_number=qr.stock_number) & Q(strategy_name=qr.strategy_name) & Q(date=qr.date)) except Exception as e: logging.error( 'Error when check dupliate %s strategy %s date %s: %s' % (qr.stock_number, qr.strategy_name, qr.date, e)) if cursor: return True else: return False
def get_read_later(user_id): """ 获取待读列表下的所有文献 """ try: lib_query = Library.objects(Q(lib_name="待读列表") & Q(owner_id=user_id)).first() j, c = get_docs_in_lib(user_id=user_id, lib_id=lib_query.id, lib_type=0) return j, c except Exception as e: print(str(e)) return '', 403
def node_stats(pub_key: str): pub_key = crypto.bytes_to_hex_str_0x(crypto.hex_str_to_bytes(pub_key)) node = zilnode.ZilNode.get_by_pub_key(pub_key, authorized=None) if node: working_q = Q(expire_time__gte=datetime.utcnow()) & Q(finished=False) latest_works = pow.PowWork.get_node_works(pub_key=node.pub_key, count=6) return { "pub_key": node.pub_key, "pow_fee": node.pow_fee, "authorized": node.authorized, "latest_works": latest_works, "works": node.works_stats(), }
def start_quant_analysis(**kwargs): if not kwargs.get('qr_date'): print('no qr_date') return if not kwargs.get('quant_stock'): print('not quant_stock funtion') return if not SDT.objects(date=kwargs['qr_date']) and not kwargs.get('real_time'): print('Not a Trading Date') return try: all_stocks = StockInfo.objects() except Exception as e: logging.error('Error when query StockInfo:' + str(e)) raise e stocks_count = all_stocks.count() skip = 0 quant_res = [] while skip < stocks_count: try: stocks = StockInfo.objects().skip(skip).limit(query_step) except Exception as e: logging.error('Error when query skip %s StockInfo:%s' % (skip, e)) stocks = [] for i in stocks: if i.account_firm and u'瑞华会计师' in i.account_firm: # 过滤瑞华的客户 continue if not kwargs.get('real_time') and\ not SDT.objects(Q(date=kwargs['qr_date']) & Q(stock_number=i.stock_number)): continue qr = '' kwargs['industry_involved'] = i.industry_involved try: qr = kwargs['quant_stock'](i.stock_number, i.stock_name, **kwargs) except Exception as e: logging.error('Error when quant %s ma strategy: %s' % (i.stock_number, e)) if isinstance(qr, QR): quant_res.append(qr) skip += query_step return quant_res
def view_messages(username, viewPage=1): form = PrivateMessageForm() formModalMessage = PrivateMessageForm() fromUser = User.objects.get(username=session.get('username')) fetchNotifications(fromUser) toUser = User.objects.get(username=username) privateMessagesList = PrivateMessage.objects.filter( Q(fromUser=fromUser, toUser=toUser) | Q(fromUser=toUser, toUser=fromUser)).order_by('createDate') if '/page' not in request.path: tempList = privateMessagesList.paginate(page=1, per_page=5) viewPage = tempList.pages viewPage = int(viewPage) if viewPage == 0: viewPage = 1 print(viewPage) privateMessagesList = privateMessagesList.paginate(page=viewPage, per_page=5) print(privateMessagesList.page) notification = Notification.objects.filter( fromUser=toUser.username, toUser=fromUser.username).first() if notification != None: nlist = session.get('notifications') nlist.remove(notification) session['notifications'] = nlist notification.delete() return render_template('feed/private_message.html', form=form, user=fromUser, toUser=toUser, privateMessages=privateMessagesList, formModalMessage=formModalMessage)
def pre_sdt_check(stock_number, **kwargs): """ 依据量价进行预先筛选 :param stock_number: :param qr_date: :return: """ qr_date = kwargs.get('qr_date') if kwargs.get('week_long', False): short_ma = 5 long_ma = 10 if not is_week_long(stock_number, qr_date, short_ma, long_ma): return False rate_value = 0 cursor = SDT.objects(Q(stock_number=stock_number) & Q(today_closing_price__ne=0.0) & Q(date__lte=qr_date))\ .order_by('-date') if not cursor: return False today_sdt = cursor[0] today_closing_price = today_sdt.today_closing_price if today_sdt.year_ma: year_ma = today_sdt.year_ma else: year_ma = cal_year_ma(cursor) try: today_sdt.year_ma = year_ma today_sdt.save() except Exception: pass if today_closing_price >= year_ma: rate_value += 1 max_trade_amount = 2000 avg_trade_amount = 1000 amount_avg_num = 5 amount_sdt = cursor[:amount_avg_num] if cal_turnover_ma(cursor, amount_avg_num) >= avg_trade_amount or\ max([i.turnover_amount for i in amount_sdt]) >= max_trade_amount: rate_value += 1 if rate_value: return True else: return False
def srsmm(): query = Q(cohort__icontains='computer') & Q(grade__gt=11) srs = User.objects(query) seniors = [[ 'Name', 'otemail', 'pemails', 'Shirt Size', 'Personal Email', 'Mobile', 'PostGrad', 'Address' ]] for sr in srs: senior = [] if sr.adults: aemails = "" for adult in sr.adults: if adult.email: aemails += f";{adult.email}" srname = "" senior.append(f"{sr.fname} {sr.lname}") if sr.personalemail: senior.append( f"{sr.otemail};{sr.personalemail},{sr.aadultemail};{aemails}") else: senior.append(f"{sr.otemail},{sr.aadultemail};{aemails}") if not sr.shirtsize: senior.append("No Shirt Size") else: senior.append(sr.shirtsize) if not sr.personalemail: senior.append("No Personal Email") else: senior.append(sr.personalemail) if not sr.mobile: senior.append("No Mobile Phone") else: senior.append(formatphone(sr.mobile)) if not sr.postgrads: senior.append("No PostGrad Info") else: senior.append(f"{sr.postgrads[0].type_}: {sr.postgrads[0].org}") if not sr.ustreet: senior.append("No Address Info") else: senior.append( f"{sr.ustreet} | {sr.ucity} | {sr.ustate} | {sr.uzipcode}") seniors.append(senior) return render_template('array.html', array=seniors, nested=True)
def _resolve_entities( cls, experiments: Sequence[str] = None, projects: Sequence[str] = None, task_statuses: Sequence[str] = None, ) -> Dict[Type[mongoengine.Document], Set[mongoengine.Document]]: entities = defaultdict(set) if projects: print("Reading projects...") entities[cls.project_cls].update( cls._resolve_type(cls.project_cls, projects)) print("--> Reading project experiments...") query = Q( project__in=list( set(filter(None, (p.id for p in entities[cls.project_cls])))), system_tags__nin=[EntityVisibility.archived.value], ) if task_statuses: query &= Q(status__in=list(set(task_statuses))) objs = cls.task_cls.objects(query) entities[cls.task_cls].update(o for o in objs if o.id not in (experiments or [])) if experiments: print("Reading experiments...") entities[cls.task_cls].update( cls._resolve_type(cls.task_cls, experiments)) print("--> Reading experiments projects...") objs = cls.project_cls.objects(id__in=list( set(filter(None, (p.project for p in entities[cls.task_cls]))))) project_ids = {p.id for p in entities[cls.project_cls]} entities[cls.project_cls].update(o for o in objs if o.id not in project_ids) model_ids = { model_id for task in entities[cls.task_cls] for model_id in (task.output.model, task.execution.model) if model_id } if model_ids: print("Reading models...") entities[cls.model_cls] = set( cls.model_cls.objects(id__in=list(model_ids))) return entities
def get_data_repositories(cls): """ Return a list of Data Repository objects :return: """ repo_lst = list() for obj in cls.__subclasses__(): for ob in obj.objects.filter( Q(repo_type='data') | Q(is_internal=True)): """ We need to filter syslog repo because they are dealed as "File" repo """ if isinstance(ob, SyslogRepository): continue else: repo_lst.append(ob) return repo_lst
def mostrarPantallaCuracionBibliografica(): conectarBd() papers = Paper.objects( Q(inclusion1=True) & Q(inclusion2=True) & Q(bibliographyIsLoaded__exists=False)) count_papers = len(papers) if count_papers > 0: st.success("Se encontraron disponibles " + str(count_papers) + " papers para cargar.") st.markdown("## ¿Desea realizar la carga ahora?") cargar = st.button("Cargar") if cargar: automatizarCarga(papers) else: st.error("No hay papers disponibles para cargar en este momento.")
def upsert_session_level_attentiveness(observed_at, session, param): # print(observed_at, session, param) sp = SessionPulse.objects( Q(session=session) & Q(datetime_sequence=observed_at)) if not sp: sp_obj = SessionPulse() sp_obj.session = session sp_obj.datetime_sequence = observed_at sp_obj.attentiveness = param sp_obj.save() else: sp_obj = sp.first() sp_obj.attentiveness = param sp_obj.save()
def search(self, query, show_catalog, trending): show_catalog_param = self.get_show_catalog(show_catalog) trending_param = self.get_trending(trending) filter = Q() if trending_param is not None: filter = filter & Q(trending=trending_param) if show_catalog_param is not None: filter = filter & Q(show_catalog=show_catalog_param) if query is not None: filter = filter & (Q(name__icontains=query) | Q(short_description__icontains=query) | Q(long_description__icontains=query)) return Product.objects(filter)
def quote_price(self, order_id): order = order_repository.get_order(order_id) total = 0 rules_to_apply = self.rule_repository.active_sorted_by_value()\ .filter( (Q(benefit=user_service.is_premium(order.owner)) & Q(redeemable=False)) | (Q(redeemable=True) & Q(redeemed_by__in=[order.owner])) ) for rule in rules_to_apply: result = self.condition_service.apply(order, *rule.conditions) if result: total = self.consequence_service.apply(rule.consequence, total, order) return total if total > 0 else 0
def get(self): keyword = request.args.get('keyword') if keyword: # find data where *any of the fields contain the term... data = models.Post.objects.filter( Q(title__icontains=keyword) | Q(content__icontains=keyword) | Q(author__icontains=keyword) ) else: data = models.Post.objects # formatting the output JSON data = self.queryset_to_serialized_list(data) return Response(json.dumps(data), mimetype="application/json", status=200)
def upsert_session_level_engagement(observed_at, session_id, param): # print(observed_at, session_id, param) sp = SessionPulse.objects( Q(session_id=session_id) & Q(observed_at=observed_at)) if not sp: sp_obj = SessionPulse() sp_obj.session_id = session_id sp_obj.observed_at = observed_at sp_obj.engagement = param sp_obj.save() else: sp_obj = sp.first() sp_obj.engagement = param sp_obj.save()
def _get_user_messages(user, num_of_msg_to_return=10): """_get_user_messages(user_obj, int) -> mongoengine query object A function that when called returns all the messages belonging to the user. The function takes an optional parameter with a default value of ten that allows the user to set the number of messages returned for a given page. :param user: The user object which contains all the user's details num_of_msg_to_return: The number of messages to return for any given query """ return Message.objects.filter( Q(from_user=user) | Q(to_user=user), message_type=POST).order_by("-created_date")[:num_of_msg_to_return]
def handler_login(form): if not ('login' in form and 'password' in form): raise Exception('Переданы неверные параметры') user = User.objects( Q(login=form['login']) & Q(password=User.get_password(form['password']))).first() if not user: raise Exception('Неверный логин или пароль') if 'remember' in form: session.permanent = bool(form['remember']) session['user_id'] = str(user.id) session['rate'] = user.rate session['login'] = user.login session['timestamp'] = user.timestamp return redirect('/')
def parse_names_after_2002(): cands = Candidate.objects.filter((Q(election_id__not__contains="2000") | Q(election_id__not__contains="2002")), state='MD') #Loop through candidates, perform name parse and update for cand in cands: # Skip Other write-ins if 'other' in cand.slug: continue name = HumanName(cand.raw_full_name) cand.given_name = name.first cand.family_name = name.last cand.additional_name = name.middle cand.suffix = name.suffix cand.save()
def get_vc_interfaces_count(self, vc_id): vc = VC.get_by_id(vc_id) if not vc: return 0 objects = vc.vc_domain.managedobject_set.values_list("id", flat=True) l1 = vc.l1 n = SubInterface.objects.filter( Q(managed_object__in=objects) & ( Q(untagged_vlan=l1, enabled_afi=["BRIDGE"]) | Q(tagged_vlans=l1, enabled_afi=["BRIDGE"]) | Q(vlan_ids=l1) ) ).count() return n
def get_journal_by_issn(issn, **kwargs): """ Retorna um periódico considerando os parâmetros ``issn`` e ``kwargs`` - ``issn``: string, issn do periódico - ``kwargs``: parâmetros de filtragem. Em caso de não existir itens retorna {}. """ if not issn: raise ValueError(__('Obrigatório um issn.')) return Journal.objects( Q(print_issn=issn) | Q(eletronic_issn=issn), **kwargs).first()
def get_between(start_time, end_time): """ Return all reservations between start_time and end_time Args: start_time (datetime): end_time (datetime): Returns list(Reservation): """ reservations = Reservation.objects(( (Q(start_time__gte=start_time) & Q(start_time__lt=end_time)) | (Q(end_time__lte=end_time) & Q(end_time__gt=start_time))) & (Q(allowed__ne=False))) return reservations
def findmany_by_domains(self, num_elements, required_domains, blocked_domains, *sort_fields): if len(required_domains) > 0: req_query = Q(domain__in=required_domains) else: req_query = Q() if len(blocked_domains) > 0: blk_query = Q(domain__nin=blocked_domains) else: blk_query = Q() with self.conn(): if len(sort_fields) > 0: return URLMetadataDTO.objects(req_query & blk_query).order_by(*sort_fields)[:num_elements] else: return URLMetadataDTO.objects(req_query & blk_query)[:num_elements]
def quant_stock(stock_number, stock_name, **kwargs): short_ema = kwargs['short_ema'] long_ema = kwargs['long_ema'] dif_ema = kwargs['dif_ema'] qr_date = kwargs['qr_date'] if not pre_sdt_check(stock_number, **kwargs): return strategy_direction = 'long' quant_count = 150 strategy_name = 'week_macd_%s_%s_%s_%s' % (strategy_direction, short_ema, long_ema, dif_ema) last_trade_date = qr_date + datetime.timedelta(days=7) swt = SWT.objects( Q(stock_number=stock_number) & Q(last_trade_date__lte=last_trade_date)).order_by( '-last_trade_date')[:quant_count] use_ad_price, swt = is_ad_price(stock_number, qr_date, swt) if not swt: return trading_data = format_trading_data(swt, use_ad_price) df = calculate_macd(DataFrame(trading_data), short_ema, long_ema, dif_ema) this_week = df.iloc[-1] last_week = df.iloc[-2] if last_week['macd'] < 0 < this_week['macd']: if use_ad_price: init_price = swt[0].weekly_close_price else: init_price = this_week['close_price'] increase_rate = round( (this_week['close_price'] - last_week['close_price']) / last_week['close_price'], 4) * 100 qr = QR(stock_number=stock_number, stock_name=stock_name, date=qr_date, strategy_direction=strategy_direction, strategy_name=strategy_name, init_price=init_price, industry_involved=kwargs.get('industry_involved'), increase_rate=increase_rate) if not check_duplicate_strategy(qr): qr.save()
def profile(username, friends_page_number=1): # Removed everything with edit_profile variable because it isn't needed logged_user = None rel = None friends_page = False user = User.objects.filter(username=username).first() profile_messages = [] if user: if session.get("username"): logged_user = User.objects.filter(username=session.get("username")).first() rel=Relationship.get_relationship(logged_user, user) # Get friends friends = Relationship.objects.filter( from_user=user, rel_type=Relationship.FRIENDS, status=Relationship.APPROVED ) friends_total = friends.count() if "friends" in request.url: friends_page = True friends = friends.paginate(page=friends_page_number, per_page=3) # paginate is a mongoengine helper else: friends = friends[:5] form = FeedPostForm() # Get user messages if friends or self if logged_user and (rel == "SAME" or rel == "FRIENDS_APPROVED"): profile_messages = Message.objects.filter( Q(from_user=user) | Q(to_user=user), message_type=POST ).order_by("-create_date")[:10] return render_template("user/profile.html", user=user, rel=rel, logged_user=logged_user, friends=friends, friends_total=friends_total, friends_page=friends_page, form=form, profile_messages=profile_messages, ) else: # Don't find the user abort(404)
def quant_stock(stock_number, stock_name, **kwargs): if not pre_sdt_check(stock_number, **kwargs): return real_time = kwargs.get('real_time', False) week_long = kwargs.get('week_long', False) strategy_direction = 'long' strategy_name = 'break_through_%s_%s_%s' % (strategy_direction, kwargs['short_ma'], kwargs['long_ma']) if week_long: strategy_name = 'weeklong_' + strategy_name sdt = SDT.objects(Q(stock_number=stock_number) & Q(today_closing_price__ne=0.0) & Q(date__lte=kwargs['qr_date'])).order_by('-date')[:kwargs['long_ma']+10] if not sdt: return if not real_time: if sdt[0].today_closing_price <= sdt[0].today_average_price: return if real_time: sdt = setup_realtime_sdt(stock_number, sdt, kwargs) if not sdt: return if sdt[0].today_closing_price < sdt[0].today_opening_price: return trading_data = format_trading_data(sdt) df = calculate_ma(DataFrame(trading_data), short_ma, long_ma) today = df.iloc[-1] yestoday = df.iloc[-2] if yestoday['close_price'] < yestoday['long_ma'] and today['close_price'] > today['short_ma']\ and today['close_price'] > today['long_ma']: increase_rate = round((today['close_price'] - yestoday['close_price']) / yestoday['close_price'], 4) * 100 qr = QR( stock_number=stock_number, stock_name=stock_name, date=today.name, strategy_direction=strategy_direction, strategy_name=strategy_name, init_price=today['close_price'], industry_involved=kwargs.get('industry_involved'), increase_rate=increase_rate ) if real_time: return qr if not check_duplicate_strategy(qr): qr.save() return qr return ''
def get_sub_positions(position_ids, included=False): ''' 获取某些职位(id)的全部下级职位。 Params ------ - position_ids: 职位id列表 - included: boolean, default False, 是否包含position_ids中的职位 ''' query = Q(soft_del=False) if included: query = query & (Q(id__in=position_ids) | Q(path__in=position_ids)) else: query = query & Q(path__in=position_ids) positions = list(PositionDesc.objects(query)) positions = sorted(positions, key=lambda x: chinese_num_replace(x.name)) return positions
def get_by_id( company_id, task_id, required_status=None, only_fields=None, allow_public=False, ): if only_fields: if isinstance(only_fields, string_types): only_fields = [only_fields] else: only_fields = list(only_fields) only_fields = only_fields + ["status"] with TimingContext("mongo", "task_by_id_all"): tasks = Task.get_many( company=company_id, query=Q(id=task_id), allow_public=allow_public, override_projection=only_fields, return_dicts=False, ) task = None if not tasks else tasks[0] if not task: raise errors.bad_request.InvalidTaskId(id=task_id) if required_status and not task.status == required_status: raise errors.bad_request.InvalidTaskStatus( expected=required_status) return task
def assert_exists(company_id, task_ids, only=None, allow_public=False, return_tasks=True) -> Optional[Sequence[Task]]: task_ids = [task_ids] if isinstance(task_ids, six.string_types) else task_ids with translate_errors_context(), TimingContext("mongo", "task_exists"): ids = set(task_ids) q = Task.get_many( company=company_id, query=Q(id__in=ids), allow_public=allow_public, return_dicts=False, ) res = None if only: res = q.only(*only) elif return_tasks: res = list(q) count = len(res) if res is not None else q.count() if count != len(ids): raise errors.bad_request.InvalidTaskId(ids=task_ids) if return_tasks: return res
def index(): """View the ADI homepage. **Route:** ``/`` **Methods:** ``GET`` """ # cast date.today() to a datetime today = datetime.combine(date.today(), datetime.min.time()) # Ending on a future date, or today at a future time. The events should be # published, and should be chronological. # We limit to four events, one large event and one set of three events. events = (Event.objects(Q(end_date__gte=today)) .filter(published=True) .order_by('start_date', 'start_time') .limit(ONE_LARGE_AND_TRIPLE)) # sort published posts chronologically back in time all_blog_posts = (BlogPost.objects(published=True) .order_by('-date_published')) latest_blog_post = all_blog_posts[0] if all_blog_posts else None return render_template('index.html', events=events, blog_post=latest_blog_post)