Improve api experience

pyframe/models/alert.py

@@ -1,16 +1,13 @@
-from collections import defaultdict
-from dateutil.parser import isoparse
-from pyframe.models.common import Mission, WarframeObj
+from pyframe.models.common import Mission, WarframeObj, isoparse
 
 class Alert(WarframeObj):
     def __init__(self, json_alert: dict):
-        json_alert = defaultdict(lambda : None, json_alert)
-        self.id = json_alert['id']
+        self.id = str(json_alert['id']) if 'id' in json_alert else None
         self.activation = isoparse(json_alert['activation']) if 'activation' in json_alert else None
         self.expiry = isoparse(json_alert['expiry']) if 'expiry' in json_alert else None
-        self.start_string = json_alert['startString']
-        self.active = json_alert['active']
+        self.start_string = str(json_alert['startString']) if 'startString' in json_alert else None
+        self.active = bool(json_alert['active']) if 'active' in json_alert else None
         self.mission = Mission(json_alert['mission']) if 'mission' in json_alert else None
-        self.expired = json_alert['expired']
-        self.eta = json_alert['eta']
-        self.reward_types = json_alert['rewardTypes']
+        self.expired = bool(json_alert['expired']) if 'expired' in json_alert else None
+        self.eta = str(json_alert['eta']) if 'eta' in json_alert else None
+        self.reward_types = list[str](json_alert['rewardTypes']) if 'rewardTypes' in json_alert else []

pyframe/models/arbitration.py

@@ -1,19 +1,16 @@
-from collections import defaultdict
-from dateutil.parser import isoparse
-from pyframe.models.common import WarframeObj
+from pyframe.models.common import WarframeObj, isoparse
 
 class Arbitration(WarframeObj):
     def __init__(self, json_arbitration: dict):
-        json_arbitration = defaultdict(lambda : None, json_arbitration)
-        self.id = json_arbitration['id']
+        self.id = str(json_arbitration['id'])
         self.activation = isoparse(json_arbitration['activation']) if 'activation' in json_arbitration else None
         self.expiry = isoparse(json_arbitration['expiry']) if 'expiry' in json_arbitration else None
-        self.start_string = json_arbitration['startString']
-        self.active = json_arbitration['active']
-        self.node = json_arbitration['node']
-        self.enemy = json_arbitration['enemy']
-        self.enemy_key = json_arbitration['enemyKey']
-        self.type = json_arbitration['type']
-        self.type_key = json_arbitration['typeKey']
-        self.archwing = json_arbitration['archwing']
-        self.sharkwing = json_arbitration['sharkwing']
+        self.start_string = str(json_arbitration['startString']) if 'startString' in json_arbitration else None
+        self.active = bool(json_arbitration['active']) if 'active' in json_arbitration else None
+        self.node = str(json_arbitration['node']) if 'node' in json_arbitration else None
+        self.enemy = str(json_arbitration['enemy']) if 'enemy' in json_arbitration else None
+        self.enemy_key = str(json_arbitration['enemyKey']) if 'enemyKey' in json_arbitration else None
+        self.type = str(json_arbitration['type']) if 'type' in json_arbitration else None
+        self.type_key = str(json_arbitration['typeKey']) if 'typeKey' in json_arbitration else None
+        self.archwing = bool(json_arbitration['archwing']) if 'archwing' in json_arbitration else None
+        self.sharkwing = bool(json_arbitration['sharkwing']) if 'sharkwing' in json_arbitration else None

pyframe/models/archon_hunt.py

@@ -1,19 +1,16 @@
-from collections import defaultdict
-from dateutil.parser import isoparse
-from pyframe.models.common import WarframeObj, Mission
+from pyframe.models.common import WarframeObj, Mission, isoparse
 
 class ArchonHunt(WarframeObj):
     def __init__(self, json_archon_hunt: dict):
-        json_archon_hunt = defaultdict(lambda : None, json_archon_hunt)
-        self.id = json_archon_hunt['id']
-        self.activation = isoparse(json_archon_hunt['activation'])
-        self.expiry = isoparse(json_archon_hunt['expiry'])
-        self.start_string = json_archon_hunt['startString']
-        self.active = json_archon_hunt['active']
-        self.reward_pool = json_archon_hunt['rewardPool']
+        self.id = str(json_archon_hunt['id']) if 'id' in json_archon_hunt else None
+        self.activation = isoparse(json_archon_hunt['activation']) if 'activation' in json_archon_hunt else None
+        self.expiry = isoparse(json_archon_hunt['expiry']) if 'expiry' in json_archon_hunt else None
+        self.start_string = str(json_archon_hunt['startString']) if 'startString' in json_archon_hunt else None
+        self.active = bool(json_archon_hunt['active']) if 'active' in json_archon_hunt else None
+        self.reward_pool = str(json_archon_hunt['rewardPool']) if 'rewardPool' in json_archon_hunt else None
         self.missions = [Mission(mission) for mission in json_archon_hunt['missions']] if 'missions' in json_archon_hunt else []
-        self.boss = json_archon_hunt['boss']
-        self.faction = json_archon_hunt['faction']
-        self.faction_key = json_archon_hunt['factionKey']
-        self.expired = json_archon_hunt['expired']
-        self.eta = json_archon_hunt['eta']
+        self.boss = str(json_archon_hunt['boss']) if 'boss' in json_archon_hunt else None
+        self.faction = str(json_archon_hunt['faction']) if 'faction' in json_archon_hunt else None
+        self.faction_key = str(json_archon_hunt['factionKey']) if 'factionKey' in json_archon_hunt else None
+        self.expired = bool(json_archon_hunt['expired']) if 'expired' in json_archon_hunt else None
+        self.eta = str(json_archon_hunt['eta']) if 'eta' in json_archon_hunt else None

pyframe/models/cambion_cycle.py

@@ -1,13 +1,10 @@
-from collections import defaultdict
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class CambionCycle(WarframeObj):
     def __init__(self, json_cambion_cycle: dict):
-        json_cambion_cycle = defaultdict(lambda : None, json_cambion_cycle)
-        self.id = json_cambion_cycle['id']
+        self.id = str(json_cambion_cycle['id']) if 'id' in json_cambion_cycle else None
         self.expiry = isoparse(json_cambion_cycle['expiry']) if 'expiry' in json_cambion_cycle else None
         self.activation = isoparse(json_cambion_cycle['activation']) if 'activation' in json_cambion_cycle else None
-        self.state = json_cambion_cycle['state']
-        self.active = json_cambion_cycle['active']
-        self.time_left = json_cambion_cycle['timeLeft']
+        self.state = str(json_cambion_cycle['state']) if 'state' in json_cambion_cycle else None
+        self.active = bool(json_cambion_cycle['active']) if 'active' in json_cambion_cycle else None
+        self.time_left = str(json_cambion_cycle['timeLeft']) if 'timeLeft' in json_cambion_cycle else None

pyframe/models/cetus_cycle.py

@@ -1,17 +1,14 @@
-from pyframe.models.common import WarframeObj
-from collections import defaultdict
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class CetusCycle(WarframeObj):
     def __init__(self, json_cetus_cycle: dict):
-        json_cetus_cycle = defaultdict(lambda : None, json_cetus_cycle)
-        self.id = json_cetus_cycle['id']
+        self.id = str(json_cetus_cycle['id']) if 'id' in json_cetus_cycle else None
         self.activation = isoparse(json_cetus_cycle['activation']) if 'activation' in json_cetus_cycle else None
         self.expiry = isoparse(json_cetus_cycle['expiry']) if 'expiry' in json_cetus_cycle else None
-        self.start_string = json_cetus_cycle['startString']
-        self.active = json_cetus_cycle['active']
-        self.is_day = json_cetus_cycle['isDay']
-        self.state = json_cetus_cycle['state']
-        self.time_left = json_cetus_cycle['timeLeft']
-        self.is_cetus = json_cetus_cycle['isCetus']
-        self.short_string = json_cetus_cycle['shortString']
+        self.start_string = str(json_cetus_cycle['startString']) if 'startString' in json_cetus_cycle else None
+        self.active = bool(json_cetus_cycle['active']) if 'active' in json_cetus_cycle else None
+        self.is_day = bool(json_cetus_cycle['isDay']) if 'isDay' in json_cetus_cycle else None
+        self.state = str(json_cetus_cycle['state']) if 'state' in json_cetus_cycle else None
+        self.time_left = str(json_cetus_cycle['timeLeft']) if 'timeLeft' in json_cetus_cycle else None
+        self.is_cetus = bool(json_cetus_cycle['isCetus']) if 'isCetus' in json_cetus_cycle else None
+        self.short_string = str(json_cetus_cycle['shortString']) if 'shortString' in json_cetus_cycle else None

pyframe/models/common.py

@@ -1,6 +1,9 @@
-from collections import defaultdict
+from datetime import datetime, timezone
 from pprint import PrettyPrinter
-from dateutil.parser import isoparse
+
+def isoparse(date: str):
+    newDate = date[:-1] if date[-1] == 'Z' else date
+    return datetime.fromisoformat(newDate).replace(tzinfo = timezone.utc)
 
 pp = PrettyPrinter(indent = 4, width = 150)
 
@@ -13,53 +16,49 @@ def __repr__(self):
 
 class CountedItem(WarframeObj):
     def __init__(self, json_counted_item: dict):
-        json_counted_item = defaultdict(lambda : None, json_counted_item)
-        self.count = json_counted_item['count']
-        self.type = json_counted_item['type']
+        self.count = int(json_counted_item['count']) if 'count' in json_counted_item else None
+        self.type = str(json_counted_item['type']) if 'type' in json_counted_item else None
 
 class Job(WarframeObj):
     def __init__(self, json_job: dict):
-        json_job = defaultdict(lambda : None, json_job)
         self.activation = isoparse(json_job['activation']) if 'activation' in json_job else None
         self.expiry = isoparse(json_job['expiry']) if 'expiry' in json_job else None
-        self.reward_pool = json_job['reward_pool'] if 'reward_pool' in json_job else []
-        self.type = json_job['type']
-        self.enemy_levels = json_job['enemyLevels'] if 'enemyLevels' in json_job else []
-        self.standing_stages = json_job['standingStages'] if 'standingStages' in json_job else []
-        self.minMR = json_job['minMR']
+        self.reward_pool = list[str](json_job['reward_pool']) if 'reward_pool' in json_job else []
+        self.type = str(json_job['type']) if 'type' in json_job else None
+        self.enemy_levels = list[int](json_job['enemyLevels']) if 'enemyLevels' in json_job else []
+        self.standing_stages = list[int](json_job['standingStages']) if 'standingStages' in json_job else []
+        self.min_mastery_rank = int(json_job['minMR']) if 'minMR' in json_job else None
 
 class Reward(WarframeObj):
     def __init__(self, json_reward: dict):
-        json_reward = defaultdict(lambda : None, json_reward)
         self.counted_items = [CountedItem(counted_item) for counted_item in json_reward['countedItems']] if 'countedItems' in json_reward else []
-        self.thumbnail = json_reward['thumbnail']
-        self.color = json_reward['color']
-        self.credits = json_reward['credits']
-        self.as_string = json_reward['asString']
-        self.items = json_reward['items']
-        self.item_string = json_reward['itemString']
+        self.thumbnail = str(json_reward['thumbnail']) if 'thumbnail' in json_reward else None
+        self.color = int(json_reward['color']) if 'color' in json_reward else None
+        self.credits = int(json_reward['credits']) if 'credits' in json_reward else None
+        self.as_string = str(json_reward['asString']) if 'asString' in json_reward else None
+        self.items = list[str](json_reward['items']) if 'items' in json_reward else []
+        self.item_string = str(json_reward['itemString']) if 'itemString' in json_reward else None
 
 class Mission(WarframeObj):
     def __init__(self, json_mission: dict):
-        json_mission = defaultdict(lambda : None, json_mission)
         self.reward = Reward(json_mission['reward']) if 'reward' in json_mission else None
-        self.node = json_mission['node']
-        self.node_key = json_mission['nodeKey']
-        self.faction = json_mission['faction']
-        self.faction_key = json_mission['factionKey']
-        self.max_enemy_level = json_mission['maxEnemyLevel']
-        self.min_enemy_level = json_mission['minEnemyLevel']
-        self.max_wave_num = json_mission['maxWaveNum']
-        self.type = json_mission['type']
-        self.type_key = json_mission['typeKey']
-        self.nightmare = json_mission['nightmare']
-        self.archwing_required = json_mission['archwingRequired']
-        self.is_sharkwing = json_mission['isSharkwing']
-        self.enemy_spec = json_mission['enemySpec']
-        self.level_override = json_mission['levelOverride']
-        self.advanced_spawners = json_mission['advancedSpawners']
-        self.required_items = json_mission['requiredItems']
-        self.consume_required_items = json_mission['consumeRequiredItems']
-        self.leaders_always_allowed = json_mission['leadersAlwaysAllowed']
-        self.level_auras = json_mission['levelAuras']
-        self.description = json_mission['description']
+        self.node = str(json_mission['node']) if 'node' in json_mission else None
+        self.node_key = str(json_mission['nodeKey']) if 'nodeKey' in json_mission else None
+        self.faction = str(json_mission['faction']) if 'faction' in json_mission else None
+        self.faction_key = str(json_mission['factionKey']) if 'factionKey' in json_mission else None
+        self.max_enemy_level = int(json_mission['maxEnemyLevel']) if 'maxEnemyLevel' in json_mission else None
+        self.min_enemy_level = int(json_mission['minEnemyLevel']) if 'minEnemyLevel' in json_mission else None
+        self.max_wave_num = int(json_mission['maxWaveNum']) if 'maxWaveNum' in json_mission else None
+        self.type = str(json_mission['type']) if 'type' in json_mission else None
+        self.type_key = str(json_mission['typeKey']) if 'typeKey' in json_mission else None
+        self.nightmare = bool(json_mission['nightmare']) if 'nightmare' in json_mission else None
+        self.archwing_required = bool(json_mission['archwingRequired']) if 'archwingRequired' in json_mission else None
+        self.is_sharkwing = bool(json_mission['isSharkwing']) if 'isSharkwing' in json_mission else None
+        self.enemy_spec = str(json_mission['enemySpec']) if 'enemySpec' in json_mission else None
+        self.level_override = str(json_mission['levelOverride']) if 'levelOverride' in json_mission else None
+        self.advanced_spawners = list[str](json_mission['advancedSpawners'])
+        self.required_items = list[str](json_mission['requiredItems'])
+        self.consume_required_items = bool(json_mission['consumeRequiredItems']) if 'consumeRequiredItems' in json_mission else None
+        self.leaders_always_allowed = bool(json_mission['leadersAlwaysAllowed']) if 'leadersAlwaysAllowed' in json_mission else None
+        self.level_auras = list[str](json_mission['levelAuras']) if 'levelAuras' in json_mission else []
+        self.description = str(json_mission['description']) if 'description' in json_mission else None

pyframe/models/conclave_challenge.py

@@ -1,19 +1,16 @@
-from collections import defaultdict
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class ConclaveChallenge(WarframeObj):
     def __init__(self, json_conclave_challenge: dict):
-        json_conclave_challenge = defaultdict(lambda : None, json_conclave_challenge)
-        self.mode = json_conclave_challenge['mode']
-        self.amount = json_conclave_challenge['amount']
-        self.eta = json_conclave_challenge['eta']
-        self.expired = json_conclave_challenge['expired']
-        self.end_string = json_conclave_challenge['endString']
-        self.daily = json_conclave_challenge['daily']
-        self.description = json_conclave_challenge['description']
-        self.id = json_conclave_challenge['id']
+        self.mode = str(json_conclave_challenge['mode']) if 'mode' in json_conclave_challenge else None
+        self.amount = int(json_conclave_challenge['amount']) if 'amount' in json_conclave_challenge else None
+        self.eta = str(json_conclave_challenge['eta']) if 'eta' in json_conclave_challenge else None
+        self.expired = bool(json_conclave_challenge['expired']) if 'expired' in json_conclave_challenge else None
+        self.end_string = str(json_conclave_challenge['endString']) if 'endString' in json_conclave_challenge else None
+        self.daily = bool(json_conclave_challenge['daily']) if 'daily' in json_conclave_challenge else None
+        self.description = str(json_conclave_challenge['description']) if 'description' in json_conclave_challenge else None
+        self.id = str(json_conclave_challenge['id']) if 'id' in json_conclave_challenge else None
         self.expiry = isoparse(json_conclave_challenge['expiry']) if 'expiry' in json_conclave_challenge else None
-        self.as_string = json_conclave_challenge['asString']
-        self.category = json_conclave_challenge['category']
-        self.root_challenge = json_conclave_challenge['rootChallenge']
+        self.as_string = str(json_conclave_challenge['asString']) if 'asString' in json_conclave_challenge else None
+        self.category = str(json_conclave_challenge['category']) if 'category' in json_conclave_challenge else None
+        self.root_challenge = bool(json_conclave_challenge['rootChallenge']) if 'rootChallenge' in json_conclave_challenge else None

pyframe/models/construction_progress.py

@@ -1,11 +1,9 @@
 from pyframe.models.common import WarframeObj
-from collections import defaultdict
 
 class ConstructionProgress(WarframeObj):
     def __init__(self, json_construction_progress: dict):
-        json_construction_progress = defaultdict(lambda : None, json_construction_progress)
-        self.id = json_construction_progress['id']
-        self.fomorian_progress = json_construction_progress['fomorianProgress']
-        self.razorback_progress = json_construction_progress['razorbackProgress']
-        self.unknown_progress = json_construction_progress['unkownProgress']
+        self.id = str(json_construction_progress['id']) if 'id' in json_construction_progress else None
+        self.fomorian_progress = str(json_construction_progress['fomorianProgress']) if 'fomorianProgress' in json_construction_progress else None
+        self.razorback_progress = str(json_construction_progress['razorbackProgress']) if 'razorbackProgress' in json_construction_progress else None
+        self.unknown_progress = str(json_construction_progress['unkownProgress']) if 'unkownProgress' in json_construction_progress else None