return np.array(value)
class Group(Base):
name = sa.Column(sa.String, unique=True, nullable=False)
sources = relationship('Source', secondary='group_sources', cascade='all')
streams = relationship('Stream', secondary='stream_groups', cascade='all',
back_populates='groups')
group_users = relationship('GroupUser', back_populates='group',
cascade='all', passive_deletes=True)
users = relationship('User', secondary='group_users', cascade='all',
back_populates='groups')
GroupUser = join_model('group_users', Group, User)
GroupUser.admin = sa.Column(sa.Boolean, nullable=False, default=False)
class Stream(Base):
name = sa.Column(sa.String, unique=True, nullable=False)
url = sa.Column(sa.String, unique=True, nullable=False)
username = sa.Column(sa.String)
password = sa.Column(sa.String)
groups = relationship('Group', secondary='stream_groups', cascade='all',
back_populates='streams')
StreamGroup = join_model('stream_groups', Stream, Group)
else:
header = None
return cls(
obj_id=obj_id,
instrument_id=instrument_id,
type=type,
label=label,
observed_at=observed_at,
altdata=header,
**spec_data,
)
SpectrumReducer = join_model("spectrum_reducers", Spectrum, User)
SpectrumObserver = join_model("spectrum_observers", Spectrum, User)
SpectrumReducer.create = (
SpectrumReducer.delete
) = SpectrumReducer.update = AccessibleIfUserMatches('spectrum.owner')
SpectrumObserver.create = (
SpectrumObserver.delete
) = SpectrumObserver.update = AccessibleIfUserMatches('spectrum.owner')
# should be accessible only by spectrumowner ^^
SpectrumReducer.external_reducer = sa.Column(
sa.String,
nullable=True,
doc="The actual reducer for the spectrum, provided as free text if the "
"reducer is not a user in the database. Separate from the point-of-contact "
def update_single_user_group(mapper, connection, target):
# Update single user group name if needed
@event.listens_for(DBSession(), "after_flush_postexec", once=True)
def receive_after_flush(session, context):
single_user_group = target.single_user_group
single_user_group.name = slugify(target.username)
DBSession().merge(single_user_group)
@property
def isadmin(self):
return "System admin" in self.permissions
User.is_system_admin = isadmin
UserInvitation = join_model("user_invitations", User, Invitation)
@property
def token_groups(self):
"""The groups the Token owner is a member of."""
return self.created_by.groups
Token.groups = token_groups
Token.accessible_groups = user_or_token_accessible_groups
Token.accessible_streams = user_or_token_accessible_streams
Token.is_system_admin = isadmin
streams = relationship('Stream',
secondary='stream_groups',
back_populates='groups')
telescopes = relationship('Telescope', secondary='group_telescopes')
group_users = relationship(
'GroupUser',
back_populates='group',
cascade='save-update, merge, refresh-expire, expunge',
passive_deletes=True)
users = relationship('User',
secondary='group_users',
back_populates='groups')
filter = relationship("Filter", uselist=False, back_populates="group")
GroupUser = join_model('group_users', Group, User)
GroupUser.admin = sa.Column(sa.Boolean, nullable=False, default=False)
class Stream(Base):
name = sa.Column(sa.String, unique=True, nullable=False)
url = sa.Column(sa.String, unique=True, nullable=False)
username = sa.Column(sa.String)
password = sa.Column(sa.String)
groups = relationship('Group',
secondary='stream_groups',
back_populates='streams')
StreamGroup = join_model('stream_groups', Stream, Group)
allocation = relationship('Allocation', back_populates='requests')
transactions = relationship(
'FacilityTransaction',
back_populates='followup_request',
passive_deletes=True,
order_by="FacilityTransaction.created_at.desc()",
)
target_groups = relationship(
'Group',
secondary='request_groups',
passive_deletes=True,
doc='Groups to share the resulting data from this request with.',
)
photometry = relationship('Photometry', back_populates='followup_request')
spectra = relationship('Spectrum', back_populates='followup_request')
@property
def instrument(self):
return self.allocation.instrument
FollowupRequestTargetGroup = join_model('request_groups', FollowupRequest,
Group)
FollowupRequestTargetGroup.create = (
FollowupRequestTargetGroup.update) = FollowupRequestTargetGroup.delete = (
AccessibleIfUserMatches('followuprequest.requester')
& FollowupRequestTargetGroup.read)
allocations = relationship(
'Allocation',
back_populates="group",
cascade="save-update, merge, refresh-expire, expunge",
passive_deletes=True,
doc="Allocations made to this group.",
)
admission_requests = relationship(
"GroupAdmissionRequest",
back_populates="group",
passive_deletes=True,
doc="User requests to join this group.",
)
GroupUser = join_model('group_users', Group, User)
GroupUser.__doc__ = "Join table mapping `Group`s to `User`s."
GroupUser.admin = sa.Column(
sa.Boolean,
nullable=False,
default=False,
doc="Boolean flag indicating whether the User is an admin of the group.",
)
GroupUser.can_save = sa.Column(
sa.Boolean,
nullable=False,
server_default="true",
doc=
"Boolean flag indicating whether the user should be able to save sources to the group",
)
GroupUser.update = CustomUserAccessControl(groupuser_update_access_logic)
'GroupUser',
back_populates='group',
cascade='save-update, merge, refresh-expire, expunge',
passive_deletes=True)
filter = relationship("Filter", uselist=False, back_populates="group")
photometry = relationship(
"Photometry",
secondary="group_photometry",
back_populates="groups",
cascade="save-update, merge, refresh-expire, expunge",
passive_deletes=True)
single_user_group = sa.Column(sa.Boolean, default=False)
GroupUser = join_model('group_users', Group, User)
GroupUser.admin = sa.Column(sa.Boolean, nullable=False, default=False)
class Stream(Base):
name = sa.Column(sa.String, unique=True, nullable=False)
url = sa.Column(sa.String, unique=True, nullable=False)
username = sa.Column(sa.String)
password = sa.Column(sa.String)
groups = relationship('Group',
secondary='stream_groups',
back_populates='streams',
passive_deletes=True)
class Project(Base):
name = sa.Column(sa.String(), nullable=False)
description = sa.Column(sa.String())
created = sa.Column(sa.DateTime(), default=datetime.datetime.now)
cesium_app_id = sa.Column(sa.String())
users = relationship('User',
secondary='user_projects',
back_populates='projects')
datasets = relationship('Dataset', back_populates='project', cascade='all')
predictions = relationship('Prediction',
back_populates='project',
cascade='all')
user_projects = join_model('user_projects', User, Project)
User.projects = relationship('Project',
secondary='user_projects',
back_populates='users',
cascade='all')
class Dataset(Base):
name = sa.Column(sa.String(), nullable=False)
project_id = sa.Column(sa.ForeignKey('projects.id', ondelete='CASCADE'),
nullable=False,
index=True)
project = relationship('Project', back_populates='datasets')
file_names = sa.Column(sa.ARRAY(sa.VARCHAR()), nullable=False, index=True)
meta_features = sa.Column(sa.ARRAY(sa.VARCHAR()),
nullable=False,
from .comment import CommentOnSpectrum
from .annotation import AnnotationOnSpectrum
from .comment import CommentOnGCN
from .comment import CommentOnShift
from .invitation import Invitation
from .source_notification import SourceNotification
from .filter import Filter
from .stream import Stream, StreamUser
from .survey_efficiency import (
SurveyEfficiencyForObservations,
SurveyEfficiencyForObservationPlan,
)
from .group import Group, accessible_by_group_admins, accessible_by_group_members
from .analysis import AnalysisService, ObjAnalysis
GroupObjAnalysis = join_model("group_obj_analyses", Group, ObjAnalysis)
GroupObjAnalysis.__doc__ = "Join table mapping Groups to ObjAnalysis."
GroupObjAnalysis.delete = GroupObjAnalysis.update = (accessible_by_group_admins
& GroupObjAnalysis.read)
GroupAnalysisService = join_model("group_analysisservices", Group,
AnalysisService)
GroupAnalysisService.__doc__ = "Join table mapping Groups to Analysis Services."
GroupAnalysisService.delete = GroupAnalysisService.update = (
accessible_by_group_admins & GroupAnalysisService.read)
GroupTaxonomy = join_model("group_taxonomy", Group, Taxonomy)
GroupTaxonomy.__doc__ = "Join table mapping Groups to Taxonomies."
GroupTaxonomy.delete = GroupTaxonomy.update = (accessible_by_group_admins
& GroupTaxonomy.read)
sa.literal(
user_or_token.is_admin)).join(
User, cls.user).outerjoin(
Group, User.groups).outerjoin(
GroupStream,
sa.and_(
GroupStream.group_id == Group.id,
GroupStream.stream_id == cls.stream_id,
),
).group_by(cls.id)
# no OR here because Users will always be a member of at least one
# group -- their single user group.
.having(sa.func.bool_and(GroupStream.stream_id.is_(None))))
StreamUser = join_model('stream_users', Stream, User)
StreamUser.__doc__ = "Join table mapping Streams to Users."
StreamUser.create = restricted
# only system admins can modify user stream permissions
# only system admins can modify user stream permissions
StreamUser.delete = CustomUserAccessControl(stream_delete_logic)
StreamPhotometry = join_model("stream_photometry", Stream, Photometry)
StreamPhotometry.__doc__ = "Join table mapping Streams to Photometry."
StreamPhotometry.create = accessible_by_stream_members
StreamPhotometricSeries = join_model("stream_photometric_series", Stream,
PhotometricSeries)
StreamPhotometricSeries.__doc__ = "Join table mapping Streams to PhotometricSeries."
StreamPhotometricSeries.create = accessible_by_stream_members
import sqlalchemy as sa
from sqlalchemy.orm import relationship
from sqlalchemy import func
from baselayer.app.models import (
DBSession,
join_model,
UserAccessControl,
CustomUserAccessControl,
)
from .obj import Obj
from .group import Group, GroupUser, accessible_by_group_members
Source = join_model("sources", Group, Obj)
# This relationship is defined here to prevent a circular import.
# Please see obj.py for other Obj relationships.
Obj.sources = relationship(
Source,
back_populates='obj',
cascade='delete',
passive_deletes=True,
doc="Instances in which a group saved this Obj.",
)
def source_create_access_logic(cls, user_or_token):
user_id = UserAccessControl.user_id_from_user_or_token(user_or_token)
query = DBSession().query(cls)
'CommentOnShift',
back_populates='shift',
cascade='save-update, merge, refresh-expire, expunge, delete',
passive_deletes=True,
order_by="CommentOnShift.created_at",
doc="Comments posted about this Shift.",
)
required_users_number = sa.Column(
sa.Integer,
nullable=True,
doc='The number of users required to join this shift for it to be considered full',
)
ShiftUser = join_model('shift_users', Shift, User)
ShiftUser.__doc__ = "Join table mapping `Shift`s to `User`s."
ShiftUser.admin = sa.Column(
sa.Boolean,
nullable=False,
default=False,
doc="Boolean flag indicating whether the User is an admin of the shift.",
)
# add a column that is a boolean saying if a user needs a replacement for the shift
ShiftUser.needs_replacement = sa.Column(
sa.Boolean,
nullable=False,
default=False,
doc="Boolean flag indicating whether the User needs a replacement for the shift.",
)
name = sa.Column(sa.String(), nullable=False)
description = sa.Column(sa.String())
users = relationship('User', secondary='user_projects',
back_populates='projects')
datasets = relationship('Dataset', back_populates='project',
cascade='all')
featuresets = relationship('Featureset', back_populates='project',
cascade='all')
models = relationship('Model', back_populates='project', cascade='all')
predictions = relationship('Prediction', back_populates='project',
cascade='all')
User.projects = relationship('Project', secondary='user_projects',
back_populates='users', cascade='all')
UserProjects = join_model('user_projects', User, Project)
class Featureset(Base):
project_id = sa.Column(sa.ForeignKey('projects.id', ondelete='CASCADE'),
nullable=False, index=True)
project = relationship('Project', back_populates='featuresets')
dataset_id = sa.Column(sa.ForeignKey('datasets.id'))
dataset = relationship('Dataset')
name = sa.Column(sa.String(), nullable=False)
features_list = sa.Column(sa.ARRAY(sa.VARCHAR()), nullable=False, index=True)
custom_features_script = sa.Column(sa.String())
file_uri = sa.Column(sa.String(), nullable=True, index=True)
task_id = sa.Column(sa.String())
finished = sa.Column(sa.DateTime)
from baselayer.app.models import DBSession, restricted, CustomUserAccessControl
from .photometry import Photometry
from .taxonomy import Taxonomy
from .comment import Comment
from .annotation import Annotation
from .classification import Classification
from .spectrum import Spectrum
from .comment import CommentOnSpectrum
from .annotation import AnnotationOnSpectrum
from .invitation import Invitation
from .source_notification import SourceNotification
from .filter import Filter
from .stream import Stream, StreamUser
from .group import Group, accessible_by_group_admins, accessible_by_group_members
GroupTaxonomy = join_model("group_taxonomy", Group, Taxonomy)
GroupTaxonomy.__doc__ = "Join table mapping Groups to Taxonomies."
GroupTaxonomy.delete = GroupTaxonomy.update = (accessible_by_group_admins
& GroupTaxonomy.read)
GroupComment = join_model("group_comments", Group, Comment)
GroupComment.__doc__ = "Join table mapping Groups to Comments."
GroupComment.delete = GroupComment.update = (accessible_by_group_admins
& GroupComment.read)
GroupAnnotation = join_model("group_annotations", Group, Annotation)
GroupAnnotation.__doc__ = "Join table mapping Groups to Annotation."
GroupAnnotation.delete = GroupAnnotation.update = (accessible_by_group_admins
& GroupAnnotation.read)
GroupClassification = join_model("group_classifications", Group,
doc='Groups to share the resulting data from this request with.',
)
transactions = relationship(
'FacilityTransaction',
back_populates='observation_plan_request',
passive_deletes=True,
order_by="FacilityTransaction.created_at.desc()",
)
@property
def instrument(self):
return self.allocation.instrument
ObservationPlanRequestTargetGroup = join_model('observationplan_groups',
ObservationPlanRequest, Group)
ObservationPlanRequestTargetGroup.create = (
ObservationPlanRequestTargetGroup.update
) = ObservationPlanRequestTargetGroup.delete = (
AccessibleIfUserMatches('followuprequest.requester')
& ObservationPlanRequestTargetGroup.read)
class EventObservationPlan(Base):
"""Tiling information, including the event time, localization ID, tile IDs,
and plan name"""
observation_plan_request_id = sa.Column(
sa.ForeignKey('observationplanrequests.id', ondelete="CASCADE"),
nullable=False,
doc='ObservationPlanRequest ID',
ondelete='CASCADE'),
nullable=False,
index=True)
allocation = relationship('Allocation',
back_populates='default_observation_plans')
target_groups = relationship(
'Group',
secondary='default_observationplan_groups',
passive_deletes=True,
doc=
'Groups to share the resulting data from this default request with.',
)
DefaultObservationPlanRequestTargetGroup = join_model(
'default_observationplan_groups', DefaultObservationPlanRequest, Group)
DefaultObservationPlanRequestTargetGroup.create = (
DefaultObservationPlanRequestTargetGroup.update
) = DefaultObservationPlanRequestTargetGroup.delete = (
AccessibleIfUserMatches('defaultobservationplanrequest.requester')
& DefaultObservationPlanRequestTargetGroup.read)
class ObservationPlanRequest(Base):
"""A request for an EventObservationPlan."""
# TODO: Make read-accessible via target groups
create = read = AccessibleIfRelatedRowsAreAccessible(gcnevent="read",
allocation="read")
update = delete = (
(AccessibleIfUserMatches('allocation.group.users')
