complicated_contract.py

from firm.precedents.corporate.agreements import StartupShareholdersAgreement
from firm.precedents.corporate.mixins import DragAlongMixin, RightOfRefusalMixin
from jursidictions import Delaware
from votes import super_majority
from legal_entities import Corporation, Individual

# First lets create some parties to be part of our agreement
john = Individual(name='John Smith', jurisdiction=UK)
sam = Individual(name='Sam Smith', jurisdiction=Delaware)

investor_corp = Corporation(name='Investor Co.', jurisdiciton=UK)
johns_mom = Individual(name='Jane Smith', jurisdiction=UK)
jeff = Individual(name="Jeff Taylor", jurisdiction=UK)
    
# Here we are creating a new shareholders agreement by sublcassing
# StartupShareholdersAgreement (i.e. using it as a precedent).
# StartupShareholdersAgreement could in turn be a subclass of ShareholdersAgreement
# which has the most generic terms a shareholders agreement can expect.
#
# We are also mixing in two complicated sections (1) a drag-along right
# and (b) a right of first refusal.
class StartUpCoShareholdersAgreement(StartupShareholdersAgreement, 
                                     DragAlongMixin, RightOfRefusalMixin):
    # Setting the jurisdiction for the contract here could influence code
    # written in StartupShareholdersAgreement (e.g. governing law provision)
    # and also one of the mixins (e.g. statutory minimum notice period for RoFR)
    jurisdiction = Delaware
    
    # StartupShareholdersAgreement is a special kind of ShareholdersAgreement which 
    # has a concept of founders.  We can define who the founders are and it will
    # effect how the agreement operates.
    founders = [john, sam]
    shareholders = [john, sam, investor_corp, johns_mom, jeff]

    def determine_board_vote(self, votes):
        # here we are deffering to our precedent to appoint the board based
        # on an input value `votes`.  Our StartupShareholdersAgreement might have
        # existing logic to elect by super majority/majority/slate/indivudal, etc.
        board = super(StartupShareholdersAgreement, self).appoint_board(votes)
        # but we are adding a guy named Jeff who should always be on the board
        board.append(jeff)
        return board
    
    def validate_board(self, board):
        # our precedent start up agreement will have
        # logic to determine what a valid board is.  For instance
        # it might require that all the founders are on the board.
        # Going further into the programming language, there may be
        # a layer that requires all directors to be individuals, or
        # requires a percentage of directors to have residency in a given country
        # All of this we get for free and can of course override it if it doesn't make sense.
        
        # Here we will layer on one additional requirement
        brit_directors = [person for person in board if person.jurisdiction == UK]
        if not len(brit_directors) > 3:
            # raising this exception could trigger an entire set of logic in the
            # StartupShareholdersAgreement base class that deals with how to handle a situation
            # where the board is invalid.
            raise InvalidBoardException('Must have at least 3 directors who reside in the UK')