Add teams /1: database definitions (#545)

* Define user team table

* Add .pep8speaks.yml config

Author: rth

.pep8speaks.yml

@@ -0,0 +1,2 @@
+pycodestyle:
+    max-line-length: 88 # black defaults

db_engine.yml

@@ -1,2 +1,2 @@
 db_owner: postgres # to find out your db_owner type psql -l in the terminal
-                   # and check who is the owner of your postgres database 
+                   # and check who is the owner of your postgres database

ramp-database/ramp_database/model/event.py

@@ -339,7 +339,14 @@ def n_jobs(self):
     @property
     def n_participants(self):
         """int: The number of participants to the event."""
-        return len(self.event_teams)
+        # Only select individual teams
+        return len(
+            [
+                event_team
+                for event_team in self.event_teams
+                if event_team.team.is_individual
+            ]
+        )
 
 
 class EventScoreType(Model):

ramp-database/ramp_database/model/submission.py

@@ -178,13 +178,18 @@ class Submission(Model):
     test_time_cv_std = Column(Float, default=0.0)
     # the maximum memory size used when training/testing, in MB
     max_ram = Column(Float, default=0.0)
+    # This is intentionally optional, and not a ForeignKey, to avoid DB migration
+    # issues. This field is mostly used for audits to know which user
+    # made a submission within a team.
+    user_name = Column(String)
     # later also ramp_id
     UniqueConstraint(event_team_id, name, name="ts_constraint")
 
-    def __init__(self, name, event_team, session=None):
+    def __init__(self, name, event_team, session=None, user_name=None):
         self.name = name
         self.event_team = event_team
         self.session = inspect(event_team).session
+        self.user_name = user_name
         sha_hasher = hashlib.sha1()
         sha_hasher.update(_encode_string(self.event.name))
         sha_hasher.update(_encode_string(self.team.name))

ramp-database/ramp_database/model/team.py

@@ -1,16 +1,20 @@
 import datetime
 
+from sqlalchemy import Enum
 from sqlalchemy import Column
 from sqlalchemy import String
 from sqlalchemy import Integer
+from sqlalchemy import Boolean
 from sqlalchemy import DateTime
 from sqlalchemy import ForeignKey
 from sqlalchemy.orm import backref
 from sqlalchemy.orm import relationship
 
+from sqlalchemy import sql
+
 from .base import Model
 
-__all__ = ["Team"]
+__all__ = ["Team", "UserTeam"]
 
 
 class Team(Model):
@@ -22,10 +26,8 @@ class Team(Model):
         The name of the team.
     admin : :class:`ramp_database.model.User`
         The admin user of the team.
-    initiator : None or :class:`ramp_database.model.Team`, default is None
-        The team initiating a merging.
-    acceptor : None or :class:`ramp_database.model.Team`, default is None
-        The team accepting a merging.
+    is_individual : bool
+        This team is an individual team.
 
     Attributes
     ----------
@@ -37,14 +39,6 @@ class Team(Model):
         The ID of the admin user.
     admin : :class:`ramp_database.model.User`
         The admin user instance.
-    initiator_id : int
-        The ID of the team asking for merging.
-    initiator : :class:`ramp_database.model.Team`
-        The team instance asking for merging.
-    acceptor_id : int
-        The ID of the team accepting the merging.
-    acceptor : :class:`ramp_database.model.Team`
-        The team instance accepting the merging.
     team_events : :class:`ramp_database.model.EventTeam`
         A back-reference to the events to which the team is enroll.
     """
@@ -59,30 +53,68 @@ class Team(Model):
         "User", backref=backref("admined_teams", cascade="all, delete")
     )
 
-    # initiator asks for merge, acceptor accepts
-    initiator_id = Column(Integer, ForeignKey("teams.id"), default=None)
-    initiator = relationship(
-        "Team", primaryjoin=("Team.initiator_id == Team.id"), uselist=False
-    )
-
-    acceptor_id = Column(Integer, ForeignKey("teams.id"), default=None)
-    acceptor = relationship(
-        "Team", primaryjoin=("Team.acceptor_id == Team.id"), uselist=False
-    )
-
+    is_individual = Column(Boolean, default=True, nullable=False)
     creation_timestamp = Column(DateTime, nullable=False)
 
-    def __init__(self, name, admin, initiator=None, acceptor=None):
+    def __init__(self, name, admin, is_individual=True):
         self.name = name
         self.admin = admin
-        self.initiator = initiator
-        self.acceptor = acceptor
         self.creation_timestamp = datetime.datetime.utcnow()
+        self.is_individual = is_individual
 
     def __str__(self):
-        return "Team({})".format(self.name)
+        return f"Team({self.name})"
+
+    def __repr__(self):
+        return (
+            f"Team(name={self.name}, admin_name={self.admin.name}, "
+            f"is_individual={self.is_individual})"
+        )
+
+
+class UserTeam(Model):
+    """User to team many-to-many association table.
+
+    Parameters
+    ----------
+    user_id : int
+        The ID of the user.
+    team_id : int
+        The ID of the team.
+    status: str
+        The relationship status. One of "asked", "accepted".
+
+    Attributes
+    ----------
+    id : int
+        The ID of the table row.
+    update_timestamp : datetime
+        Last updated timestamp.
+    """
+
+    __tablename__ = "user_teams"
+
+    id = Column(Integer, primary_key=True)
+    user_id = Column(Integer, ForeignKey("users.id"))
+    user = relationship(
+        "User", backref=backref("user_user_team", cascade="all, delete")
+    )
+    team_id = Column(Integer, ForeignKey("teams.id"))
+    team = relationship(
+        "Team", backref=backref("team_user_team", cascade="all, delete")
+    )
+    status = Column(Enum("asked", "accepted", name="status"), default="asked")
+    update_timestamp = Column(
+        DateTime, onupdate=sql.func.now(), server_default=sql.func.now()
+    )
+
+    def __init__(self, user_id, team_id, status="asked"):
+        self.user_id = user_id
+        self.team_id = team_id
+        self.status = status
 
     def __repr__(self):
-        return "Team(name={}, admin_name={}, initiator={}, acceptor={})".format(
-            self.name, self.admin.name, self.initiator, self.acceptor
+        return (
+            f"UserTeam(user_id={self.user_id}, team_id={self.team_id}, "
+            f"status='{self.status}')"
         )

ramp-database/ramp_database/model/tests/test_team.py

@@ -7,6 +7,7 @@
 from ramp_utils.testing import database_config_template
 from ramp_utils.testing import ramp_config_template
 
+from ramp_database.model import Team, UserTeam, User
 from ramp_database.model import EventTeam
 from ramp_database.model import Model
 
@@ -33,9 +34,45 @@ def session_scope_module(database_connection):
 
 def test_team_model(session_scope_module):
     team = get_team_by_name(session_scope_module, "test_user")
-    assert re.match(r"Team\(name=.*test_user.*, admin_name=.*test_user.*\)", repr(team))
+    expr = r"Team\(name=.*test_user.*, admin_name=.*test_user.*\, is_individual=True\)"
+    assert re.match(expr, repr(team))
     assert re.match(r"Team\(.*test_user.*\)", str(team))
 
+    assert team.is_individual is True
+
+
+def test_user_team_model(session_scope_module):
+    """Test user / team association"""
+    session = session_scope_module
+    # Create a new user and team, so that we can remove them in the end.
+    user = User("user-75", "user-75", "", "", "")
+    session.add(user)
+    session.commit()
+    # Create a new non individual team
+    team = Team(name="group_team_75", admin=user, is_individual=False)
+    session.add(team)
+    session.commit()
+
+    # And finally a user-team association
+    user_team = UserTeam(team_id=team.id, user_id=user.id, status="accepted")
+    session.add(user_team)
+    session.commit()
+
+    msg = r"UserTeam\(user_id=4, team_id=4, status='accepted'\)"
+    assert re.match(msg, repr(user_team))
+    assert team.is_individual is False
+
+    # Check backrefs
+    assert user_team.user.name == user.name
+    assert user_team.team.name == team.name
+
+    # When a user is deleted, its team and user/team association are also deleted
+    session.delete(user)
+    session.commit()
+    assert session.query(User).filter_by(name="user-75").first() is None
+    assert session.query(Team).filter_by(name="group_team_75").first() is None
+    assert session.query(UserTeam).filter_by(user_id=4).first() is None
+
 
 @pytest.mark.parametrize("backref, expected_type", [("team_events", EventTeam)])
 def test_event_model_backref(session_scope_module, backref, expected_type):