def test_manager_backend_set(databases):
"""Tests that creating a new instance of :see:PostgresManager succeseeds
without any errors if one or more databases are configured with
`psqlextra.backend` as its ENGINE."""
with override_settings(DATABASES=databases):
assert PostgresManager()
def _create_model(method):
fields = [("name", models.TextField())]
key = []
if method == PostgresPartitioningMethod.RANGE:
key.append("timestamp")
fields.append(("timestamp", models.DateTimeField()))
elif method == PostgresPartitioningMethod.LIST:
key.append("category")
fields.append(("category", models.TextField()))
elif method == PostgresPartitioningMethod.HASH:
key.append("artist_id")
fields.append(("artist_id", models.IntegerField()))
else:
raise NotImplementedError
return operations.PostgresCreatePartitionedModel(
"test",
fields=fields,
bases=(PostgresPartitionedModel, ),
managers=[("objects", PostgresManager())],
partitioning_options={
"method": method,
"key": key
},
)
class AttendeeVote(TimeStampedModel):
attendee = models.ForeignKey(
Attendee,
verbose_name=_("Attendee"),
null=False,
limit_choices_to={"event__published": True},
on_delete=models.CASCADE,
)
talk = models.ForeignKey(
Talk,
verbose_name=_("Talk"),
null=False,
limit_choices_to={"track__is_null": False},
on_delete=models.CASCADE,
)
score = models.PositiveSmallIntegerField()
objects = PostgresManager()
class Meta:
verbose_name = _("Attendee vote")
verbose_name_plural = _("Attendee votes")
unique_together = ["attendee", "talk"]
def __str__(self):
return "{} voted {} for {} by {}".format(self.attendee, self.score,
self.talk.title,
self.talk.published_speaker)
class Ability(TimeStampedModel):
name = models.CharField(max_length=512, verbose_name=_("Ability"))
depth = models.PositiveSmallIntegerField(choices=[(1, "1"), (2, "2")],
verbose_name=_("Depth"),
blank=True,
null=True)
levels = models.ManyToManyField("Level", blank=True)
subjects = models.ManyToManyField("Subject")
subject_related = models.BooleanField(verbose_name=_("Subject related"))
systems = models.ManyToManyField("System", blank=True)
ufids = models.ManyToManyField("UFID")
study_field = models.ForeignKey("StudyField",
on_delete=models.CASCADE,
blank=True,
null=True)
module_tracks = models.ManyToManyField("ModuleTrack", blank=True)
public = models.BooleanField(default=False)
rolemodel = models.ForeignKey("RoleModel",
blank=True,
null=True,
on_delete=models.SET_NULL)
objects = PostgresManager()
class Meta:
verbose_name = _("Ability")
verbose_name_plural = _("Abilities")
ordering = ("name", )
def get_absolute_url(self):
return reverse("ability-detail", kwargs={"pk": self.pk})
def __str__(self):
return self.name
def test_partitioned_model_render(model):
"""Tests whether the state can be rendered into a valid model class."""
options = dict(method=PostgresPartitioningMethod.RANGE, key=["timestamp"])
state = PostgresPartitionedModelState(
app_label="tests",
name=str(uuid.uuid4()),
fields=[("name", models.TextField())],
options=None,
partitioning_options=options,
bases=(PostgresPartitionedModel, ),
managers=[("cookie", PostgresManager())],
)
rendered_model = state.render(apps)
assert issubclass(rendered_model, PostgresPartitionedModel)
assert rendered_model.name
assert isinstance(rendered_model.objects, PostgresManager)
assert isinstance(rendered_model.cookie, PostgresManager)
assert rendered_model.__name__ == state.name
assert rendered_model._meta.apps == apps
assert rendered_model._meta.app_label == "tests"
assert rendered_model._partitioning_meta.method == options["method"]
assert rendered_model._partitioning_meta.key == options["key"]
class Serie(models.Model):
station = models.ForeignKey(Station, on_delete=models.CASCADE)
sensor = models.ForeignKey(Sensor, on_delete=models.CASCADE)
parameter = models.ForeignKey(Parameter, on_delete=models.CASCADE)
height = models.FloatField(blank=True, null=True)
location = models.ForeignKey(Location,
on_delete=models.CASCADE,
null=True,
blank=True)
# add below additional fields
stats_mean = models.FloatField(blank=True, null=True)
stats_outliers = ArrayField(models.IntegerField(), blank=True, null=True)
objects = models.Manager()
extra = PostgresManager()
def set_mean(self, threshold=5):
df = read_frame(Measure.objects.filter(serie=self),
index_col='timestamp')
df['pandas'] = df['value'].rolling(
window=5,
center=True).median().fillna(method='bfill').fillna(method='ffill')
difference = np.abs(df['value'] - df['pandas'])
outlier_idx = difference > threshold
# print df.loc[outlier_idx, 'value'].shape
self.stats_mean = df.loc[~outlier_idx, 'value'].mean()
self.save()
return self.stats_mean
def __str__(self):
return u'{} - {} - {}'.format(self.station, self.parameter,
self.sensor.label)
class EnsemblGene(PostgresModel):
# override default Django manager
objects = PostgresManager()
gene_id = models.BigAutoField(primary_key=True)
ensg_id = models.CharField(unique=True, max_length=30, blank=True, null=True)
gene_name = models.CharField(max_length=255, blank=True, null=True)
chromosome = models.CharField(max_length=50, blank=True, null=True)
region_accession = models.CharField(max_length=50, blank=True, null=True)
mod_id = models.CharField(max_length=30, blank=True, null=True)
deleted = models.NullBooleanField()
seq_region_start = models.BigIntegerField(blank=True, null=True)
seq_region_end = models.BigIntegerField(blank=True, null=True)
seq_region_strand = models.BigIntegerField(blank=True, null=True)
biotype = models.CharField(max_length=40, blank=True, null=True)
time_loaded = models.DateTimeField(blank=True, null=True)
gene_symbol = models.CharField(max_length=30, blank=True, null=True)
gene_accession = models.CharField(max_length=30, blank=True, null=True)
source = models.CharField(max_length=30, blank=True, null=True)
# history is not a column
history = models.ManyToManyField(
EnsemblSpeciesHistory,
through='GeneHistory'
)
def __str__(self):
return "{0} - {1} ({2})".format(self.gene_id, self.ensg_id, self.gene_name)
class Meta:
managed = False
db_table = 'ensembl_gene'
class BaseModel(models.Model):
created_at = models.DateTimeField(auto_now_add=True, blank=True)
last_modified = models.DateTimeField(auto_now=True, blank=True)
objects = PostgresManager()
class Meta:
abstract = True
class PostgresModel(models.Model):
"""Base class for for taking advantage of PostgreSQL specific features."""
class Meta:
abstract = True
base_manager_name = "objects"
objects = PostgresManager()
class Sensor(models.Model):
code = models.CharField(max_length=100)
label = models.CharField(max_length=150, blank=True, null=True)
objects = models.Manager()
extra = PostgresManager()
def __str__(self):
return u'{}'.format(self.label)
class Location(models.Model):
label = models.CharField(max_length=150)
geo = models.PointField(srid=4326, null=True)
elevation = models.IntegerField(null=True, blank=True)
image = models.ImageField(null=True, blank=True)
objects = LocationManager()
extra = PostgresManager()
def __str__(self):
return u'{}'.format(self.label)
class Measure(models.Model):
id = models.BigAutoField(primary_key=True)
serie = models.ForeignKey(Serie, on_delete=models.CASCADE)
timestamp = models.DateTimeField(db_index=True)
value = models.FloatField()
objects = models.Manager()
extra = PostgresManager()
class Meta:
unique_together = ('serie', 'timestamp') #, 'value')
class GeneHistory(PostgresModel):
objects = PostgresManager()
ensembl_species_history = models.ForeignKey(EnsemblSpeciesHistory,
models.DO_NOTHING)
gene = models.ForeignKey(EnsemblGene, models.DO_NOTHING)
class Meta:
managed = False
db_table = 'gene_history'
unique_together = (('ensembl_species_history', 'gene'), )
def test_manager_backend_not_set():
"""Tests whether creating a new instance of
:see:PostgresManager fails if no database
has `psqlextra.backend` configured
as its ENGINE."""
with override_settings(
DATABASES={"default": {"ENGINE": "django.db.backends.postgresql"}}
):
with pytest.raises(ImproperlyConfigured):
PostgresManager()
class TranscriptHistory(PostgresModel):
objects = PostgresManager()
ensembl_species_history = models.ForeignKey(EnsemblSpeciesHistory,
models.DO_NOTHING,
primary_key=True)
transcript = models.ForeignKey(EnsemblTranscript, models.DO_NOTHING)
class Meta:
managed = False
db_table = 'transcript_history'
unique_together = (('ensembl_species_history', 'transcript'), )
class ModuleTrack(models.Model):
name = models.CharField(max_length=512, verbose_name=_("Module track"))
university = models.ForeignKey("University", on_delete=models.CASCADE)
objects = PostgresManager()
class Meta:
verbose_name = _("Module track")
verbose_name_plural = _("module tracks")
ordering = ("name", )
def __str__(self):
return f"{self.university}: {self.name}"
class UFID(models.Model):
id = models.PositiveIntegerField(primary_key=True)
name = models.CharField(max_length=512, verbose_name=_("Name"))
objects = PostgresManager()
class Meta:
verbose_name = _("UFID")
verbose_name_plural = _("UFIDs")
ordering = ("id", )
def __str__(self):
return f"{self.name} ({self.id})"
class TranscriptHistory(PostgresModel):
objects = PostgresManager()
ensembl_species_history = models.ForeignKey(EnsemblSpeciesHistory,
models.DO_NOTHING
# primary_key=True
)
transcript = models.ForeignKey(EnsemblTranscript, models.DO_NOTHING)
grouping_id = models.BigIntegerField(blank=True, null=True)
class Meta:
managed = False
db_table = 'transcript_history'
unique_together = (('ensembl_species_history', 'transcript'), )
class Level(TimeStampedModel):
id = models.CharField(max_length=128,
primary_key=True,
verbose_name=_("Acronym"))
name = models.CharField(max_length=512, verbose_name=_("Name"))
objects = PostgresManager()
class Meta:
verbose_name = _("Level")
verbose_name_plural = _("Levels")
ordering = ("id", )
def __str__(self):
return f"{self.name} ({self.id})"
class System(models.Model):
id = models.CharField(max_length=128,
primary_key=True,
verbose_name=_("Acronym"))
name = models.CharField(max_length=512, verbose_name=_("Name"))
objects = PostgresManager()
class Meta:
verbose_name = _("System")
verbose_name_plural = _("Systems")
ordering = ("name", )
def __str__(self):
return self.name
class Symptom(TimeStampedModel):
name = models.CharField(max_length=512, verbose_name=_("Symptom"))
subjects = models.ManyToManyField("Subject")
public = models.BooleanField(default=False)
objects = PostgresManager()
class Meta:
verbose_name = _("Symptom")
verbose_name_plural = _("Symptoms")
ordering = ("name", )
def get_absolute_url(self):
return reverse("symptom-detail", kwargs={"pk": self.pk})
def __str__(self):
return self.name
class Skill(models.Model):
name = models.CharField(max_length=512, verbose_name=_("Name"))
activity = models.ForeignKey("Activity", on_delete=models.CASCADE)
clinical_traineeship_checklist = models.BooleanField(
default=False, verbose_name=_("Clinical traineeship checklist"))
objects = PostgresManager()
class Meta:
verbose_name = _("Skill")
verbose_name_plural = _("Skills")
ordering = ("name", )
def get_absolute_url(self):
return reverse("skill-detail", kwargs={"pk": self.pk})
def __str__(self):
return self.name
class Subject(TimeStampedModel):
id = models.CharField(max_length=128,
primary_key=True,
verbose_name=_("Acronym"))
name = models.CharField(max_length=512, verbose_name=_("Name"))
slug = AutoSlugField(populate_from=["name"])
objects = PostgresManager()
class Meta:
verbose_name = _("Subject")
verbose_name_plural = _("Subjects")
ordering = ("id", )
def __str__(self):
return f"{self.name} ({self.id})"
def get_absolute_url(self):
return reverse('subject-detail', kwargs={'slug': self.slug})
class Activity(models.Model):
name = models.CharField(max_length=512, verbose_name=_("Name"))
competence_level = models.ForeignKey("CompetenceLevel",
on_delete=models.CASCADE)
objects = PostgresManager()
class Meta:
verbose_name = _("Activity")
verbose_name_plural = _("Activities")
ordering = ("name", )
constraints = (models.UniqueConstraint(fields=("name", ),
name="unique_name"), )
def get_absolute_url(self):
return reverse("activity-detail", kwargs={"pk": self.pk})
def __str__(self):
return self.name
class Station(models.Model):
code = models.CharField(max_length=100)
label = models.CharField(max_length=150, null=True, blank=True)
description = models.TextField(null=True, blank=True)
image = models.ImageField(null=True, blank=True)
network = models.ForeignKey(Network,
on_delete=models.CASCADE,
null=True,
blank=True)
# location has been moved directly within Series model
# this location field should provide current Station location
location = models.ForeignKey(Location,
on_delete=models.CASCADE,
null=True,
blank=True)
source = models.ForeignKey(SourceType,
on_delete=models.CASCADE,
null=True,
blank=True)
status = models.CharField(
max_length=255,
choices=[(i, i)
for i in ['active', 'decomissioned', 'in maintenance']],
default='active')
parameters_mapping = models.ManyToManyField(Parameter,
through='ParameterMapping')
# this allows to override SourceType endpoint
uri = models.URLField(blank=True,
null=True,
help_text="DataSource/Station endpoint")
objects = models.Manager()
extra = PostgresManager()
def __str__(self):
l = getattr(self, 'label') or getattr(self, 'code')
n = getattr(self, 'network', '')
return u'{} {}'.format(l, n)
class Meta:
verbose_name = "DataSource/Station"
verbose_name_plural = "DataSources/Stations"
class EnsemblSpeciesHistory(PostgresModel):
objects = PostgresManager()
ensembl_species_history_id = models.BigAutoField(primary_key=True)
species = models.CharField(max_length=30, blank=True, null=True)
assembly_accession = models.CharField(max_length=30, blank=True, null=True)
ensembl_tax_id = models.BigIntegerField(blank=True, null=True)
ensembl_release = models.BigIntegerField(blank=True, null=True)
status = models.CharField(max_length=30, blank=True, null=True)
time_loaded = models.DateTimeField(blank=True, null=True)
def __str__(self):
return "{0} - {1} {2} {3}".format(self.ensembl_species_history_id,
self.species,
self.assembly_accession,
self.ensembl_tax_id,
self.ensembl_release)
class Meta:
managed = False
db_table = 'ensembl_species_history'
class Parameter(models.Model):
code = models.CharField(max_length=100)
uri = models.URLField(
blank=True,
null=True,
help_text="Reference to a controlled vocabulary (eg. NERC)")
label = models.CharField(max_length=150, blank=True, null=True)
uom = models.CharField(
max_length=25,
validators=[validate_uom],
help_text=
"unit of measure based on python-pint unit registry (eg. meter, kelvin)",
blank=True,
null=True)
objects = models.Manager()
extra = PostgresManager()
def __str__(self):
if self.uom is None:
return u'{}'.format(self.code)
else:
return u'{} ({})'.format(self.code, self.uom)
class EnsemblTranscript(PostgresModel):
objects = PostgresManager()
transcript_id = models.BigAutoField(primary_key=True)
gene = models.ForeignKey(EnsemblGene,
models.DO_NOTHING,
blank=True,
null=True)
enst_id = models.CharField(unique=True,
max_length=30,
blank=True,
null=True)
enst_version = models.SmallIntegerField(blank=True, null=True)
ccds_id = models.CharField(max_length=30, blank=True, null=True)
uniparc_accession = models.CharField(max_length=30, blank=True, null=True)
biotype = models.CharField(max_length=40, blank=True, null=True)
deleted = models.NullBooleanField()
seq_region_start = models.BigIntegerField(blank=True, null=True)
seq_region_end = models.BigIntegerField(blank=True, null=True)
supporting_evidence = models.CharField(max_length=45,
blank=True,
null=True)
userstamp = models.CharField(max_length=30, blank=True, null=True)
time_loaded = models.DateTimeField(blank=True, null=True)
select = models.NullBooleanField()
ensp_id = models.CharField(max_length=30, blank=True, null=True)
ensp_len = models.IntegerField(blank=True, null=True)
history = models.ManyToManyField(EnsemblSpeciesHistory,
through='TranscriptHistory')
def __str__(self):
return "{0} - {1} ({2})".format(self.transcript_id, self.enst_id,
self.gene)
class Meta:
managed = False
db_table = 'ensembl_transcript'
class SymbolManager(PostgresManager.from_queryset(SymbolQuerySet)):
def get_queryset(self):
return SymbolQuerySet(self.model, using=self.db)
class OhlcvManager(PostgresManager.from_queryset(OhlcvQuerySet)):
def get_queryset(self):
return OhlcvQuerySet(self.model, using=self.db)
