From da5bfcd809911d0d1d9d58a4f22f580bb218784d Mon Sep 17 00:00:00 2001
From: LilTOJustice <muianick4@gmail.com>
Date: Tue, 30 Jan 2024 20:42:59 -0800
Subject: [PATCH 1/3] Added proper type annotations for all models

---
 pyframe/models/alert.py                 | 14 ++---
 pyframe/models/arbitration.py           | 22 ++++---
 pyframe/models/archon_hunt.py           | 24 ++++----
 pyframe/models/cambion_cycle.py         | 10 ++--
 pyframe/models/cetus_cycle.py           | 18 +++---
 pyframe/models/common.py                | 71 ++++++++++------------
 pyframe/models/conclave_challenge.py    | 24 ++++----
 pyframe/models/construction_progress.py | 10 ++--
 pyframe/models/daily_deal.py            | 20 +++----
 pyframe/models/earth_cycle.py           | 12 ++--
 pyframe/models/event.py                 | 80 ++++++++++++-------------
 pyframe/models/fissure.py               | 30 +++++-----
 pyframe/models/flash_sale.py            | 16 +++--
 pyframe/models/global_upgrade.py        | 21 ++++---
 pyframe/models/invasion.py              | 37 ++++++------
 pyframe/models/kuva.py                  | 22 ++++---
 pyframe/models/news.py                  | 25 ++++----
 pyframe/models/nightwave.py             | 34 +++++------
 pyframe/models/persistent_enemy.py      | 25 ++++----
 pyframe/models/simaris.py               |  8 +--
 pyframe/models/sortie.py                | 33 +++++-----
 pyframe/models/steel_path.py            | 14 ++---
 pyframe/models/syndicate_mission.py     | 10 ++--
 pyframe/models/vallis_cycle.py          |  8 +--
 pyframe/models/void_trader.py           | 23 ++++---
 pyframe/models/worldstate.py            |  3 +-
 26 files changed, 276 insertions(+), 338 deletions(-)

diff --git a/pyframe/models/alert.py b/pyframe/models/alert.py
index d1d971e..5fb2688 100644
--- a/pyframe/models/alert.py
+++ b/pyframe/models/alert.py
@@ -1,16 +1,14 @@
-from collections import defaultdict
 from dateutil.parser import isoparse
 from pyframe.models.common import Mission, WarframeObj
 
 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']
\ No newline at end of file
+        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 []
\ No newline at end of file
diff --git a/pyframe/models/arbitration.py b/pyframe/models/arbitration.py
index b21e1be..6d7b206 100644
--- a/pyframe/models/arbitration.py
+++ b/pyframe/models/arbitration.py
@@ -1,19 +1,17 @@
-from collections import defaultdict
 from dateutil.parser import isoparse
 from pyframe.models.common import WarframeObj
     
 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']
\ No newline at end of file
+        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
\ No newline at end of file
diff --git a/pyframe/models/archon_hunt.py b/pyframe/models/archon_hunt.py
index 5af60c9..d03bedb 100644
--- a/pyframe/models/archon_hunt.py
+++ b/pyframe/models/archon_hunt.py
@@ -1,19 +1,17 @@
-from collections import defaultdict
 from dateutil.parser import isoparse
 from pyframe.models.common import WarframeObj, Mission
 
 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']
\ No newline at end of file
+        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
\ No newline at end of file
diff --git a/pyframe/models/cambion_cycle.py b/pyframe/models/cambion_cycle.py
index fac2505..ef4aad1 100644
--- a/pyframe/models/cambion_cycle.py
+++ b/pyframe/models/cambion_cycle.py
@@ -1,13 +1,11 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 from dateutil.parser import 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']
\ No newline at end of file
+        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
\ No newline at end of file
diff --git a/pyframe/models/cetus_cycle.py b/pyframe/models/cetus_cycle.py
index 6aa7471..e96f840 100644
--- a/pyframe/models/cetus_cycle.py
+++ b/pyframe/models/cetus_cycle.py
@@ -1,17 +1,15 @@
 from pyframe.models.common import WarframeObj
-from collections import defaultdict
 from dateutil.parser import 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
diff --git a/pyframe/models/common.py b/pyframe/models/common.py
index be25a20..a27ccf6 100644
--- a/pyframe/models/common.py
+++ b/pyframe/models/common.py
@@ -1,4 +1,3 @@
-from collections import defaultdict
 from pprint import PrettyPrinter
 from dateutil.parser import isoparse
 
@@ -13,53 +12,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']
\ No newline at end of file
+        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
\ No newline at end of file
diff --git a/pyframe/models/conclave_challenge.py b/pyframe/models/conclave_challenge.py
index 240dfd6..c974fa6 100644
--- a/pyframe/models/conclave_challenge.py
+++ b/pyframe/models/conclave_challenge.py
@@ -1,19 +1,17 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 from dateutil.parser import 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']
\ No newline at end of file
+        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
\ No newline at end of file
diff --git a/pyframe/models/construction_progress.py b/pyframe/models/construction_progress.py
index a515195..f8751a3 100644
--- a/pyframe/models/construction_progress.py
+++ b/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
     
\ No newline at end of file
diff --git a/pyframe/models/daily_deal.py b/pyframe/models/daily_deal.py
index cb05cc9..d662d13 100644
--- a/pyframe/models/daily_deal.py
+++ b/pyframe/models/daily_deal.py
@@ -1,18 +1,16 @@
 from pyframe.models.common import WarframeObj
-from collections import defaultdict
 from dateutil.parser import isoparse
 
 class DailyDeal(WarframeObj):
     def __init__(self, json_daily_deal: dict):
-        json_daily_deal = defaultdict(lambda : None, json_daily_deal)
-        self.sold = json_daily_deal['sold']
-        self.item = json_daily_deal['item']
-        self.unique_name = json_daily_deal['uniqueName']
-        self.total = json_daily_deal['total']
-        self.eta = json_daily_deal['eta']
-        self.original_price = json_daily_deal['originalPrice']
-        self.sale_price = json_daily_deal['salePrice']
-        self.discount  = json_daily_deal['discount']
+        self.sold = int(json_daily_deal['sold'])
+        self.item = str(json_daily_deal['item']) if 'item' in json_daily_deal else None
+        self.unique_name = str(json_daily_deal['uniqueName']) if 'uniqueName' in json_daily_deal else None
+        self.total = int(json_daily_deal['total']) if 'total' in json_daily_deal else None
+        self.eta = str(json_daily_deal['eta']) if 'eta' in json_daily_deal else None
+        self.original_price = int(json_daily_deal['originalPrice']) if 'originalPrice' in json_daily_deal else None
+        self.sale_price = int(json_daily_deal['salePrice']) if 'salePrice' in json_daily_deal else None
+        self.discount  = int(json_daily_deal['discount']) if 'discount' in json_daily_deal else None
         self.expiry = isoparse(json_daily_deal['expiry']) if 'expiry' in json_daily_deal else None
-        self.id = json_daily_deal['id']
+        self.id = str(json_daily_deal['id']) if 'id' in json_daily_deal else None
         
\ No newline at end of file
diff --git a/pyframe/models/earth_cycle.py b/pyframe/models/earth_cycle.py
index 0f757c4..6951836 100644
--- a/pyframe/models/earth_cycle.py
+++ b/pyframe/models/earth_cycle.py
@@ -1,14 +1,12 @@
 from pyframe.models.common import WarframeObj
-from collections import defaultdict
 from dateutil.parser import isoparse
 
 class EarthCycle(WarframeObj):
     def __init__(self, json_earth_cycle: dict):
-        json_earth_cycle = defaultdict(lambda : None, json_earth_cycle)
-        self.id = json_earth_cycle['id']
+        self.id = str(json_earth_cycle['id']) if 'id' in json_earth_cycle else None
         self.activation = isoparse(json_earth_cycle['activation']) if 'activation' in json_earth_cycle else None
         self.expiration = isoparse(json_earth_cycle['expiry']) if 'expiry' in json_earth_cycle else None
-        self.start_string = json_earth_cycle['startString']
-        self.active = json_earth_cycle['active']
-        self.is_day = json_earth_cycle['isDay']
-        self.time_left = json_earth_cycle['timeLeft']
\ No newline at end of file
+        self.start_string = str(json_earth_cycle['startString']) if 'startString' in json_earth_cycle else None
+        self.active = bool(json_earth_cycle['active']) if 'active' in json_earth_cycle else None
+        self.is_day = bool(json_earth_cycle['isDay']) if 'isDay' in json_earth_cycle else None
+        self.time_left = str(json_earth_cycle['timeLeft']) if 'timeLeft' in json_earth_cycle else None
\ No newline at end of file
diff --git a/pyframe/models/event.py b/pyframe/models/event.py
index 9651288..f828b35 100644
--- a/pyframe/models/event.py
+++ b/pyframe/models/event.py
@@ -1,71 +1,65 @@
-from collections import defaultdict
 from pyframe.models.common import Reward, WarframeObj, Job
 from dateutil.parser import isoparse
 
 class Message(WarframeObj):
     def __init__(self, json_message: dict):
-        json_message = defaultdict(lambda : None, json_message)
-        self.sender = json_message['sender']
-        self.subject = json_message['subject']
-        self.message = json_message['message']
-        self.sender_icon = json_message['senderIcon']
-        self.attachments = json_message['attachments'] if 'attachments' in json_message else []
+        self.sender = str(json_message['sender']) if 'sender' in json_message else None
+        self.subject = str(json_message['subject']) if 'subject' in json_message else None
+        self.message = str(json_message['message']) if 'message' in json_message else None
+        self.sender_icon = str(json_message['senderIcon']) if 'senderIcon' in json_message else None
+        self.attachments = list[str](json_message['attachments']) if 'attachments' in json_message else []
 
 class InterimStep(WarframeObj):
     def __init__(self, json_interim_step: dict):
-        json_interim_step = defaultdict(lambda : None, json_interim_step)
-        self.goal = json_interim_step['goal']
+        self.goal = int(json_interim_step['goal']) if 'goal' in json_interim_step else None
         self.reward = Reward(json_interim_step['reward']) if 'reward' in json_interim_step else None
         self.message = Message(json_interim_step['message']) if 'message' in json_interim_step else None
-        self.winner_count = json_interim_step['winnerCount']
+        self.winner_count = int(json_interim_step['winnerCount']) if 'winnerCount' in json_interim_step else None
 
 class ProgressStep(WarframeObj):
     def __init__(self, json_progress_step: dict):
-        json_progress_step = defaultdict(lambda : None, json_progress_step)
-        self.type = json_progress_step['type']
-        self.progress_amt = json_progress_step['progressAmt']
+        self.type = str(json_progress_step['type']) if 'type' in json_progress_step else None
+        self.progress_amt = int(json_progress_step['progressAmt']) if 'progressAmt' in json_progress_step else None
 
 class Alt(WarframeObj):
     def __init__(self, json_alt: dict):
-        json_alt = defaultdict(lambda : None, json_alt)
         self.expiry = isoparse(json_alt['expiry']) if 'expiry' in json_alt else None
         self.activation = isoparse(json_alt['activation']) if 'activation' in json_alt else None
 
 class Event(WarframeObj):
     def __init__(self, json_event: dict):
-        json_event = defaultdict(lambda : None, json_event)
-        self.id = json_event['id']
+        self.id = str(json_event['id']) if 'id' in json_event else None
         self.activation = isoparse(json_event['activation']) if 'activation' in json_event else None
         self.expiry = isoparse(json_event['expiry']) if 'expiry' in json_event else None
-        self.start_string = json_event['startString']
-        self.active = json_event['active']
-        self.maximum_score = json_event['maximumScore']
-        self.current_score = json_event['currentScore']
-        self.small_interval = json_event['smallInterval']
-        self.large_interval = json_event['largeInterval']
-        self.faction = json_event['faction']
-        self.description = json_event['description']
-        self.tooltip = json_event['tooltip']
-        self.node = json_event['node']
-        self.concurrent_nodes = json_event['concurrent_nodes'] if 'concurrent_nodes' in json_event else []
-        self.victim_node = json_event['victimNode']
-        self.score_loc_tag = json_event['scoreLocTag']
+        self.start_string = str(json_event['startString']) if 'startString' in json_event else None
+        self.active = bool(json_event['active']) if 'active' in json_event else None
+        self.maximum_score = int(json_event['maximumScore']) if 'maximumScore' in json_event else None
+        self.current_score = int(json_event['currentScore']) if 'currentScore' in json_event else None
+        self.small_interval = int(json_event['smallInterval']) if 'smallInterval' in json_event else None
+        self.large_interval = int(json_event['largeInterval']) if 'largeInterval' in json_event else None
+        self.faction = str(json_event['faction']) if 'faction' in json_event else None
+        self.description = str(json_event['description']) if 'description' in json_event else None
+        self.tooltip = str(json_event['tooltip']) if 'tooltip' in json_event else None
+        self.node = str(json_event['node']) if 'node' in json_event else None
+        self.concurrent_nodes = list[str](json_event['concurrent_nodes']) if 'concurrent_nodes' in json_event else []
+        self.victim_node = str(json_event['victimNode']) if 'victimNode' in json_event else None
+        self.score_loc_tag = str(json_event['scoreLocTag']) if 'scoreLocTag' in json_event else None
         self.rewards = [Reward(reward) for reward in json_event['rewards']] if 'rewards' in json_event else []
-        self.health = json_event['health']
-        self.affiliated_with = json_event['affiliatedWith']
+        self.health = int(json_event['health']) if 'health' in json_event else None
+        self.affiliated_with = str(json_event['affiliatedWith']) if 'affiliatedWith' in json_event else None
         self.jobs = [Job(job) for job in json_event['jobs']] if 'jobs' in json_event else []
         self.interim_steps = [InterimStep(interim_step) for interim_step in json_event['interimSteps']] if 'interimSteps' in json_event else []
         self.progress_steps = [ProgressStep(progress_step) for progress_step in json_event['progressSteps']] if 'progressSteps' in json_event else []
-        self.progress_total = json_event['progressTotal']
-        self.show_total_at_end_of_mission = json_event['showTotalAtEndOfMission']
-        self.is_personal = json_event['isPersonal']
-        self.is_comminity = json_event['isCommunity']
-        self.region_drops = json_event['regionDrops'] if 'regionDrops' in json_event else []
-        self.archwing_drops = json_event['archwingDrops'] if 'archwingDrops' in json_event else []
-        self.as_string = json_event['asString']
-        self.metadata = json_event['metadata']
-        self.completion_bonuses = json_event['completionBonuses'] if 'completionBonuses' in json_event else []
-        self.score_var = json_event['scoreVar']
-        self.alt_expiry = json_event['altExpiry']
-        self.alt_activation = json_event['altActivation']
+        self.progress_total = int(json_event['progressTotal']) if 'progressTotal' in json_event else None
+        self.show_total_at_end_of_mission = bool(json_event['showTotalAtEndOfMission']) if 'showTotalAtEndOfMission' in json_event else None
+        self.is_personal = bool(json_event['isPersonal']) if 'isPersonal' in json_event else None
+        self.is_comminity = bool(json_event['isCommunity']) if 'isCommunity' in json_event else None
+        self.region_drops = list[str](json_event['regionDrops']) if 'regionDrops' in json_event else []
+        self.archwing_drops = list[str](json_event['archwingDrops']) if 'archwingDrops' in json_event else []
+        self.as_string = str(json_event['asString']) if 'asString' in json_event else None
+        self.metadata = dict[str, any](json_event['metadata']) if 'metadata' in json_event else {}
+        self.completion_bonuses = list[int](json_event['completionBonuses']) if 'completionBonuses' in json_event else []
+        self.score_var = str(json_event['scoreVar']) if 'scoreVar' in json_event else None
+        self.alt_expiry = str(json_event['altExpiry']) if 'altExpiry' in json_event else None
+        self.alt_activation = str(json_event['altActivation']) if 'altActivation' in json_event else None
         self.next_alt = Alt(json_event['nextAlt']) if 'nextAlt' in json_event else None
\ No newline at end of file
diff --git a/pyframe/models/fissure.py b/pyframe/models/fissure.py
index 8987bd0..f10514a 100644
--- a/pyframe/models/fissure.py
+++ b/pyframe/models/fissure.py
@@ -1,23 +1,21 @@
 from pyframe.models.common import WarframeObj
-from collections import defaultdict
 from dateutil.parser import isoparse
 
 class Fissure(WarframeObj):
     def __init__(self, json_fissure: dict):
-        json_fissure = defaultdict(lambda : None, json_fissure)
-        self.id = json_fissure['id']
+        self.id = str(json_fissure['id']) if 'id' in json_fissure else None
         self.activation = isoparse(json_fissure['activation']) if 'activation' in json_fissure else None 
         self.expiry = isoparse(json_fissure['expiry']) if 'expiry' in json_fissure else None 
-        self.start_string = json_fissure['startString']
-        self.active = json_fissure['active']
-        self.node = json_fissure['node']
-        self.expired = json_fissure['expired']
-        self.eta = json_fissure['eta']
-        self.mission_type = json_fissure['missonType']
-        self.mission_key = json_fissure['missionKey']
-        self.tier = json_fissure['tier']
-        self.tier_num = json_fissure['tierNum']
-        self.enemy = json_fissure['enemy']
-        self.enemy_key = json_fissure['enemyKey']
-        self.is_storm = json_fissure['isStorm']
-        self.is_hard = json_fissure['isHard']
+        self.start_string = str(json_fissure['startString']) if 'startString' in json_fissure else None
+        self.active = bool(json_fissure['active']) if 'active' in json_fissure else None
+        self.node = str(json_fissure['node']) if 'node' in json_fissure else None
+        self.expired = str(json_fissure['expired']) if 'expired' in json_fissure else None
+        self.eta = str(json_fissure['eta']) if 'eta' in json_fissure else None
+        self.mission_type = str(json_fissure['missonType']) if 'missionType' in json_fissure else None
+        self.mission_key = str(json_fissure['missionKey']) if 'missionKey' in json_fissure else None
+        self.tier = str(json_fissure['tier']) if 'tier' in json_fissure else None
+        self.tier_num = int(json_fissure['tierNum']) if 'tierNum' in json_fissure else None
+        self.enemy = str(json_fissure['enemy']) if 'enemy' in json_fissure else None
+        self.enemy_key = str(json_fissure['enemyKey']) if 'enemyKey' in json_fissure else None
+        self.is_storm = bool(json_fissure['isStorm']) if 'isStorm' in json_fissure else None
+        self.is_hard = bool(json_fissure['isHard']) if 'isHard' in json_fissure else None
diff --git a/pyframe/models/flash_sale.py b/pyframe/models/flash_sale.py
index e30895f..f8f54c4 100644
--- a/pyframe/models/flash_sale.py
+++ b/pyframe/models/flash_sale.py
@@ -1,13 +1,11 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 
 class FlashSale(WarframeObj):
     def __init__(self, json_flash_sale: dict):
-        json_flash_sale = defaultdict(lambda : None, json_flash_sale)
-        self.item = json_flash_sale['item']
-        self.expired = json_flash_sale['expired']
-        self.eta = json_flash_sale['eta']
-        self.discount = json_flash_sale['discount']
-        self.premium_override = json_flash_sale['premiumOverride']
-        self.is_popular = json_flash_sale['isPopular']
-        self.is_featured = json_flash_sale['isFeatured']
\ No newline at end of file
+        self.item = str(json_flash_sale['item']) if 'item' in json_flash_sale else None
+        self.expired = str(json_flash_sale['expired']) if 'expired' in json_flash_sale else None
+        self.eta = str(json_flash_sale['eta']) if 'eta' in json_flash_sale else None
+        self.discount = int(json_flash_sale['discount']) if 'discount' in json_flash_sale else None
+        self.premium_override = int(json_flash_sale['premiumOverride']) if 'premiumOverride' in json_flash_sale else None
+        self.is_popular = bool(json_flash_sale['isPopular']) if 'isPopular' in json_flash_sale else None
+        self.is_featured = bool(json_flash_sale['isFeatured']) if 'isFeatured' in json_flash_sale else None
\ No newline at end of file
diff --git a/pyframe/models/global_upgrade.py b/pyframe/models/global_upgrade.py
index 4eeeda6..5e7fffb 100644
--- a/pyframe/models/global_upgrade.py
+++ b/pyframe/models/global_upgrade.py
@@ -1,15 +1,14 @@
 from pyframe.models.common import WarframeObj
-from collections import defaultdict
+from dateutil.parser import isoparse
 
 class GlobalUpgrade(WarframeObj):
     def __init__(self, json_global_upgrade: dict):
-        json_global_upgrade = defaultdict(lambda : None, json_global_upgrade)
-        self.start = json_global_upgrade['start']
-        self.end = json_global_upgrade['end']
-        self.upgrade = json_global_upgrade['upgrade']
-        self.operation = json_global_upgrade['operation']
-        self.operation_symbol = json_global_upgrade['operationSymbol']
-        self.upgrade_operation_value = json_global_upgrade['upgradeOperationSymbol']
-        self.expired = json_global_upgrade['expired']
-        self.eta = json_global_upgrade['eta']
-        self.desc = json_global_upgrade['desc']
+        self.start = isoparse(json_global_upgrade['start']) if 'start' in json_global_upgrade else None
+        self.end = isoparse(json_global_upgrade['end']) if 'end' in json_global_upgrade else None
+        self.upgrade = str(json_global_upgrade['upgrade']) if 'upgrade' in json_global_upgrade else None
+        self.operation = str(json_global_upgrade['operation']) if 'operation' in json_global_upgrade else None
+        self.operation_symbol = str(json_global_upgrade['operationSymbol']) if 'operationSymbol' in json_global_upgrade else None
+        self.upgrade_operation_value = int(json_global_upgrade['upgradeOperationSymbol']) if 'upgradeOperationSymbol' in json_global_upgrade else None
+        self.expired = bool(json_global_upgrade['expired']) if 'expired' in json_global_upgrade else None
+        self.eta = str(json_global_upgrade['eta']) if 'eta' in json_global_upgrade else None
+        self.desc = str(json_global_upgrade['desc']) if 'desc' in json_global_upgrade else None
diff --git a/pyframe/models/invasion.py b/pyframe/models/invasion.py
index 67b0a62..524e0c8 100644
--- a/pyframe/models/invasion.py
+++ b/pyframe/models/invasion.py
@@ -1,35 +1,32 @@
-from collections import defaultdict
 from pyframe.models.common import Reward, WarframeObj
 from dateutil.parser import isoparse
 
 class AttackerDefender(WarframeObj):
     def __init__(self, json_attacker: dict):
-        json_attacker = defaultdict(lambda : None, json_attacker)
         self.reward = Reward(json_attacker['reward']) if 'reward' in json_attacker else None
-        self.faction = json_attacker['faction']
-        self.faction_key = json_attacker['factionKey']
+        self.faction = str(json_attacker['faction']) if 'faction' in json_attacker else None
+        self.faction_key = str(json_attacker['factionKey']) if 'factionKey' in json_attacker else None
 
 class Invasion(WarframeObj):
     def __init__(self, json_invasion: dict):
-        json_invasion = defaultdict(lambda : None, json_invasion)
-        self.id = json_invasion['id']
+        self.id = str(json_invasion['id']) if 'id' in json_invasion else None
         self.activation = isoparse(json_invasion['activation']) if 'activation' in json_invasion else None
         self.expiry = isoparse(json_invasion['expiry']) if 'expiry' in json_invasion else None
-        self.start_string = json_invasion['startString']
-        self.active = json_invasion['active']
+        self.start_string = str(json_invasion['startString']) if 'startString' in json_invasion else None
+        self.active = bool(json_invasion['active']) if 'active' in json_invasion else None
         self.attacker = AttackerDefender(json_invasion['attacker']) if 'attacker' in json_invasion else None
         self.attacker_reward = Reward(json_invasion['attackerReward']) if 'attackerReward' in json_invasion else None
-        self.attacking_faction = json_invasion['attackingFaction']
-        self.completed = json_invasion['completed']
-        self.completion = json_invasion['completion'] if 'completion' in json_invasion else []
-        self.count = json_invasion['count']
+        self.attacking_faction = str(json_invasion['attackingFaction']) if 'attackingFaction' in json_invasion else None
+        self.completed = bool(json_invasion['completed']) if 'completed' in json_invasion else None
+        self.completion = list[int](json_invasion['completion']) if 'completion' in json_invasion else []
+        self.count = int(json_invasion['count']) if 'count' in json_invasion else None
         self.defender = AttackerDefender(json_invasion['defender']) if 'defender' in json_invasion else None
         self.defender_reward = Reward(json_invasion['defenderReward']) if 'defenderReward' in json_invasion else None
-        self.defending_faction = json_invasion['defendingFaction']
-        self.desc = json_invasion['desc']
-        self.eta = json_invasion['eta']
-        self.node = json_invasion['node']
-        self.node_key = json_invasion['nodeKey']
-        self.required_runs = json_invasion['requiredRuns']
-        self.reward_types = json_invasion['rewardTypes'] if 'rewardTypes' in json_invasion else []
-        self.vs_infestation = json_invasion['vsInfestation']
\ No newline at end of file
+        self.defending_faction = str(json_invasion['defendingFaction']) if 'defendingFaction' in json_invasion else None
+        self.desc = str(json_invasion['desc']) if 'desc' in json_invasion else None
+        self.eta = str(json_invasion['eta']) if 'eta' in json_invasion else None
+        self.node = str(json_invasion['node']) if 'node' in json_invasion else None
+        self.node_key = str(json_invasion['nodeKey']) if 'nodeKey' in json_invasion else None
+        self.required_runs = int(json_invasion['requiredRuns']) if 'requiredRuns' in json_invasion else None
+        self.reward_types = list[str](json_invasion['rewardTypes']) if 'rewardTypes' in json_invasion else []
+        self.vs_infestation = bool(json_invasion['vsInfestation']) if 'vsInfestation' in json_invasion else None
\ No newline at end of file
diff --git a/pyframe/models/kuva.py b/pyframe/models/kuva.py
index 89bea80..5667d05 100644
--- a/pyframe/models/kuva.py
+++ b/pyframe/models/kuva.py
@@ -1,19 +1,17 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 from dateutil.parser import isoparse
 
 class Kuva(WarframeObj):
     def __init__(self, json_kuva: dict):
-        json_kuva = defaultdict(lambda : None, json_kuva)
-        self.id = json_kuva['id']
+        self.id = str(json_kuva['id']) if 'id' in json_kuva else None
         self.activation = isoparse(json_kuva['activation']) if 'activation' in json_kuva else None
         self.expiry = isoparse(json_kuva['expiry']) if 'expiry' in json_kuva else None
-        self.start_string = json_kuva['startString']
-        self.active = json_kuva['active']
-        self.node = json_kuva['node']
-        self.enemy = json_kuva['enemy']
-        self.enemy_key = json_kuva['enemyKey']
-        self.type = json_kuva['type']
-        self.type_key = json_kuva['typeKey']
-        self.archwing = json_kuva['archwing']
-        self.sharkwing = json_kuva['sharkwing']
\ No newline at end of file
+        self.start_string = str(json_kuva['startString']) if 'startString' in json_kuva else None
+        self.active = bool(json_kuva['active']) if 'active' in json_kuva else None
+        self.node = str(json_kuva['node']) if 'node' in json_kuva else None
+        self.enemy = str(json_kuva['enemy']) if 'enemy' in json_kuva else None
+        self.enemy_key = str(json_kuva['enemyKey']) if 'enemyKey' in json_kuva else None
+        self.type = str(json_kuva['type']) if 'type' in json_kuva else None
+        self.type_key = str(json_kuva['typeKey']) if 'typeKey' in json_kuva else None
+        self.archwing = bool(json_kuva['archwing']) if 'archwing' in json_kuva else None
+        self.sharkwing = bool(json_kuva['sharkwing']) if 'sharkwing' in json_kuva else None
\ No newline at end of file
diff --git a/pyframe/models/news.py b/pyframe/models/news.py
index c8edb02..4ebb7ff 100644
--- a/pyframe/models/news.py
+++ b/pyframe/models/news.py
@@ -1,24 +1,21 @@
-from collections import defaultdict
 from dateutil.parser import isoparse
 from pyframe.models.common import WarframeObj
 
 class News(WarframeObj):
     def __init__(self, json_news: dict):
-        json_news = defaultdict(lambda : None, json_news)
         self.date = isoparse(json_news['date']) if 'date' in json_news else None
-        self.image_link = json_news['imageLink']
-        self.eta = json_news['eta']
-        self.prime_access = json_news['primeAcess']
-        self.stream = json_news['stream']
+        self.image_link = str(json_news['imageLink']) if 'imageLink' in json_news else None
+        self.eta = str(json_news['eta']) if 'eta' in json_news else None
+        self.prime_access = bool(json_news['primeAcess']) if 'primeAcess' in json_news else None
+        self.stream = bool(json_news['stream']) if 'stream' in json_news else None
         self.translations = Translation(json_news['translations']) if 'translations' in json_news else None
-        self.link = json_news['link']
-        self.update = json_news['update']
-        self.id = json_news['id']
-        self.as_string = json_news['asString']
-        self.message = json_news['message']
-        self.priority = json_news['priority']
+        self.link = str(json_news['link']) if 'link' in json_news else None
+        self.update = bool(json_news['update']) if 'update' in json_news else None
+        self.id = str(json_news['id']) if 'id' in json_news else None
+        self.as_string = str(json_news['asString']) if 'asString' in json_news else None
+        self.message = str(json_news['message']) if 'message' in json_news else None
+        self.priority = bool(json_news['priority']) if 'priority' in json_news else None
 
 class Translation(WarframeObj):
     def __init__(self, json_translation: dict):
-        json_translation = defaultdict(lambda : None, json_translation)
-        self.es = json_translation['es']
+        self.es = str(json_translation['es']) if 'es' in json_translation else None
diff --git a/pyframe/models/nightwave.py b/pyframe/models/nightwave.py
index 739d9a6..0e1bcff 100644
--- a/pyframe/models/nightwave.py
+++ b/pyframe/models/nightwave.py
@@ -1,32 +1,30 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 from dateutil.parser import isoparse
 
 class Challenge(WarframeObj):
     def __init__(self, json_challenge: dict):
-        json_challenge = defaultdict(lambda : None, json_challenge)
-        self.id = json_challenge['id']
+        self.id = str(json_challenge['id']) if 'id' in json_challenge else None
         self.activation = isoparse(json_challenge['activation']) if 'activation' in json_challenge else None
         self.expiry = isoparse(json_challenge['expiry']) if 'expiry' in json_challenge else None
-        self.start_string = json_challenge['startString']
-        self.active = json_challenge['active']
-        self.is_daily = json_challenge['isDaily']
-        self.is_elite = json_challenge['isElite']
-        self.title = json_challenge['title']
-        self.desc = json_challenge['desc']
-        self.reputation = json_challenge['reputation']
+        self.start_string = str(json_challenge['startString']) if 'startString' in json_challenge else None
+        self.active = bool(json_challenge['active']) if 'active' in json_challenge else None
+        self.is_daily = bool(json_challenge['isDaily']) if 'isDaily' in json_challenge else None
+        self.is_elite = bool(json_challenge['isElite']) if 'isElite' in json_challenge else None
+        self.title = str(json_challenge['title']) if 'title' in json_challenge else None
+        self.desc = str(json_challenge['desc']) if 'desc' in json_challenge else None
+        self.reputation = int(json_challenge['reputation']) if 'reputation' in json_challenge else None
 
 class Nightwave(WarframeObj):
     def __init__(self, json_nightwave: dict):
-        json_nightwave = defaultdict(lambda : None, json_nightwave)
-        self.id = json_nightwave['id']
+        self.id = str(json_nightwave['id']) if 'id' in json_nightwave else None
         self.activation = isoparse(json_nightwave['activation']) if 'activation' in json_nightwave else None
         self.expiry = isoparse(json_nightwave['expiry']) if 'expiry' in json_nightwave else None
-        self.start_string = json_nightwave['startString']
-        self.active = json_nightwave['active']
-        self.params = json_nightwave['params']
-        self.reward_types = json_nightwave['rewardTypes'] if 'rewardTypes' in json_nightwave else []
-        self.season = json_nightwave['season']
-        self.tag = json_nightwave['tag']
+        self.start_string = str(json_nightwave['startString']) if 'startString' in json_nightwave else None
+        self.active = bool(json_nightwave['active']) if 'active' in json_nightwave else None
+        self.params = dict[str, any](json_nightwave['params']) if 'params' in json_nightwave else {}
+        self.reward_types = list[str](json_nightwave['rewardTypes']) if 'rewardTypes' in json_nightwave else []
+        self.season = int(json_nightwave['season']) if 'season' in json_nightwave else None
+        self.tag = str(json_nightwave['tag']) if 'tag' in json_nightwave else None
+        self.phase = int(json_nightwave['phase']) if 'phase' in json_nightwave else None
         self.possible_challenges = [Challenge(challenge) for challenge in json_nightwave['possibleChallenges']] if 'possibleChallenges' in json_nightwave else []
         self.active_challenges = [Challenge(challenge) for challenge in json_nightwave['activeChallenges']] if 'activeChallenges' in json_nightwave else []
\ No newline at end of file
diff --git a/pyframe/models/persistent_enemy.py b/pyframe/models/persistent_enemy.py
index 903df50..6cb785f 100644
--- a/pyframe/models/persistent_enemy.py
+++ b/pyframe/models/persistent_enemy.py
@@ -1,18 +1,15 @@
-from collections import defaultdict
-from dateutil.parser import isoparse
 from pyframe.models.common import WarframeObj
 
 class PersistentEnemy(WarframeObj):
     def __init__(self, json_persistent_enemy: dict):
-        json_persistent_enemy = defaultdict(lambda : None, json_persistent_enemy)
-        self.location_tag = json_persistent_enemy['locationTag']
-        self.agent_type = json_persistent_enemy['agentType']
-        self.rank = json_persistent_enemy['rank']
-        self.health_percent = json_persistent_enemy['healthPercent']
-        self.flee_damage = json_persistent_enemy['fleeDamage']
-        self.region = json_persistent_enemy['region']
-        self.last_discovered_time = json_persistent_enemy['lastDiscoveredTime']
-        self.last_discovered_at = json_persistent_enemy['lastDiscoveredAt']
-        self.is_discovered = json_persistent_enemy['isDiscovered']
-        self.is_using_ticketing = json_persistent_enemy['isUsingTicketing']
-        self.pid = json_persistent_enemy['pid']
+        self.location_tag = str(json_persistent_enemy['locationTag']) if 'locationTag' in json_persistent_enemy else None
+        self.agent_type = str(json_persistent_enemy['agentType']) if 'agentType' in json_persistent_enemy else None
+        self.rank = int(json_persistent_enemy['rank']) if 'rank' in json_persistent_enemy else None
+        self.health_percent = int(json_persistent_enemy['healthPercent']) if 'healthPercent' in json_persistent_enemy else None
+        self.flee_damage = int(json_persistent_enemy['fleeDamage']) if 'fleeDamage' in json_persistent_enemy else None
+        self.region = str(json_persistent_enemy['region']) if 'region' in json_persistent_enemy else None
+        self.last_discovered_time = str(json_persistent_enemy['lastDiscoveredTime']) if 'lastDiscoveredTime' in json_persistent_enemy else None
+        self.last_discovered_at = str(json_persistent_enemy['lastDiscoveredAt']) if 'lastDiscoveredAt' in json_persistent_enemy else None
+        self.is_discovered = bool(json_persistent_enemy['isDiscovered']) if 'isDiscovered' in json_persistent_enemy else None
+        self.is_using_ticketing = bool(json_persistent_enemy['isUsingTicketing']) if 'isUsingTicketing' in json_persistent_enemy else None
+        self.pid = str(json_persistent_enemy['pid']) if 'pid' in json_persistent_enemy else None
diff --git a/pyframe/models/simaris.py b/pyframe/models/simaris.py
index cc819df..c6c2257 100644
--- a/pyframe/models/simaris.py
+++ b/pyframe/models/simaris.py
@@ -1,9 +1,7 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 
 class Simaris(WarframeObj):
     def __init__(self, json_simaris: dict):
-        json_simaris = defaultdict(lambda : None, json_simaris)
-        self.target = json_simaris['target']
-        self.is_target_active = json_simaris['isTargetActive']
-        self.as_string = json_simaris['asString']
\ No newline at end of file
+        self.target = str(json_simaris['target']) if 'target' in json_simaris else None
+        self.is_target_active = bool(json_simaris['isTargetActive']) if 'isTargetActive' in json_simaris else None
+        self.as_string = str(json_simaris['asString']) if 'asString' in json_simaris else None
\ No newline at end of file
diff --git a/pyframe/models/sortie.py b/pyframe/models/sortie.py
index 88de2ba..cd6fe1e 100644
--- a/pyframe/models/sortie.py
+++ b/pyframe/models/sortie.py
@@ -1,29 +1,26 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 from dateutil.parser import isoparse
 
 class Variant(WarframeObj):
     def __init__(self, json_variant: dict):
-        json_variant = defaultdict(lambda : None, json_variant)
-        self.node = json_variant['node']
-        self.boss = json_variant['boss']
-        self.mission_type = json_variant['missionType']
-        self.planet = json_variant['planet']
-        self.modifier = json_variant['modifier']
-        self.modifier_description = json_variant['modifierDescription']
+        self.node = str(json_variant['node']) if 'node' in json_variant else None
+        self.boss = str(json_variant['boss']) if 'boss' in json_variant else None
+        self.mission_type = str(json_variant['missionType']) if 'missionType' in json_variant else None
+        self.planet = str(json_variant['planet']) if 'planet' in json_variant else None
+        self.modifier = str(json_variant['modifier']) if 'modifier' in json_variant else None
+        self.modifier_description = str(json_variant['modifierDescription']) if 'modifierDescription' in json_variant else None
 
 class Sortie(WarframeObj):
     def __init__(self, json_sortie: dict):
-        json_sortie = defaultdict(lambda : None, json_sortie)
-        self.id = json_sortie['id']
+        self.id = str(json_sortie['id']) if 'id' in json_sortie else None
         self.activation = isoparse(json_sortie['activation']) if 'activation' in json_sortie else None
         self.expiry = isoparse(json_sortie['expiry']) if 'expiry' in json_sortie else None
-        self.start_string = json_sortie['startString']
-        self.active = json_sortie['active']
-        self.reward_pool = json_sortie['rewardPool']
+        self.start_string = str(json_sortie['startString']) if 'startString' in json_sortie else None
+        self.active = bool(json_sortie['active']) if 'active' in json_sortie else None
+        self.reward_pool = str(json_sortie['rewardPool']) if 'rewardPool' in json_sortie else None
         self.variants = [Variant(variant) for variant in json_sortie['variants']] if 'variants' in json_sortie else None
-        self.boss = json_sortie['boss']
-        self.faction = json_sortie['faction']
-        self.faction_key = json_sortie['factionKey']
-        self.expired = json_sortie['expired']
-        self.eta = json_sortie['eta']
\ No newline at end of file
+        self.boss = str(json_sortie['boss']) if 'boss' in json_sortie else None
+        self.faction = str(json_sortie['faction']) if 'faction' in json_sortie else None
+        self.faction_key = str(json_sortie['factionKey']) if 'factionKey' in json_sortie else None
+        self.expired = bool(json_sortie['expired']) if 'expired' in json_sortie else None
+        self.eta = str(json_sortie['eta']) if 'eta' in json_sortie else None
\ No newline at end of file
diff --git a/pyframe/models/steel_path.py b/pyframe/models/steel_path.py
index c462b9b..cb0584b 100644
--- a/pyframe/models/steel_path.py
+++ b/pyframe/models/steel_path.py
@@ -1,28 +1,24 @@
 from pyframe.models.common import WarframeObj
-from collections import defaultdict
 from dateutil.parser import isoparse
 
 class Incursions(WarframeObj):
     def __init__(self, json_incursions: dict):
-        json_incursions = defaultdict(lambda : None, json_incursions)
-        self.id = json_incursions['id']
+        self.id = str(json_incursions['id']) if 'id' in json_incursions else None
         self.activation = isoparse(json_incursions['activation']) if 'activation' in json_incursions else None
         self.expiry = isoparse(json_incursions['expiry']) if 'expiry' in json_incursions else None
-        self.active = json_incursions['active']
+        self.active = bool(json_incursions['active']) if 'active' in json_incursions else None
 
 class SteelPathItem(WarframeObj): 
     def __init__(self, json_steel_path_item: dict):
-        json_steel_path_item = defaultdict(lambda : None, json_steel_path_item)
-        self.name = json_steel_path_item['name']
-        self.cost = json_steel_path_item['cost']
+        self.name = str(json_steel_path_item['name']) if 'name' in json_steel_path_item else None
+        self.cost = int(json_steel_path_item['cost']) if 'cost' in json_steel_path_item else None
 
 class SteelPath(WarframeObj):
     def __init__(self, json_steel_path: dict):
-        json_steel_path = defaultdict(lambda : None, json_steel_path)
         self.activation = isoparse(json_steel_path['activation']) if 'activation' in json_steel_path else None
         self.expiry = isoparse(json_steel_path['expiry']) if 'expiry' in json_steel_path else None
         self.current_reward = SteelPathItem(json_steel_path['currentReward']) if 'currentReward' in json_steel_path else None
-        self.remaining = json_steel_path['remaining']
+        self.remaining = str(json_steel_path['remaining']) if 'remaining' in json_steel_path else None
         self.rotation = [SteelPathItem(rotation) for rotation in json_steel_path['rotation']] if 'rotation' in json_steel_path else []
         self.evergreens = [SteelPathItem(evergreen) for evergreen in json_steel_path['evergreens']] if 'evergreens' in json_steel_path else []
         self.incursions = Incursions(json_steel_path['incursions']) if 'incursions' in json_steel_path else None
\ No newline at end of file
diff --git a/pyframe/models/syndicate_mission.py b/pyframe/models/syndicate_mission.py
index 0cd8967..cfcd7c4 100644
--- a/pyframe/models/syndicate_mission.py
+++ b/pyframe/models/syndicate_mission.py
@@ -1,14 +1,12 @@
-from collections import defaultdict
 from dateutil.parser import isoparse
 from pyframe.models.common import WarframeObj, Job
 
 class SyndicateMission(WarframeObj):
     def __init__(self, json_syndicate_mission: dict):
-        json_syndicate_mission = defaultdict(lambda : None, json_syndicate_mission)
-        self.nodes = json_syndicate_mission['nodes'] if 'nodes' in json_syndicate_mission else []
-        self.eta = json_syndicate_mission['eta']
+        self.nodes = list[str](json_syndicate_mission['nodes']) if 'nodes' in json_syndicate_mission else []
+        self.eta = str(json_syndicate_mission['eta']) if 'eta' in json_syndicate_mission else None
         self.jobs = [Job(job) for job in json_syndicate_mission['jobs']] if 'jobs' in json_syndicate_mission else []
-        self.syndicate = json_syndicate_mission['syndicate']
-        self.id = json_syndicate_mission['id']
+        self.syndicate = str(json_syndicate_mission['syndicate']) if 'syndicate' in json_syndicate_mission else None
+        self.id = str(json_syndicate_mission['id']) if 'id' in json_syndicate_mission else None
         self.expiry = isoparse(json_syndicate_mission['expiry']) if 'expiry' in json_syndicate_mission else None
         self.activation = isoparse(json_syndicate_mission['activation']) if 'activation' in json_syndicate_mission else None
diff --git a/pyframe/models/vallis_cycle.py b/pyframe/models/vallis_cycle.py
index c01d533..0705754 100644
--- a/pyframe/models/vallis_cycle.py
+++ b/pyframe/models/vallis_cycle.py
@@ -1,11 +1,9 @@
-from collections import defaultdict
 from pyframe.models.common import WarframeObj
 from dateutil.parser import isoparse
 
 class VallisCycle(WarframeObj):
     def __init__(self, json_vallis_cycle : dict):
-        json_vallis_cycle = defaultdict(lambda : None, json_vallis_cycle)
-        self.id = json_vallis_cycle['id']
+        self.id = str(json_vallis_cycle['id']) if 'id' in json_vallis_cycle else None
         self.expiry = isoparse(json_vallis_cycle['expiry']) if 'expiry' in json_vallis_cycle else None
-        self.time_left = json_vallis_cycle['timeLeft']
-        self.is_warm = json_vallis_cycle['isWarm']
+        self.time_left = str(json_vallis_cycle['timeLeft']) if 'timeLeft' in json_vallis_cycle else None
+        self.is_warm = bool(json_vallis_cycle['isWarm']) if 'isWarm' in json_vallis_cycle else None
diff --git a/pyframe/models/void_trader.py b/pyframe/models/void_trader.py
index 363e94b..d4abec3 100644
--- a/pyframe/models/void_trader.py
+++ b/pyframe/models/void_trader.py
@@ -1,24 +1,21 @@
-from collections import defaultdict
 from dateutil.parser import isoparse
 from pyframe.models.common import WarframeObj
 
 class VoidTrader(WarframeObj):
     def __init__(self, json_void_trader: dict):
-        json_void_trader = defaultdict(lambda : None, json_void_trader)
-        self.id = json_void_trader['id']
+        self.id = str(json_void_trader['id']) if 'id' in json_void_trader else None
         self.activation = isoparse(json_void_trader['activation']) if 'activation' in json_void_trader else None
         self.expiry = isoparse(json_void_trader['expiry']) if 'expiry' in json_void_trader else None
-        self.start_string = json_void_trader['startString']
-        self.active = json_void_trader['active']
-        self.character = json_void_trader['character']
-        self.location = json_void_trader['location']
+        self.start_string = str(json_void_trader['startString']) if 'startString' in json_void_trader else None
+        self.active = bool(json_void_trader['active']) if 'active' in json_void_trader else None
+        self.character = str(json_void_trader['character']) if 'character' in json_void_trader else None
+        self.location = str(json_void_trader['location']) if 'location' in json_void_trader else None
         self.inventory = [VoidTraderItem(item) for item in json_void_trader['inventory']] if 'inventory' in json_void_trader else []
-        self.ps_id = json_void_trader['psId']
-        self.end_string = json_void_trader['endString']
+        self.ps_id = str(json_void_trader['psId']) if 'psId' in json_void_trader else None
+        self.end_string = str(json_void_trader['endString']) if 'endString' in json_void_trader else None
 
 class VoidTraderItem(WarframeObj):
     def __init__(self, json_void_trader_item):
-        json_void_trader_item = defaultdict(lambda : None, json_void_trader_item)
-        self.item = json_void_trader_item['item']
-        self.ducats = json_void_trader_item['ducats']
-        self.credits = json_void_trader_item['credits']
\ No newline at end of file
+        self.item = str(json_void_trader_item['item']) if 'item' in json_void_trader_item else None
+        self.ducats = int(json_void_trader_item['ducats']) if 'ducats' in json_void_trader_item else None
+        self.credits = int(json_void_trader_item['credits']) if 'credits' in json_void_trader_item else None
\ No newline at end of file
diff --git a/pyframe/models/worldstate.py b/pyframe/models/worldstate.py
index 6d39e4c..b3c8bab 100644
--- a/pyframe/models/worldstate.py
+++ b/pyframe/models/worldstate.py
@@ -25,11 +25,12 @@
 from pyframe.models.syndicate_mission import SyndicateMission
 from pyframe.models.vallis_cycle import VallisCycle
 from pyframe.models.void_trader import VoidTrader
+from dateutil.parser import isoparse
 
 class Worldstate(WarframeObj):
     def __init__(self, json_worldstate: dict):
         json_worldstate = defaultdict(lambda : None, json_worldstate)
-        self.timestamp = json_worldstate['timestamp']
+        self.timestamp = isoparse(json_worldstate['timestamp']) if 'timestamp' in json_worldstate else None
         self.alerts = [Alert(alert) for alert in json_worldstate['alerts']] if 'alerts' in json_worldstate else []
         self.arbitration = Arbitration(json_worldstate['arbitration']) if 'arbitration' in json_worldstate else None
         self.archon_hunt = ArchonHunt(json_worldstate['archonHunt']) if 'archonHunt' in json_worldstate else None

From 608cd018b56868315e0280eb1b1548470a670ba8 Mon Sep 17 00:00:00 2001
From: LilTOJustice <muianick4@gmail.com>
Date: Tue, 30 Jan 2024 21:08:53 -0800
Subject: [PATCH 2/3] Deprecated dateutil

---
 pyframe/models/alert.py              | 3 +--
 pyframe/models/arbitration.py        | 3 +--
 pyframe/models/archon_hunt.py        | 3 +--
 pyframe/models/cambion_cycle.py      | 3 +--
 pyframe/models/cetus_cycle.py        | 3 +--
 pyframe/models/common.py             | 6 +++++-
 pyframe/models/conclave_challenge.py | 3 +--
 pyframe/models/daily_deal.py         | 3 +--
 pyframe/models/earth_cycle.py        | 3 +--
 pyframe/models/event.py              | 3 +--
 pyframe/models/fissure.py            | 3 +--
 pyframe/models/global_upgrade.py     | 3 +--
 pyframe/models/invasion.py           | 3 +--
 pyframe/models/kuva.py               | 3 +--
 pyframe/models/news.py               | 3 +--
 pyframe/models/nightwave.py          | 3 +--
 pyframe/models/sortie.py             | 3 +--
 pyframe/models/steel_path.py         | 3 +--
 pyframe/models/syndicate_mission.py  | 3 +--
 pyframe/models/vallis_cycle.py       | 3 +--
 pyframe/models/void_trader.py        | 3 +--
 pyframe/models/worldstate.py         | 6 ++----
 22 files changed, 27 insertions(+), 45 deletions(-)

diff --git a/pyframe/models/alert.py b/pyframe/models/alert.py
index 5fb2688..11b7aa2 100644
--- a/pyframe/models/alert.py
+++ b/pyframe/models/alert.py
@@ -1,5 +1,4 @@
-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):
diff --git a/pyframe/models/arbitration.py b/pyframe/models/arbitration.py
index 6d7b206..16cbd20 100644
--- a/pyframe/models/arbitration.py
+++ b/pyframe/models/arbitration.py
@@ -1,5 +1,4 @@
-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):
diff --git a/pyframe/models/archon_hunt.py b/pyframe/models/archon_hunt.py
index d03bedb..c650bda 100644
--- a/pyframe/models/archon_hunt.py
+++ b/pyframe/models/archon_hunt.py
@@ -1,5 +1,4 @@
-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):
diff --git a/pyframe/models/cambion_cycle.py b/pyframe/models/cambion_cycle.py
index ef4aad1..c9cab68 100644
--- a/pyframe/models/cambion_cycle.py
+++ b/pyframe/models/cambion_cycle.py
@@ -1,5 +1,4 @@
-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):
diff --git a/pyframe/models/cetus_cycle.py b/pyframe/models/cetus_cycle.py
index e96f840..8fb85fa 100644
--- a/pyframe/models/cetus_cycle.py
+++ b/pyframe/models/cetus_cycle.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class CetusCycle(WarframeObj):
     def __init__(self, json_cetus_cycle: dict):
diff --git a/pyframe/models/common.py b/pyframe/models/common.py
index a27ccf6..801833a 100644
--- a/pyframe/models/common.py
+++ b/pyframe/models/common.py
@@ -1,5 +1,9 @@
+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)
 
diff --git a/pyframe/models/conclave_challenge.py b/pyframe/models/conclave_challenge.py
index c974fa6..b121d0c 100644
--- a/pyframe/models/conclave_challenge.py
+++ b/pyframe/models/conclave_challenge.py
@@ -1,5 +1,4 @@
-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):
diff --git a/pyframe/models/daily_deal.py b/pyframe/models/daily_deal.py
index d662d13..91680b0 100644
--- a/pyframe/models/daily_deal.py
+++ b/pyframe/models/daily_deal.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class DailyDeal(WarframeObj):
     def __init__(self, json_daily_deal: dict):
diff --git a/pyframe/models/earth_cycle.py b/pyframe/models/earth_cycle.py
index 6951836..e0da55c 100644
--- a/pyframe/models/earth_cycle.py
+++ b/pyframe/models/earth_cycle.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class EarthCycle(WarframeObj):
     def __init__(self, json_earth_cycle: dict):
diff --git a/pyframe/models/event.py b/pyframe/models/event.py
index f828b35..ac12dcd 100644
--- a/pyframe/models/event.py
+++ b/pyframe/models/event.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import Reward, WarframeObj, Job
-from dateutil.parser import isoparse
+from pyframe.models.common import Reward, WarframeObj, Job, isoparse
 
 class Message(WarframeObj):
     def __init__(self, json_message: dict):
diff --git a/pyframe/models/fissure.py b/pyframe/models/fissure.py
index f10514a..bdcd6ef 100644
--- a/pyframe/models/fissure.py
+++ b/pyframe/models/fissure.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class Fissure(WarframeObj):
     def __init__(self, json_fissure: dict):
diff --git a/pyframe/models/global_upgrade.py b/pyframe/models/global_upgrade.py
index 5e7fffb..aa2127a 100644
--- a/pyframe/models/global_upgrade.py
+++ b/pyframe/models/global_upgrade.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class GlobalUpgrade(WarframeObj):
     def __init__(self, json_global_upgrade: dict):
diff --git a/pyframe/models/invasion.py b/pyframe/models/invasion.py
index 524e0c8..450ece1 100644
--- a/pyframe/models/invasion.py
+++ b/pyframe/models/invasion.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import Reward, WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import Reward, WarframeObj, isoparse
 
 class AttackerDefender(WarframeObj):
     def __init__(self, json_attacker: dict):
diff --git a/pyframe/models/kuva.py b/pyframe/models/kuva.py
index 5667d05..1a51ed8 100644
--- a/pyframe/models/kuva.py
+++ b/pyframe/models/kuva.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class Kuva(WarframeObj):
     def __init__(self, json_kuva: dict):
diff --git a/pyframe/models/news.py b/pyframe/models/news.py
index 4ebb7ff..729395e 100644
--- a/pyframe/models/news.py
+++ b/pyframe/models/news.py
@@ -1,5 +1,4 @@
-from dateutil.parser import isoparse
-from pyframe.models.common import WarframeObj
+from pyframe.models.common import WarframeObj, isoparse
 
 class News(WarframeObj):
     def __init__(self, json_news: dict):
diff --git a/pyframe/models/nightwave.py b/pyframe/models/nightwave.py
index 0e1bcff..2e4531e 100644
--- a/pyframe/models/nightwave.py
+++ b/pyframe/models/nightwave.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class Challenge(WarframeObj):
     def __init__(self, json_challenge: dict):
diff --git a/pyframe/models/sortie.py b/pyframe/models/sortie.py
index cd6fe1e..4a65d94 100644
--- a/pyframe/models/sortie.py
+++ b/pyframe/models/sortie.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class Variant(WarframeObj):
     def __init__(self, json_variant: dict):
diff --git a/pyframe/models/steel_path.py b/pyframe/models/steel_path.py
index cb0584b..3832cfc 100644
--- a/pyframe/models/steel_path.py
+++ b/pyframe/models/steel_path.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class Incursions(WarframeObj):
     def __init__(self, json_incursions: dict):
diff --git a/pyframe/models/syndicate_mission.py b/pyframe/models/syndicate_mission.py
index cfcd7c4..12611a5 100644
--- a/pyframe/models/syndicate_mission.py
+++ b/pyframe/models/syndicate_mission.py
@@ -1,5 +1,4 @@
-from dateutil.parser import isoparse
-from pyframe.models.common import WarframeObj, Job
+from pyframe.models.common import WarframeObj, Job, isoparse
 
 class SyndicateMission(WarframeObj):
     def __init__(self, json_syndicate_mission: dict):
diff --git a/pyframe/models/vallis_cycle.py b/pyframe/models/vallis_cycle.py
index 0705754..fdf1783 100644
--- a/pyframe/models/vallis_cycle.py
+++ b/pyframe/models/vallis_cycle.py
@@ -1,5 +1,4 @@
-from pyframe.models.common import WarframeObj
-from dateutil.parser import isoparse
+from pyframe.models.common import WarframeObj, isoparse
 
 class VallisCycle(WarframeObj):
     def __init__(self, json_vallis_cycle : dict):
diff --git a/pyframe/models/void_trader.py b/pyframe/models/void_trader.py
index d4abec3..2c1ea56 100644
--- a/pyframe/models/void_trader.py
+++ b/pyframe/models/void_trader.py
@@ -1,5 +1,4 @@
-from dateutil.parser import isoparse
-from pyframe.models.common import WarframeObj
+from pyframe.models.common import WarframeObj, isoparse
 
 class VoidTrader(WarframeObj):
     def __init__(self, json_void_trader: dict):
diff --git a/pyframe/models/worldstate.py b/pyframe/models/worldstate.py
index b3c8bab..537302a 100644
--- a/pyframe/models/worldstate.py
+++ b/pyframe/models/worldstate.py
@@ -1,4 +1,4 @@
-from collections import defaultdict
+from datetime import datetime
 from pyframe.models.alert import Alert
 from pyframe.models.arbitration import Arbitration
 from pyframe.models.archon_hunt import ArchonHunt
@@ -25,12 +25,10 @@
 from pyframe.models.syndicate_mission import SyndicateMission
 from pyframe.models.vallis_cycle import VallisCycle
 from pyframe.models.void_trader import VoidTrader
-from dateutil.parser import isoparse
 
 class Worldstate(WarframeObj):
     def __init__(self, json_worldstate: dict):
-        json_worldstate = defaultdict(lambda : None, json_worldstate)
-        self.timestamp = isoparse(json_worldstate['timestamp']) if 'timestamp' in json_worldstate else None
+        self.timestamp = datetime.fromisoformat(json_worldstate['timestamp']) if 'timestamp' in json_worldstate else None
         self.alerts = [Alert(alert) for alert in json_worldstate['alerts']] if 'alerts' in json_worldstate else []
         self.arbitration = Arbitration(json_worldstate['arbitration']) if 'arbitration' in json_worldstate else None
         self.archon_hunt = ArchonHunt(json_worldstate['archonHunt']) if 'archonHunt' in json_worldstate else None

From b952b498cc65cb192150636823961cfe15cc3c62 Mon Sep 17 00:00:00 2001
From: LilTOJustice <muianick4@gmail.com>
Date: Tue, 30 Jan 2024 21:11:06 -0800
Subject: [PATCH 3/3] Remove dateutil requirement from package setup and bump
 version for release

---
 setup.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/setup.py b/setup.py
index 01356fd..20995ba 100644
--- a/setup.py
+++ b/setup.py
@@ -2,11 +2,11 @@
 
 long_desc = open("README.md").read()
 liscense = open("LICENSE").read()
-required = ["python-dateutil"]
+required = []
 
 setuptools.setup(
     name="python-PyFrame",
-    version="1.0.5",
+    version="1.0.6",
     author="LilTOJustice",
     author_email="muianick4@gmail.com",
     license=liscense,