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)
