def test_encrypt_and_decrypt_unicode_in_string_type_unicode(self):
my_value = u'hellü'
assert_true(isinstance(my_value, unicode))
my_value_encrypted = encrypt(my_value)
assert_true(isinstance(my_value_encrypted, bytes))
my_value_decrypted = decrypt(my_value_encrypted)
assert_equal(my_value_decrypted, ensure_bytes(my_value))
my_value = u'찦차КЛМНО💁◕‿◕｡)╱i̲̬͇̪͙n̝̗͕v̟̜̘̦͟o̶̙̰̠kè͚̮̺̪̹̱̤ ǝɹol'
assert_true(isinstance(my_value, unicode))
my_value_encrypted = encrypt(my_value)
my_value_decrypted = decrypt(my_value_encrypted)
assert_true(isinstance(my_value_decrypted, bytes))
assert_equal(my_value_decrypted, ensure_bytes(my_value))
def test_encrypt_and_decrypt_unicode_in_string_type_unicode(self):
my_value = u'hellü'
assert_true(isinstance(my_value, unicode))
my_value_encrypted = encrypt(my_value)
assert_true(isinstance(my_value_encrypted, bytes))
my_value_decrypted = decrypt(my_value_encrypted)
assert_equal(my_value_decrypted, ensure_bytes(my_value))
my_value = u'찦차КЛМНО💁◕‿◕｡)╱i̲̬͇̪͙n̝̗͕v̟̜̘̦͟o̶̙̰̠kè͚̮̺̪̹̱̤ ǝɹol'
assert_true(isinstance(my_value, unicode))
my_value_encrypted = encrypt(my_value)
my_value_decrypted = decrypt(my_value_encrypted)
assert_true(isinstance(my_value_decrypted, bytes))
assert_equal(my_value_decrypted, ensure_bytes(my_value))
def acceptable_title(node):
""" Omit projects that have certain words in the title """
omit_titles = ['test', 'photo', 'workshop', 'data']
if any(word in ensure_bytes(node['title']).lower() for word in omit_titles):
return False
return True
def acceptable_title(node):
""" Omit projects that have certain words in the title """
omit_titles = ['test', 'photo', 'workshop', 'data']
if any(word in ensure_bytes(node['title']).lower()
for word in omit_titles):
return False
return True
def test_encrypt_and_decrypt_no_unicode_in_string_type_unicode(self):
my_value = u'hello'
assert_true(isinstance(my_value, unicode))
my_value_encrypted = encrypt(my_value)
assert_true(isinstance(my_value_encrypted, bytes))
my_value_decrypted = decrypt(my_value_encrypted)
assert_true(isinstance(my_value_decrypted, bytes))
assert_equal(my_value_decrypted, ensure_bytes(my_value))
def test_encrypt_and_decrypt_no_unicode_in_string_type_unicode(self):
my_value = u'hello'
assert_true(isinstance(my_value, unicode))
my_value_encrypted = encrypt(my_value)
assert_true(isinstance(my_value_encrypted, bytes))
my_value_decrypted = decrypt(my_value_encrypted)
assert_true(isinstance(my_value_decrypted, bytes))
assert_equal(my_value_decrypted, ensure_bytes(my_value))
def get_events(self, date):
super(InstitutionSummary, self).get_events(date)
institutions = Institution.objects.all()
counts = []
# Convert to a datetime at midnight for queries and the timestamp
timestamp_datetime = datetime(date.year, date.month, date.day).replace(tzinfo=pytz.UTC)
query_datetime = timestamp_datetime + timedelta(days=1)
daily_query = Q(created__gte=timestamp_datetime)
public_query = Q(is_public=True)
private_query = Q(is_public=False)
# `embargoed` used private status to determine embargoes, but old registrations could be private and unapproved registrations can also be private
# `embargoed_v2` uses future embargo end dates on root
embargo_v2_query = Q(root__embargo__end_date__gt=query_datetime)
for institution in institutions:
node_qs = institution.nodes.filter(is_deleted=False, created__lt=query_datetime).exclude(type='osf.registration')
registration_qs = institution.nodes.filter(is_deleted=False, created__lt=query_datetime, type='osf.registration')
count = {
'institution': {
'id': ensure_bytes(institution._id),
'name': ensure_bytes(institution.name),
},
'users': {
'total': institution.osfuser_set.filter(is_active=True).count(),
'total_daily': institution.osfuser_set.filter(date_confirmed__gte=timestamp_datetime, date_confirmed__lt=query_datetime).count(),
},
'nodes': {
'total': node_qs.count(),
'public': node_qs.filter(public_query).count(),
'private': node_qs.filter(private_query).count(),
'total_daily': node_qs.filter(daily_query).count(),
'public_daily': node_qs.filter(public_query & daily_query).count(),
'private_daily': node_qs.filter(private_query & daily_query).count(),
},
# Projects use get_roots to remove children
'projects': {
'total': node_qs.get_roots().count(),
'public': node_qs.filter(public_query).get_roots().count(),
'private': node_qs.filter(private_query).get_roots().count(),
'total_daily': node_qs.filter(daily_query).get_roots().count(),
'public_daily': node_qs.filter(public_query & daily_query).get_roots().count(),
'private_daily': node_qs.filter(private_query & daily_query).get_roots().count(),
},
'registered_nodes': {
'total': registration_qs.count(),
'public': registration_qs.filter(public_query).count(),
'embargoed': registration_qs.filter(private_query).count(),
'embargoed_v2': registration_qs.filter(private_query & embargo_v2_query).count(),
'total_daily': registration_qs.filter(daily_query).count(),
'public_daily': registration_qs.filter(public_query & daily_query).count(),
'embargoed_daily': registration_qs.filter(private_query & daily_query).count(),
'embargoed_v2_daily': registration_qs.filter(private_query & daily_query & embargo_v2_query).count(),
},
'registered_projects': {
'total': registration_qs.get_roots().count(),
'public': registration_qs.filter(public_query).get_roots().count(),
'embargoed': registration_qs.filter(private_query).get_roots().count(),
'embargoed_v2': registration_qs.filter(private_query & embargo_v2_query).get_roots().count(),
'total_daily': registration_qs.filter(daily_query).get_roots().count(),
'public_daily': registration_qs.filter(public_query & daily_query).get_roots().count(),
'embargoed_daily': registration_qs.filter(private_query & daily_query).get_roots().count(),
'embargoed_v2_daily': registration_qs.filter(private_query & daily_query & embargo_v2_query).get_roots().count(),
},
'keen': {
'timestamp': timestamp_datetime.isoformat()
}
}
logger.info(
'{} Nodes counted. Nodes: {}, Projects: {}, Registered Nodes: {}, Registered Projects: {}'.format(
count['institution']['name'],
count['nodes']['total'],
count['projects']['total'],
count['registered_nodes']['total'],
count['registered_projects']['total']
)
)
counts.append(count)
return counts
def get_events(self, date):
super(InstitutionSummary, self).get_events(date)
institutions = Institution.objects.all()
counts = []
# Convert to a datetime at midnight for queries and the timestamp
timestamp_datetime = datetime(date.year, date.month,
date.day).replace(tzinfo=pytz.UTC)
query_datetime = timestamp_datetime + timedelta(1)
for institution in institutions:
node_query = (Q(is_deleted=False) & Q(created__lt=query_datetime))
project_query = node_query
public_query = Q(is_public=True)
private_query = Q(is_public=False)
node_public_query = node_query & public_query
node_private_query = node_query & private_query
project_public_query = project_query & public_query
project_private_query = project_query & private_query
count = {
'institution': {
'id': ensure_bytes(institution._id),
'name': ensure_bytes(institution.name),
},
'users': {
'total':
institution.osfuser_set.filter(is_active=True).count(),
},
'nodes': {
'total':
institution.nodes.filter(node_query).exclude(
type='osf.registration').count(),
'public':
institution.nodes.filter(node_public_query).exclude(
type='osf.registration').count(),
'private':
institution.nodes.filter(node_private_query).exclude(
type='osf.registration').count(),
},
'projects': {
'total':
institution.nodes.filter(project_query).exclude(
type='osf.registration').get_roots().count(),
'public':
institution.nodes.filter(project_public_query).exclude(
type='osf.registration').get_roots().count(),
'private':
institution.nodes.filter(project_private_query).exclude(
type='osf.registration').get_roots().count(),
},
'registered_nodes': {
'total':
institution.nodes.filter(node_query).filter(
type='osf.registration').count(),
'public':
institution.nodes.filter(node_public_query).filter(
type='osf.registration').count(),
'embargoed':
institution.nodes.filter(node_private_query).filter(
type='osf.registration').count(),
},
'registered_projects': {
'total':
institution.nodes.filter(project_query).filter(
type='osf.registration').get_roots().count(),
'public':
institution.nodes.filter(project_public_query).filter(
type='osf.registration').get_roots().count(),
'embargoed':
institution.nodes.filter(project_private_query).filter(
type='osf.registration').get_roots().count(),
},
'keen': {
'timestamp': timestamp_datetime.isoformat()
}
}
logger.info(
'{} Nodes counted. Nodes: {}, Projects: {}, Registered Nodes: {}, Registered Projects: {}'
.format(count['institution']['name'], count['nodes']['total'],
count['projects']['total'],
count['registered_nodes']['total'],
count['registered_projects']['total']))
counts.append(count)
return counts
def test_ensure_bytes_encodes_no_unicode_in_string_type_str(self):
my_value = 'hello'
assert_true(isinstance(my_value, bytes))
my_str = ensure_bytes(my_value)
assert_true(isinstance(my_str, bytes))
def test_ensure_bytes_encodes_unicode_in_string_type_unicode(self):
my_value = u'hellü'
assert_true(isinstance(my_value, unicode))
my_str = ensure_bytes(my_value)
assert_true(isinstance(my_str, bytes))
def test_ensure_bytes_encodes_no_unicode_in_string_type_str(self):
my_value = 'hello'
assert_true(isinstance(my_value, bytes))
my_str = ensure_bytes(my_value)
assert_true(isinstance(my_str, bytes))
def test_ensure_bytes_encodes_unicode_in_string_type_unicode(self):
my_value = u'hellü'
assert_true(isinstance(my_value, unicode))
my_str = ensure_bytes(my_value)
assert_true(isinstance(my_str, bytes))
