Skip to content

User

User

Bases: BaseModel

User model

Attributes:

Name Type Description
id str

ID of the user
username str

Username of the user
email Union[str, None]

Email of the user, only available for own user
jwt_token Union[str, None]

JWT token of the user, only available for own user
email_subscription_type Union[str, None]

Email subscription type of the user, only available for own user
capabilities UserCapabilities

Capabilities of the user
gravatar_hash str

Gravatar hash of the user
ref_id str

Ref ID of the user
registration_date int

Registration date of the user
version int

Version of the user
my_user bool

Flag if the user is my user
client Client

Client
Source code in alpha_trader/user/__init__.py 
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
class User(BaseModel):
    """
    User model

    Attributes:
        id: ID of the user
        username: Username of the user
        email: Email of the user, only available for own user
        jwt_token: JWT token of the user, only available for own user
        email_subscription_type: Email subscription type of the user, only available for own user
        capabilities: Capabilities of the user
        gravatar_hash: Gravatar hash of the user
        ref_id: Ref ID of the user
        registration_date: Registration date of the user
        version: Version of the user
        my_user: Flag if the user is my user
        client: Client
    """

    id: str
    username: str
    email: Union[str, None]
    jwt_token: Union[str, None]
    email_subscription_type: Union[str, None]
    capabilities: UserCapabilities
    gravatar_hash: str
    ref_id: str
    registration_date: int
    version: int
    my_user: bool
    client: Client

    @staticmethod
    def initialize_from_api_response(api_response: Dict, client: Client):
        return User(
            id=api_response["id"],
            username=api_response["username"],
            email=api_response.get("emailAddress", None),
            jwt_token=api_response.get("jwtToken", None),
            email_subscription_type=api_response.get("emailSubscriptionType", None),
            capabilities=UserCapabilities(
                partner_id=api_response["userCapabilities"].get("partnerId", None),
                achievement_count=api_response["userCapabilities"]["achievementCount"],
                achievement_total=api_response["userCapabilities"]["achievementTotal"],
                last_sponsoring_date=api_response["userCapabilities"][
                    "lastSponsoringDate"
                ],
                level_2_user_end_date=api_response["userCapabilities"][
                    "level2UserEndDate"
                ],
                locale=api_response["userCapabilities"]["locale"],
                premium_end_date=api_response["userCapabilities"]["premiumEndDate"],
                sponsored_hours=api_response["userCapabilities"]["sponsoredHours"],
                team_department=api_response["userCapabilities"]["teamDepartment"],
                team_role=api_response["userCapabilities"]["teamRole"],
                team_role_description=api_response["userCapabilities"][
                    "teamRoleDescription"
                ],
                level_2_user=api_response["userCapabilities"]["level2User"],
                partner=api_response["userCapabilities"]["partner"],
                premium=api_response["userCapabilities"]["premium"],
            ),
            gravatar_hash=api_response["gravatarHash"],
            ref_id=api_response["refId"],
            registration_date=api_response["registrationDate"],
            version=api_response["version"],
            my_user=api_response["myUser"],
            client=client,
        )

    @property
    def achievements(self) -> List[Achievement]:
        """
            Achievements of the user

        Returns:
            List of achievements
        """
        response = self.client.request(
            "GET", f"api/v2/userachievements/{self.username}"
        )

        logger.info("Retrieved achievements for user")

        return [
            Achievement.initialize_from_api_response(res, self.client)
            for res in response.json()
        ]

    @property
    def securities_account(self):
        """
            Get the securities account for the user

        Returns:
            Securities account
        """
        if not self.my_user:
            raise Exception("Cannot retrieve securities account for other users")

        response = self.client.request("GET", "api/v2/my/securitiesaccount")

        return SecuritiesAccount.initialize_from_api_response(
            response.json(), self.client
        )

    def found_company(
        self,
        company_name: str,
        cash_deposit: float,
        custom_number_of_shares: Union[int, None] = None,
        custom_asin: Union[str, None] = None,
    ) -> Company:
        """
            Found a company
        Args:
            company_name: Name of the company
            cash_deposit: Initial cash that should be deposited to the company
            custom_number_of_shares: Custom number of shares (premium feature)
            custom_asin: Custom ASIN (premium feature)

        Returns:
            Company
        """
        from alpha_trader.company import Company

        data = {
            "name": company_name,
            "cashDeposit": cash_deposit,
            "customNumberOfShares": custom_number_of_shares,
            "customAsin": custom_asin,
        }

        response = self.client.request("POST", "api/companies", data=data)

        return Company.initialize_from_api_response(response.json(), self.client)

    @property
    def companies(self) -> List[Company]:
        """
            Get all companies that the user is CEO of
        Returns:
            List of companies
        """
        from alpha_trader.company import Company

        response = self.client.request("GET", f"api/companies/ceo/userid/{self.id}")

        return [
            Company.initialize_from_api_response(res, self.client)
            for res in response.json()
        ]

    @property
    def salary(self) -> float:
        """
            Get the daily salary for the user
        Returns:
            Daily salary
        """
        response = self.client.request("GET", f"api/v2/possibledailysalary/{self.id}")

        return response.json()["value"]

    @property
    def bank_account(self) -> BankAccount:
        """
            Get the bank account for the user
        Returns:
            Bank account
        """
        if not self.my_user:
            raise Exception("Cannot retrieve bank account for other users")

        response = self.client.request("GET", "api/v2/my/bankaccounts/")

        return BankAccount.initialize_from_api_response(response.json()[0], self.client)

    def retrieve_salary(self) -> None:
        """
            Retrieve all the salaries for the user
        Returns:
            None

        """
        if not self.my_user:
            raise Exception("Cannot retrieve salary for other users.")

        response = self.client.request("PUT", "api/v2/my/salarypayments")

        if response.status_code == 200:
            logger.info("Successfully retrieved salary")

achievements: List[Achievement] property 

Achievements of the user

Returns:

Type Description
List[Achievement]

List of achievements

bank_account: BankAccount property 

Get the bank account for the user

Returns: Bank account

companies: List[Company] property 

Get all companies that the user is CEO of

Returns: List of companies

salary: float property 

Get the daily salary for the user

Returns: Daily salary

securities_account property 

Get the securities account for the user

Returns:

Type Description

Securities account

found_company(company_name, cash_deposit, custom_number_of_shares=None, custom_asin=None) 

Found a company

Args: company_name: Name of the company cash_deposit: Initial cash that should be deposited to the company custom_number_of_shares: Custom number of shares (premium feature) custom_asin: Custom ASIN (premium feature)

Returns:

Type Description
Company

Company
Source code in alpha_trader/user/__init__.py 
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
def found_company(
    self,
    company_name: str,
    cash_deposit: float,
    custom_number_of_shares: Union[int, None] = None,
    custom_asin: Union[str, None] = None,
) -> Company:
    """
        Found a company
    Args:
        company_name: Name of the company
        cash_deposit: Initial cash that should be deposited to the company
        custom_number_of_shares: Custom number of shares (premium feature)
        custom_asin: Custom ASIN (premium feature)

    Returns:
        Company
    """
    from alpha_trader.company import Company

    data = {
        "name": company_name,
        "cashDeposit": cash_deposit,
        "customNumberOfShares": custom_number_of_shares,
        "customAsin": custom_asin,
    }

    response = self.client.request("POST", "api/companies", data=data)

    return Company.initialize_from_api_response(response.json(), self.client)

retrieve_salary() 

Retrieve all the salaries for the user

Returns: None

Source code in alpha_trader/user/__init__.py 
233
234
235
236
237
238
239
240
241
242
243
244
245
246
def retrieve_salary(self) -> None:
    """
        Retrieve all the salaries for the user
    Returns:
        None

    """
    if not self.my_user:
        raise Exception("Cannot retrieve salary for other users.")

    response = self.client.request("PUT", "api/v2/my/salarypayments")

    if response.status_code == 200:
        logger.info("Successfully retrieved salary")

UserCapabilities

Bases: BaseModel

User capabilities model

Attributes:

Name Type Description
partner_id Union[str, None]

Partner ID of the user
achievement_count Union[None, int]

Achievement count of the user
achievement_total Union[None, int]

Achievement total of the user
last_sponsoring_date Union[None, str]

Last sponsoring date of the user
level_2_user_end_date Union[None, str]

Level 2 user end date of the user
locale str

Locale of the user
premium_end_date Union[None, int]

Premium end date of the user
sponsored_hours int

Sponsored hours of the user
team_department Union[None, str]

Team department of the user
team_role str

Team role of the user
team_role_description Union[None, str]

Team role description of the user
level_2_user bool

Level 2 user of the user
partner bool

Flag if the user is a partner
premium bool

Flag if the user is premium
Source code in alpha_trader/user/__init__.py 
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
class UserCapabilities(BaseModel):
    """
    User capabilities model

    Attributes:
        partner_id: Partner ID of the user
        achievement_count: Achievement count of the user
        achievement_total: Achievement total of the user
        last_sponsoring_date: Last sponsoring date of the user
        level_2_user_end_date: Level 2 user end date of the user
        locale: Locale of the user
        premium_end_date: Premium end date of the user
        sponsored_hours: Sponsored hours of the user
        team_department: Team department of the user
        team_role: Team role of the user
        team_role_description: Team role description of the user
        level_2_user: Level 2 user of the user
        partner: Flag if the user is a partner
        premium: Flag if the user is premium
    """

    partner_id: Union[str, None]
    achievement_count: Union[None, int]
    achievement_total: Union[None, int]
    last_sponsoring_date: Union[None, str]
    level_2_user_end_date: Union[None, str]
    locale: str
    premium_end_date: Union[None, int]
    sponsored_hours: int
    team_department: Union[None, str]
    team_role: str
    team_role_description: Union[None, str]
    level_2_user: bool
    partner: bool
    premium: bool