zulip / zulip / 6

pending completion

Build # 6

Build Type

push

travis-ci

Committed by

timabbott

Commit Message

Fix cursor() arguments for connection classes.

In order to use the latest version of psycopg2 with the latest version
of sqlalchemy we must integrate the changes made in the 2.4.6 release of
psycopg2. See
https://github.com/psycopg/psycopg2/commit/c86ca7687
and the release notes for psycopg2 2.4.6.

Run Details

3 of 3 new or added lines in 1 file covered. (100.0%)

20989 of 23966 relevant lines covered (87.58%)

1.75 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

80.49

/analytics/models.py

from django.db import models
from django.utils import timezone

from zerver.models import Realm, UserProfile, Stream, Recipient
from zerver.lib.str_utils import ModelReprMixin
from zerver.lib.timestamp import datetime_to_UTC, floor_to_day

import datetime

from six import text_type
from typing import Optional, Tuple, Union, Dict, Any

class FillState(ModelReprMixin, models.Model):
    property = models.CharField(max_length=40, unique=True) # type: text_type
    end_time = models.DateTimeField() # type: datetime.datetime

    # Valid states are {DONE, STARTED}
    DONE = 1
    STARTED = 2
    state = models.PositiveSmallIntegerField() # type: int

    last_modified = models.DateTimeField(auto_now=True) # type: datetime.datetime

    def __unicode__(self):
        # type: () -> text_type
        return u"<FillState: %s %s %s>" % (self.property, self.end_time, self.state)

def get_fill_state(property):
    # type: (text_type) -> Optional[Dict[str, Any]]
    try:
        return FillState.objects.filter(property = property).values('end_time', 'state')[0]
    except IndexError:
        return None

# The earliest/starting end_time in FillState
# We assume there is at least one realm
def installation_epoch():
    # type: () -> datetime.datetime
    earliest_realm_creation = Realm.objects.aggregate(models.Min('date_created'))['date_created__min']
    return floor_to_day(datetime_to_UTC(earliest_realm_creation))

# would only ever make entries here by hand
class Anomaly(ModelReprMixin, models.Model):
    info = models.CharField(max_length=1000) # type: text_type

    def __unicode__(self):
        # type: () -> text_type
        return u"<Anomaly: %s... %s>" % (self.info, self.id)

class BaseCount(ModelReprMixin, models.Model):
    # Note: When inheriting from BaseCount, you may want to rearrange
    # the order of the columns in the migration to make sure they
    # match how you'd like the table to be arranged.
    property = models.CharField(max_length=40) # type: text_type
    end_time = models.DateTimeField() # type: datetime.datetime
    interval = models.CharField(max_length=20) # type: text_type
    value = models.BigIntegerField() # type: int
    anomaly = models.ForeignKey(Anomaly, null=True) # type: Optional[Anomaly]

    class Meta(object):
        abstract = True

    @staticmethod
    def extended_id():
        # type: () -> Tuple[str, ...]
        raise NotImplementedError

    @staticmethod
    def key_model():
        # type: () -> models.Model
        raise NotImplementedError

class InstallationCount(BaseCount):

    class Meta(object):
        unique_together = ("property", "end_time", "interval")

    @staticmethod
    def extended_id():
        # type: () -> Tuple[str, ...]
        return ()

    @staticmethod
    def key_model():
        # type: () -> models.Model
        return None

    def __unicode__(self):
        # type: () -> text_type
        return u"<InstallationCount: %s %s>" % (self.property, self.value)

class RealmCount(BaseCount):
    realm = models.ForeignKey(Realm)

    class Meta(object):
        unique_together = ("realm", "property", "end_time", "interval")

    @staticmethod
    def extended_id():
        # type: () -> Tuple[str, ...]
        return ('realm_id',)

    @staticmethod
    def key_model():
        # type: () -> models.Model
        return Realm

    def __unicode__(self):
        # type: () -> text_type
        return u"<RealmCount: %s %s %s>" % (self.realm, self.property, self.value)

class UserCount(BaseCount):
    user = models.ForeignKey(UserProfile)
    realm = models.ForeignKey(Realm)

    class Meta(object):
        unique_together = ("user", "property", "end_time", "interval")

    @staticmethod
    def extended_id():
        # type: () -> Tuple[str, ...]
        return ('user_id', 'realm_id')

    @staticmethod
    def key_model():
        # type: () -> models.Model
        return UserProfile

    def __unicode__(self):
        # type: () -> text_type
        return u"<UserCount: %s %s %s>" % (self.user, self.property, self.value)

class StreamCount(BaseCount):
    stream = models.ForeignKey(Stream)
    realm = models.ForeignKey(Realm)

    class Meta(object):
        unique_together = ("stream", "property", "end_time", "interval")

    @staticmethod
    def extended_id():
        # type: () -> Tuple[str, ...]
        return ('stream_id', 'realm_id')

    @staticmethod
    def key_model():
        # type: () -> models.Model
        return Stream

    def __unicode__(self):
        # type: () -> text_type
        return u"<StreamCount: %s %s %s %s>" % (self.stream, self.property, self.value, self.id)

1	from django.db import models	2✔
2	from django.utils import timezone	2✔
3
4	from zerver.models import Realm, UserProfile, Stream, Recipient	2✔
5	from zerver.lib.str_utils import ModelReprMixin	2✔
6	from zerver.lib.timestamp import datetime_to_UTC, floor_to_day	2✔
7
8	import datetime	2✔
9
10	from six import text_type	2✔
11	from typing import Optional, Tuple, Union, Dict, Any	2✔
12
13	class FillState(ModelReprMixin, models.Model):	2✔
14	property = models.CharField(max_length=40, unique=True) # type: text_type	2✔
15	end_time = models.DateTimeField() # type: datetime.datetime	2✔
16
17	# Valid states are {DONE, STARTED}
18	DONE = 1	2✔
19	STARTED = 2	2✔
20	state = models.PositiveSmallIntegerField() # type: int	2✔
21
22	last_modified = models.DateTimeField(auto_now=True) # type: datetime.datetime	2✔
23
24	def __unicode__(self):	2✔
25	# type: () -> text_type
26	return u"<FillState: %s %s %s>" % (self.property, self.end_time, self.state)	×
27
28	def get_fill_state(property):	2✔
29	# type: (text_type) -> Optional[Dict[str, Any]]
30	try:	2✔
31	return FillState.objects.filter(property = property).values('end_time', 'state')[0]	2✔
32	except IndexError:	2✔
33	return None	2✔
34
35	# The earliest/starting end_time in FillState
36	# We assume there is at least one realm
37	def installation_epoch():	2✔
38	# type: () -> datetime.datetime
39	earliest_realm_creation = Realm.objects.aggregate(models.Min('date_created'))['date_created__min']	2✔
40	return floor_to_day(datetime_to_UTC(earliest_realm_creation))	2✔
41
42	# would only ever make entries here by hand
43	class Anomaly(ModelReprMixin, models.Model):	2✔
44	info = models.CharField(max_length=1000) # type: text_type	2✔
45
46	def __unicode__(self):	2✔
47	# type: () -> text_type
48	return u"<Anomaly: %s... %s>" % (self.info, self.id)	×
49
50	class BaseCount(ModelReprMixin, models.Model):	2✔
51	# Note: When inheriting from BaseCount, you may want to rearrange
52	# the order of the columns in the migration to make sure they
53	# match how you'd like the table to be arranged.
54	property = models.CharField(max_length=40) # type: text_type	2✔
55	end_time = models.DateTimeField() # type: datetime.datetime	2✔
56	interval = models.CharField(max_length=20) # type: text_type	2✔
57	value = models.BigIntegerField() # type: int	2✔
58	anomaly = models.ForeignKey(Anomaly, null=True) # type: Optional[Anomaly]	2✔
59
60	class Meta(object):	2✔
61	abstract = True	2✔
62
63	@staticmethod	2✔
64	def extended_id():
65	# type: () -> Tuple[str, ...]
66	raise NotImplementedError	×
67
68	@staticmethod	2✔
69	def key_model():
70	# type: () -> models.Model
71	raise NotImplementedError	×
72
73	class InstallationCount(BaseCount):	2✔
74
75	class Meta(object):	2✔
76	unique_together = ("property", "end_time", "interval")	2✔
77
78	@staticmethod	2✔
79	def extended_id():
80	# type: () -> Tuple[str, ...]
81	return ()	×
82
83	@staticmethod	2✔
84	def key_model():
85	# type: () -> models.Model
86	return None	×
87
88	def __unicode__(self):	2✔
89	# type: () -> text_type
90	return u"<InstallationCount: %s %s>" % (self.property, self.value)	×
91
92	class RealmCount(BaseCount):	2✔
93	realm = models.ForeignKey(Realm)	2✔
94
95	class Meta(object):	2✔
96	unique_together = ("realm", "property", "end_time", "interval")	2✔
97
98	@staticmethod	2✔
99	def extended_id():
100	# type: () -> Tuple[str, ...]
101	return ('realm_id',)	×
102
103	@staticmethod	2✔
104	def key_model():
105	# type: () -> models.Model
106	return Realm	×
107
108	def __unicode__(self):	2✔
109	# type: () -> text_type
110	return u"<RealmCount: %s %s %s>" % (self.realm, self.property, self.value)	×
111
112	class UserCount(BaseCount):	2✔
113	user = models.ForeignKey(UserProfile)	2✔
114	realm = models.ForeignKey(Realm)	2✔
115
116	class Meta(object):	2✔
117	unique_together = ("user", "property", "end_time", "interval")	2✔
118
119	@staticmethod	2✔
120	def extended_id():
121	# type: () -> Tuple[str, ...]
122	return ('user_id', 'realm_id')	×
123
124	@staticmethod	2✔
125	def key_model():
126	# type: () -> models.Model
127	return UserProfile	×
128
129	def __unicode__(self):	2✔
130	# type: () -> text_type
131	return u"<UserCount: %s %s %s>" % (self.user, self.property, self.value)	×
132
133	class StreamCount(BaseCount):	2✔
134	stream = models.ForeignKey(Stream)	2✔
135	realm = models.ForeignKey(Realm)	2✔
136
137	class Meta(object):	2✔
138	unique_together = ("stream", "property", "end_time", "interval")	2✔
139
140	@staticmethod	2✔
141	def extended_id():
142	# type: () -> Tuple[str, ...]
143	return ('stream_id', 'realm_id')	×
144
145	@staticmethod	2✔
146	def key_model():
147	# type: () -> models.Model
148	return Stream	×
149
150	def __unicode__(self):	2✔
151	# type: () -> text_type
152	return u"<StreamCount: %s %s %s %s>" % (self.stream, self.property, self.value, self.id)	×

zulip / zulip / 6

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous