inmotion-sdk 0.2.3__py3-none-any.whl

inmotion/__init__.py

@@ -0,0 +1,37 @@
+from inmotion.api import (
+    InMotionSession,
+    InMotionAccounts,
+    InMotionActivities,
+    InMotionActivityConfig,
+    InMotionApiKeys,
+    InMotionAudit,
+    InMotionDataStream,
+    InMotionDevKeys,
+    InMotionEvents,
+    InMotionFolio,
+    InMotionModel,
+    InMotionRasterOverlay,
+    InMotionShape,
+    InMotionShapeGenerator,
+    InMotionUpload,
+    InMotionUser,
+)
+
+__all__ = [
+    "InMotionSession",
+    "InMotionAccounts",
+    "InMotionActivities",
+    "InMotionActivityConfig",
+    "InMotionApiKeys",
+    "InMotionAudit",
+    "InMotionDataStream",
+    "InMotionDevKeys",
+    "InMotionEvents",
+    "InMotionFolio",
+    "InMotionModel",
+    "InMotionRasterOverlay",
+    "InMotionShape",
+    "InMotionShapeGenerator",
+    "InMotionUpload",
+    "InMotionUser",
+]

inmotion/accounts.py

@@ -0,0 +1,229 @@
+from dataclasses import asdict
+
+from inmotion.api import InMotionSession, InMotionAccounts
+from inmotion.models import (
+    AccountDetailsModel,
+    AccountMarkedForDeletionModel,
+    AccountModel,
+    AccountPrivilegesModel,
+    AccountTagsModel,
+    AccountUpdateBatchCommandModel,
+    AccountUpdateBatchResultsModel,
+    AccountUserSummaryModel,
+    AccountUserUnregisteredModel,
+    DeviceConfigSyncRequestModel,
+    DeviceConfigSyncResultModel,
+    UserAccountSummaryModel,
+)
+from inmotion.utils import request_json, request_json_map, stringify
+
+
+def _text_headers(session: InMotionSession, content: str) -> dict[str, str]:
+    headers = session.build_headers(content=content)
+    headers['Content-Type'] = 'text/plain'
+    return headers
+
+
+class InMotionAccountsImpl(InMotionAccounts):
+
+    def __init__(self, session: InMotionSession):
+        self._session = session
+        self._prefix_path = f"{session.base_url}{session.api_path}"
+
+    def find_account(self, account_key: str) -> AccountDetailsModel:
+        return request_json('GET', f"{self._prefix_path}/account/{account_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve account',
+                             AccountDetailsModel)
+
+    def find_account_tags(self, account_key: str) -> AccountTagsModel:
+        return request_json('GET', f"{self._prefix_path}/account/tags/{account_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve account tags',
+                             AccountTagsModel)
+
+    def update_account(self, account_key: str, account: AccountModel) -> AccountDetailsModel:
+        account_data = stringify(account)
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}",
+                             self._session.build_headers(content=account_data),
+                             account_data,
+                             'Failed to update account',
+                             AccountDetailsModel)
+
+    def find_account_users(self, account_key: str) -> list[AccountUserSummaryModel]:
+        return request_json('GET', f"{self._prefix_path}/account/{account_key}/users",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve account users',
+                             AccountUserSummaryModel, many=True)
+
+    def register_account_user(self, account_key: str, user_key: str, privileges: AccountPrivilegesModel) -> list[AccountUserSummaryModel]:
+        privileges_data = stringify(privileges)
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/register/{user_key}",
+                             self._session.build_headers(content=privileges_data),
+                             privileges_data,
+                             'Failed to register account user',
+                             AccountUserSummaryModel, many=True)
+
+    def unregister_account_user(self, account_key: str, user_key: str) -> AccountUserUnregisteredModel:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/unregister/{user_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to unregister account user',
+                             AccountUserUnregisteredModel)
+
+    def batch_update_account_users(self, account_key: str, commands: list[AccountUpdateBatchCommandModel]) -> AccountUpdateBatchResultsModel:
+        batch_data = stringify([asdict(c) for c in commands])
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/batch",
+                             self._session.build_headers(content=batch_data),
+                             batch_data,
+                             'Failed to batch update account users',
+                             AccountUpdateBatchResultsModel)
+
+    def create_account_only(self, account: AccountModel) -> AccountDetailsModel:
+        account_data = stringify(account)
+        return request_json('POST', f"{self._prefix_path}/account/create/only",
+                             self._session.build_headers(content=account_data),
+                             account_data,
+                             'Failed to create account',
+                             AccountDetailsModel)
+
+    def mark_account_for_deletion(self, account_key: str, and_user: bool) -> AccountMarkedForDeletionModel:
+        and_user_segment = 'true' if and_user else 'false'
+        return request_json('DELETE', f"{self._prefix_path}/account/delete/{account_key}/{and_user_segment}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to mark account for deletion',
+                             AccountMarkedForDeletionModel)
+
+    def find_my_accounts(self) -> dict[str, UserAccountSummaryModel]:
+        return request_json_map('GET', f"{self._prefix_path}/accounts",
+                                 self._session.build_headers(content=''),
+                                 '',
+                                 'Failed to retrieve accounts',
+                                 UserAccountSummaryModel)
+
+    def fetch_global_device_configs(self) -> dict:
+        return request_json('GET', f"{self._prefix_path}/device-config",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to fetch global device configs')
+
+    def sync_device_configs(self, request: DeviceConfigSyncRequestModel) -> DeviceConfigSyncResultModel:
+        request_data = stringify(request)
+        return request_json('POST', f"{self._prefix_path}/device-config/sync",
+                             self._session.build_headers(content=request_data),
+                             request_data,
+                             'Failed to sync device configs',
+                             DeviceConfigSyncResultModel)
+
+    def list_standard_data_types(self, account_key: str) -> list[dict]:
+        return request_json('GET', f"{self._prefix_path}/account/{account_key}/sdt/data-types",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to list standard data types')
+
+    def create_standard_data_type(self, account_key: str, yaml_document: str) -> dict:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/sdt/data-types",
+                             _text_headers(self._session, yaml_document),
+                             yaml_document,
+                             'Failed to create standard data type')
+
+    def update_standard_data_type(self, account_key: str, key: str, yaml_document: str) -> dict:
+        return request_json('PUT', f"{self._prefix_path}/account/{account_key}/sdt/data-types/{key}",
+                             _text_headers(self._session, yaml_document),
+                             yaml_document,
+                             'Failed to update standard data type')
+
+    def delete_standard_data_type(self, account_key: str, key: str) -> None:
+        request_json('DELETE', f"{self._prefix_path}/account/{account_key}/sdt/data-types/{key}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to delete standard data type')
+
+    def list_standard_data_variant_types(self, account_key: str) -> list[dict]:
+        return request_json('GET', f"{self._prefix_path}/account/{account_key}/sdt/data-variant-types",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to list standard data variant types')
+
+    def create_standard_data_variant_type(self, account_key: str, yaml_document: str) -> dict:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/sdt/data-variant-types",
+                             _text_headers(self._session, yaml_document),
+                             yaml_document,
+                             'Failed to create standard data variant type')
+
+    def update_standard_data_variant_type(self, account_key: str, key: str, yaml_document: str) -> dict:
+        return request_json('PUT', f"{self._prefix_path}/account/{account_key}/sdt/data-variant-types/{key}",
+                             _text_headers(self._session, yaml_document),
+                             yaml_document,
+                             'Failed to update standard data variant type')
+
+    def delete_standard_data_variant_type(self, account_key: str, key: str) -> None:
+        request_json('DELETE', f"{self._prefix_path}/account/{account_key}/sdt/data-variant-types/{key}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to delete standard data variant type')
+
+    def fetch_device_configs(self, account_key: str, preview: bool = False) -> dict:
+        qs = '?preview=true' if preview else ''
+        return request_json('GET', f"{self._prefix_path}/account/{account_key}/device-config{qs}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to fetch device configs')
+
+    def list_device_configs(self, account_key: str) -> dict:
+        return request_json('GET', f"{self._prefix_path}/account/{account_key}/device-configs",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to list device configs')
+
+    def create_device_config(self, account_key: str, yaml_document: str) -> dict:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/device-configs",
+                             _text_headers(self._session, yaml_document),
+                             yaml_document,
+                             'Failed to create device config')
+
+    def save_device_config(self, account_key: str, name: str, yaml_document: str) -> dict:
+        return request_json('PUT', f"{self._prefix_path}/account/{account_key}/device-configs/{name}",
+                             _text_headers(self._session, yaml_document),
+                             yaml_document,
+                             'Failed to save device config')
+
+    def delete_device_config(self, account_key: str, name: str) -> None:
+        request_json('DELETE', f"{self._prefix_path}/account/{account_key}/device-configs/{name}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to delete device config')
+
+    def start_device_config_development(self, account_key: str, name: str) -> dict:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/device-configs/{name}/development",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to start device config development')
+
+    def discard_device_config_development(self, account_key: str, name: str) -> None:
+        request_json('DELETE', f"{self._prefix_path}/account/{account_key}/device-configs/{name}/development",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to discard device config development')
+
+    def publish_device_config(self, account_key: str, name: str, semantic_version: str) -> dict:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/device-configs/{name}/publish?semanticVersion={semantic_version}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to publish device config')
+
+    def withdraw_device_config(self, account_key: str, name: str, version: int) -> dict:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/device-configs/{name}/{version}/withdraw",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to withdraw device config')
+
+    def republish_device_config(self, account_key: str, name: str, version: int) -> dict:
+        return request_json('POST', f"{self._prefix_path}/account/{account_key}/device-configs/{name}/{version}/republish",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to republish device config')

inmotion/activities.py

@@ -0,0 +1,381 @@
+from dataclasses import asdict
+from datetime import datetime
+from typing import Optional
+
+from inmotion.api import InMotionSession, InMotionActivities
+from inmotion.models import (
+    ActivitiesModel,
+    ActivityAnalyticsRequestModel,
+    ActivityAnalyticsResultModel,
+    ActivityBatchCommandsModel,
+    ActivityBatchResultModel,
+    ActivitySearchFilterModel,
+    ActivityTrackMetricsResultModel,
+    ActivityUpdateResponseModel,
+    ActivityVariableStatsResultModel,
+    CreateSiteActivityModel,
+    CreateTrackActivityModel,
+    LastActivitiesModel,
+    MasterDataModel,
+    ModelFieldGroupModel,
+    QCConfigModel,
+    SetModelFieldValueRequestModel,
+    SiteActivityModel,
+    SiteRecordsModel,
+    TrackActivityModel,
+    TrackRecordsModel,
+    UpdateSiteActivityModel,
+    UpdateTrackActivityModel,
+)
+from inmotion.utils import request_json, request_raw, stringify
+
+
+class InMotionActivitiesImpl(InMotionActivities):
+
+    def __init__(self, session: InMotionSession):
+        self._session = session
+        self._prefix_path = f"{session.base_url}{session.api_path}"
+
+    def find_activities(self, act_filter: ActivitySearchFilterModel) -> ActivitiesModel:
+        filter_data = stringify(act_filter)
+        postfix_path = f"activities/{self._session.account}"
+        return request_json('POST', f"{self._prefix_path}/{postfix_path}",
+                             self._session.build_headers(content=filter_data),
+                             filter_data,
+                             'Failed to retrieve activities',
+                             ActivitiesModel)
+
+    def find_activities_within_time_range(self, act_filter: ActivitySearchFilterModel, start: datetime, finish: datetime) -> ActivitiesModel:
+        start_millis = int(start.timestamp() * 1000)
+        finish_millis = int(finish.timestamp() * 1000)
+        postfix_path = f"activities/{self._session.account}/{start_millis}/{finish_millis}"
+        return request_json('GET', f"{self._prefix_path}/{postfix_path}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve activities',
+                             ActivitiesModel)
+
+    def find_latest_activity_stats(self, since: datetime, max_records: int) -> LastActivitiesModel:
+        since_millis = int(since.timestamp() * 1000)
+        postfix_path = f"activities/latest/{self._session.account}/{since_millis}/{max_records}"
+        return request_json('GET', f"{self._prefix_path}/{postfix_path}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to load latest activities',
+                             LastActivitiesModel)
+
+    def find_latest_activity_stats_by_type(self, since: datetime, coord_conv: str) -> LastActivitiesModel:
+        since_millis = int(since.timestamp() * 1000)
+        postfix_path = f"activities/latest/{self._session.account}/{since_millis}/{coord_conv}"
+        return request_json('GET', f"{self._prefix_path}/{postfix_path}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to load latest activities',
+                             LastActivitiesModel)
+
+    def find_activity_master_data(self) -> MasterDataModel:
+        return request_json('GET', f"{self._prefix_path}/activity/master-data",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve activity master data',
+                             MasterDataModel)
+
+    def find_activity_analytics(self, request: ActivityAnalyticsRequestModel) -> ActivityAnalyticsResultModel:
+        request_data = stringify(request)
+        return request_json('POST', f"{self._prefix_path}/activities/analytics",
+                             self._session.build_headers(content=request_data),
+                             request_data,
+                             'Failed to retrieve activity analytics',
+                             ActivityAnalyticsResultModel)
+
+    def find_activity_track_metrics(self, request: ActivityAnalyticsRequestModel) -> ActivityTrackMetricsResultModel:
+        request_data = stringify(request)
+        return request_json('POST', f"{self._prefix_path}/activities/analytics/track-metrics",
+                             self._session.build_headers(content=request_data),
+                             request_data,
+                             'Failed to retrieve activity track metrics',
+                             ActivityTrackMetricsResultModel)
+
+    def find_activity_variable_stats(self, request: ActivityAnalyticsRequestModel) -> ActivityVariableStatsResultModel:
+        request_data = stringify(request)
+        return request_json('POST', f"{self._prefix_path}/activities/analytics/variable-stats",
+                             self._session.build_headers(content=request_data),
+                             request_data,
+                             'Failed to retrieve activity variable stats',
+                             ActivityVariableStatsResultModel)
+
+    def batch_record_update(self, commands: ActivityBatchCommandsModel) -> list[ActivityBatchResultModel]:
+        commands_data = stringify(commands)
+        return request_json('POST', f"{self._prefix_path}/activities/batch",
+                             self._session.build_headers(content=commands_data),
+                             commands_data,
+                             'Failed to apply batch record update',
+                             ActivityBatchResultModel, many=True)
+
+    def create_track_activity(self, ctam: CreateTrackActivityModel) -> ActivityUpdateResponseModel:
+        site_data = stringify({
+            "recordInterval": ctam.recordInterval,
+            "activity": asdict(ctam.activity)
+        })
+        return request_json('POST', f"{self._prefix_path}/activity/track",
+                             self._session.build_headers(content=site_data),
+                             site_data,
+                             'Failed to create track activity',
+                             ActivityUpdateResponseModel)
+
+    def update_track_activity(self, track_key: str, utam: UpdateTrackActivityModel) -> ActivityUpdateResponseModel:
+        track_data = stringify({
+            "activity": asdict(utam.activity)
+        })
+        return request_json('POST', f"{self._prefix_path}/activity/track/{track_key}",
+                             self._session.build_headers(content=track_data),
+                             track_data,
+                             'Failed to update track activity',
+                             ActivityUpdateResponseModel)
+
+    def find_track_activity(self, track_key: str) -> TrackActivityModel:
+        return request_json('GET', f"{self._prefix_path}/activity/track/{track_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve track activity',
+                             TrackActivityModel)
+
+    def delete_track_activity(self, track_key: str) -> None:
+        request_json('DELETE', f"{self._prefix_path}/activity/track/{track_key}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to delete track activity')
+
+    def unlock_track_activity(self, track_key: str) -> None:
+        request_json('PUT', f"{self._prefix_path}/activity/track/unlock/{track_key}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to unlock track activity')
+
+    def get_track_records(self, track_key: str, start_time: Optional[datetime], end_time: Optional[datetime]) -> TrackRecordsModel:
+        start_millis = int(start_time.timestamp() * 1000) if start_time else 0
+        end_millis = int(end_time.timestamp() * 1000) if end_time else 0
+        return request_json('GET', f"{self._prefix_path}/activity/track/records/{track_key}/{start_millis}/{end_millis}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve track records',
+                             TrackRecordsModel)
+
+    def find_all_track_records(self, track_key: str) -> TrackRecordsModel:
+        return request_json('GET', f"{self._prefix_path}/activity/track/records/{track_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve track records',
+                             TrackRecordsModel)
+
+    def publish_track_records(self, track_key: str, records: dict) -> ActivityUpdateResponseModel:
+        """ Publish a set of site records to inmotion """
+        record_data = stringify(records)
+        return request_json('POST', f"{self._prefix_path}/activity/track/records/{track_key}",
+                             self._session.build_headers(content=record_data),
+                             record_data,
+                             'Failed to publish track records',
+                             ActivityUpdateResponseModel)
+
+    def download_track_records(self, track_key: str, file_format: str) -> bytes:
+        return request_raw('GET', f"{self._prefix_path}/activity/track/download/{track_key}/{file_format}",
+                            self._session.build_headers(content=''),
+                            '',
+                            'Failed to download track records')
+
+    def share_track_activity(self, track_key: str, kind: str) -> None:
+        request_json('POST', f"{self._prefix_path}/activity/track/share/{track_key}/{kind}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to share track activity')
+
+    def unshare_track_activity(self, track_key: str, kind: str) -> None:
+        request_json('PUT', f"{self._prefix_path}/activity/track/unshare/{track_key}/{kind}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to unshare track activity')
+
+    def find_shared_track_activity(self, track_key: str) -> TrackActivityModel:
+        return request_json('GET', f"{self._prefix_path}/activity/track/shared/{track_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve shared track activity',
+                             TrackActivityModel)
+
+    def find_all_shared_track_records(self, track_key: str) -> TrackRecordsModel:
+        return request_json('GET', f"{self._prefix_path}/activity/track/shared/records/{track_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve shared track records',
+                             TrackRecordsModel)
+
+    def convert_track_to_route(self, track_key: str, name: Optional[str] = None) -> str:
+        body_data = stringify({"name": name} if name is not None else {})
+        result = request_json('POST', f"{self._prefix_path}/activity/track/convert-to-route/{track_key}",
+                               self._session.build_headers(content=body_data),
+                               body_data,
+                               'Failed to convert track activity to route')
+        return result['key']
+
+    def preview_track_records(self, track_key: str, qc_config: QCConfigModel) -> dict:
+        qc_data = stringify(qc_config)
+        return request_json('POST', f"{self._prefix_path}/activity/track/records/{track_key}/preview",
+                             self._session.build_headers(content=qc_data),
+                             qc_data,
+                             'Failed to preview track records')
+
+    def preview_track_records_within_range(self, track_key: str, start_time: datetime, end_time: datetime, qc_config: QCConfigModel) -> dict:
+        start_millis = int(start_time.timestamp() * 1000)
+        end_millis = int(end_time.timestamp() * 1000)
+        qc_data = stringify(qc_config)
+        return request_json('POST', f"{self._prefix_path}/activity/track/records/{track_key}/preview/{start_millis}/{end_millis}",
+                             self._session.build_headers(content=qc_data),
+                             qc_data,
+                             'Failed to preview track records within range')
+
+    def find_track_model_field_groups(self, track_key: str) -> list[ModelFieldGroupModel]:
+        return request_json('GET', f"{self._prefix_path}/activity/track/{track_key}/model-fields",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to find track model field groups',
+                             ModelFieldGroupModel, many=True)
+
+    def set_track_model_field_value(self, track_key: str, request: SetModelFieldValueRequestModel) -> list[ModelFieldGroupModel]:
+        request_data = stringify(request)
+        return request_json('PUT', f"{self._prefix_path}/activity/track/{track_key}/model-fields",
+                             self._session.build_headers(content=request_data),
+                             request_data,
+                             'Failed to set track model field value',
+                             ModelFieldGroupModel, many=True)
+
+    def create_site_activity(self, csam: CreateSiteActivityModel) -> ActivityUpdateResponseModel:
+        site_data = stringify({
+            "activity": asdict(csam.activity),
+            "location": asdict(csam.location),
+            "recordInterval": csam.recordInterval
+        })
+        return request_json('POST', f"{self._prefix_path}/activity/site",
+                             self._session.build_headers(content=site_data),
+                             site_data,
+                             'Failed to create site activity',
+                             ActivityUpdateResponseModel)
+
+    def update_site_activity(self, site_key: str, usam: UpdateSiteActivityModel) -> ActivityUpdateResponseModel:
+        site_data = stringify({
+            "location": asdict(usam.location),
+            "activity": asdict(usam.activity)
+        })
+        return request_json('POST', f"{self._prefix_path}/activity/site/{site_key}",
+                             self._session.build_headers(content=site_data),
+                             site_data,
+                             'Failed to update site activity',
+                             ActivityUpdateResponseModel)
+
+    def find_site_activity(self, site_key: str) -> SiteActivityModel:
+        return request_json('GET', f"{self._prefix_path}/activity/site/{site_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve site activity',
+                             SiteActivityModel)
+
+    def delete_site_activity(self, site_key: str) -> None:
+        request_json('DELETE', f"{self._prefix_path}/activity/site/{site_key}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to delete site activity')
+
+    def unlock_site_activity(self, site_key: str) -> None:
+        request_json('PUT', f"{self._prefix_path}/activity/site/unlock/{site_key}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to unlock site activity')
+
+    def get_site_records(self, site_key: str, start_time: Optional[datetime], end_time: Optional[datetime]) -> SiteRecordsModel:
+        start_millis = int(start_time.timestamp() * 1000) if start_time else 0
+        end_millis = int(end_time.timestamp() * 1000) if end_time else 0
+        return request_json('GET', f"{self._prefix_path}/activity/site/records/{site_key}/{start_millis}/{end_millis}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve site records',
+                             SiteRecordsModel)
+
+    def find_all_site_records(self, site_key: str) -> SiteRecordsModel:
+        return request_json('GET', f"{self._prefix_path}/activity/site/records/{site_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve site records',
+                             SiteRecordsModel)
+
+    def publish_site_records(self, site_key: str, records: dict) -> ActivityUpdateResponseModel:
+        """ Publish a set of site records to inmotion """
+        record_data = stringify(records)
+        return request_json('POST', f"{self._prefix_path}/activity/site/records/{site_key}",
+                             self._session.build_headers(content=record_data),
+                             record_data,
+                             'Failed to publish site records',
+                             ActivityUpdateResponseModel)
+
+    def download_site_records(self, site_key: str, file_format: str) -> bytes:
+        return request_raw('GET', f"{self._prefix_path}/activity/site/download/{site_key}/{file_format}",
+                            self._session.build_headers(content=''),
+                            '',
+                            'Failed to download site records')
+
+    def share_site_activity(self, site_key: str, kind: str) -> None:
+        request_json('POST', f"{self._prefix_path}/activity/site/share/{site_key}/{kind}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to share site activity')
+
+    def unshare_site_activity(self, site_key: str, kind: str) -> None:
+        request_json('PUT', f"{self._prefix_path}/activity/site/unshare/{site_key}/{kind}",
+                     self._session.build_headers(content=''),
+                     '',
+                     'Failed to unshare site activity')
+
+    def find_shared_site_activity(self, site_key: str) -> SiteActivityModel:
+        return request_json('GET', f"{self._prefix_path}/activity/site/shared/{site_key}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve shared site activity',
+                             SiteActivityModel)
+
+    def find_shared_site_records(self, site_key: str, start_time: datetime, end_time: datetime) -> SiteRecordsModel:
+        start_millis = int(start_time.timestamp() * 1000)
+        end_millis = int(end_time.timestamp() * 1000)
+        return request_json('GET', f"{self._prefix_path}/activity/site/shared/records/{site_key}/{start_millis}/{end_millis}",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to retrieve shared site records',
+                             SiteRecordsModel)
+
+    def preview_site_records(self, site_key: str, qc_config: QCConfigModel) -> dict:
+        qc_data = stringify(qc_config)
+        return request_json('POST', f"{self._prefix_path}/activity/site/records/{site_key}/preview",
+                             self._session.build_headers(content=qc_data),
+                             qc_data,
+                             'Failed to preview site records')
+
+    def preview_site_records_within_range(self, site_key: str, start_time: datetime, end_time: datetime, qc_config: QCConfigModel) -> dict:
+        start_millis = int(start_time.timestamp() * 1000)
+        end_millis = int(end_time.timestamp() * 1000)
+        qc_data = stringify(qc_config)
+        return request_json('POST', f"{self._prefix_path}/activity/site/records/{site_key}/preview/{start_millis}/{end_millis}",
+                             self._session.build_headers(content=qc_data),
+                             qc_data,
+                             'Failed to preview site records within range')
+
+    def find_site_model_field_groups(self, site_key: str) -> list[ModelFieldGroupModel]:
+        return request_json('GET', f"{self._prefix_path}/activity/site/{site_key}/model-fields",
+                             self._session.build_headers(content=''),
+                             '',
+                             'Failed to find site model field groups',
+                             ModelFieldGroupModel, many=True)
+
+    def set_site_model_field_value(self, site_key: str, request: SetModelFieldValueRequestModel) -> list[ModelFieldGroupModel]:
+        request_data = stringify(request)
+        return request_json('PUT', f"{self._prefix_path}/activity/site/{site_key}/model-fields",
+                             self._session.build_headers(content=request_data),
+                             request_data,
+                             'Failed to set site model field value',
+                             ModelFieldGroupModel, many=True)