def __init__(self):
config = edrconfig.EDRConfig()
self.REST_firebase = RESTFirebase.RESTFirebaseAuth()
self.EDR_API_KEY = config.edr_api_key()
self.EDR_SERVER = config.edr_server()
self.player_name = None
self.version = edrconfig.EDRConfig().edr_version()
def __init__(self, edrserver, edrinara):
self.server = edrserver
self.inara = edrinara
self._player = EDCmdr()
self.heartbeat_timestamp = None
edr_config = edrconfig.EDRConfig()
self._edr_heartbeat = edr_config.edr_heartbeat()
try:
with open(self.EDR_CMDRS_CACHE, 'rb') as handle:
self.cmdrs_cache = pickle.load(handle)
except:
self.cmdrs_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.cmdrs_max_age())
try:
with open(self.EDR_INARA_CACHE, 'rb') as handle:
self.inara_cache = pickle.load(handle)
except:
self.inara_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.inara_max_age())
try:
with open(self.EDR_SQDRDEX_CACHE, 'rb') as handle:
self.sqdrdex_cache = pickle.load(handle)
except:
self.sqdrdex_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.sqdrdex_max_age())
def __init__(self, server, opponent_kind, client_callback):
self.server = server
self.kind = opponent_kind
self.powerplay = None
self.realtime_callback = client_callback
self.realtime = None
config = edrconfig.EDRConfig()
try:
with open(self.EDR_OPPONENTS_SIGHTINGS_CACHES[opponent_kind],
'rb') as handle:
self.sightings = pickle.load(handle)
except:
self.sightings = lrucache.LRUCache(
config.lru_max_size(), config.opponents_max_age(self.kind))
try:
with open(self.EDR_OPPONENTS_RECENTS_CACHES[opponent_kind],
'rb') as handle:
self.recents = pickle.load(handle)
except:
self.recents = deque(
maxlen=config.opponents_max_recents(self.kind))
self.timespan = config.opponents_recent_threshold(self.kind)
self.reports_check_interval = config.reports_check_interval()
def __init__(self):
self.type = None
self.size = None
self.name = None
self.id = None
self.identity = None
self.rebuy = None
self._value = None
self.hot = False
now = EDTime.py_epoch_now()
self._hull_health = {"timestamp": now, "value": 100.0}
self._shield_health = {"timestamp": now, "value": 100.0}
self.shield_up = True
self.subsystems = {}
self.timestamp = now
self.fight = {u"value": False, "large": False, u"timestamp": now}
self._hardpoints_deployed = {u"value": False, u"timestamp": now}
self._attacked = {u"value": False, u"timestamp": now}
self.heat_damaged = {u"value": False, u"timestamp": now}
self._in_danger = {u"value": False, u"timestamp": now}
self._low_fuel = {u"value": False, u"timestamp": now}
config = edrconfig.EDRConfig()
self.fight_staleness_threshold = config.instance_fight_staleness_threshold()
self.danger_staleness_threshold = config.instance_danger_staleness_threshold()
self.seats = 1
self.fuel_capacity = None
self.fuel_level = None
self.attitude = EDVehicleAttitude()
self.module_info_timestamp = None
self.slots_timestamp = None
self.slots = {}
self.modules = None
self.power_capacity = None
self.cargo_capacity = 0
self.cargo = edcargo.EDCargo()
def __init__(self):
config = edrconfig.EDRConfig()
self.REST_firebase = RESTFirebase.RESTFirebaseAuth()
self.EDR_API_KEY = config.edr_api_key()
self.EDR_SERVER = config.edr_server()
self.player_name = None
self.game_mode = None
self.private_group = None
self.version = edrconfig.EDRConfig().edr_version()
self._throttle_until_timestamp = None
self.anonymous_reports = None
self.fc_jump_psa = None
self.backoff = {
"EDR": backoff.Backoff(u"EDR"),
"Inara": backoff.Backoff(u"Inara")
}
self.INARA_API_KEY = config.inara_api_key()
def has_recent_traffic(self, star_system):
if self.has_sitrep(star_system):
system_reports = self.sitreps_cache.get(self.system_id(star_system))
if system_reports is None or "latestTraffic" not in system_reports:
return False
edr_config = edrconfig.EDRConfig()
return self.is_recent(system_reports["latestTraffic"],
edr_config.traffic_recent_threshold())
return False
def pledged_to(self, power, time_pledged):
if self.kind is not EDROpponents.ENEMIES:
return
if not power or self.powerplay is not power:
config = edrconfig.EDRConfig()
self.recents = deque(
maxlen=config.opponents_max_recents(self.kind))
self.sightings = lrucache.LRUCache(
config.lru_max_size(), config.opponents_max_age(self.kind))
self.powerplay = power
def __init__(self):
edr_config = edrconfig.EDRConfig()
set_language(config.get("language"))
self.edr_version = edr_config.edr_version()
EDRLOG.log(u"Version {}".format(self.edr_version), "INFO")
self.system_novelty_threshold = edr_config.system_novelty_threshold()
self.place_novelty_threshold = edr_config.place_novelty_threshold()
self.ship_novelty_threshold = edr_config.ship_novelty_threshold()
self.cognitive_novelty_threshold = edr_config.cognitive_novelty_threshold(
)
self.intel_even_if_clean = edr_config.intel_even_if_clean()
self.edr_needs_u_novelty_threshold = edr_config.edr_needs_u_novelty_threshold(
)
self.previous_ad = None
self.blips_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.blips_max_age())
self.cognitive_blips_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.blips_max_age())
self.traffic_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.traffic_max_age())
self.scans_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.scans_max_age())
self.cognitive_scans_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.blips_max_age())
self._email = tk.StringVar(value=config.get("EDREmail"))
self._password = tk.StringVar(value=config.get("EDRPassword"))
# Translators: this is shown on the EDMC's status line
self._status = tk.StringVar(value=_(u"not authenticated."))
self.status_ui = None
visual = 1 if config.get("EDRVisualFeedback") == "True" else 0
self._visual_feedback = tk.IntVar(value=visual)
audio = 1 if config.get("EDRAudioFeedback") == "True" else 0
self._audio_feedback = tk.IntVar(value=audio)
self.player = edentities.EDCmdr()
self.server = edrserver.EDRServer()
self.edrsystems = edrsystems.EDRSystems(self.server)
self.edrcmdrs = edrcmdrs.EDRCmdrs(self.server)
self.edroutlaws = edroutlaws.EDROutlaws(self.server)
self.edrlegal = edrlegalrecords.EDRLegalRecords(self.server)
self.mandatory_update = False
self.crimes_reporting = True
self.motd = []
self.tips = randomtips.RandomTips()
self.help_content = helpcontent.HelpContent()
def has_recent_outlaws(self, star_system):
if self.has_sitrep(star_system):
system_reports = self.sitreps_cache.get(
self.system_id(star_system))
if system_reports is None or "latestOutlaw" not in system_reports:
return False
edr_config = edrconfig.EDRConfig()
return self.is_recent(
system_reports["latestOutlaw"],
edr_config.opponents_recent_threshold("outlaws"))
return False
def player_pledged_to(self, power, time_pledged=0):
edr_config = edrconfig.EDRConfig()
delta = time_pledged - self._player.time_pledged if self._player.time_pledged else time_pledged
if power == self._player.power and delta <= edr_config.noteworthy_pledge_threshold(
):
EDRLOG.log(
u"Skipping pledged_to (not noteworthy): current vs. proposed {} vs. {}; {} vs {}"
.format(self._player.power, power, self._player.time_pledged,
time_pledged), "DEBUG")
return False
self._player.pledged_to(power, time_pledged)
since = self._player.pledged_since()
return self.server.pledged_to(power, since)
def has_recent_enemies(self, star_system, pledged_to):
if self.has_sitrep(star_system):
system_reports = self.sitreps_cache.get(
self.system_id(star_system))
latestEnemy = "latestEnemy_{}".format(
self.server.nodify(pledged_to))
if system_reports is None or latestEnemy not in system_reports:
return False
edr_config = edrconfig.EDRConfig()
return self.is_recent(
system_reports[latestEnemy],
edr_config.opponents_recent_threshold("enemies"))
return False
def __init__(self, server):
self.server = server
self.timespan = None
self.records_last_updated = None
self.records_check_interval = None
config = edrconfig.EDRConfig()
try:
with open(self.EDR_LEGAL_RECORDS_CACHE, 'rb') as handle:
self.records = pickle.load(handle)
except:
self.records = lrucache.LRUCache(config.lru_max_size(),
config.legal_records_max_age())
self.timespan = config.legal_records_recent_threshold()
self.reports_check_interval = config.legal_records_check_interval()
def __init__(self, server):
self.server = server
config = edrconfig.EDRConfig()
try:
with open(self.EDR_OUTLAWS_SIGHTINGS_CACHE, 'rb') as handle:
self.sightings = pickle.load(handle)
except:
self.sightings = lrucache.LRUCache(config.lru_max_size(), config.outlaws_max_age())
try:
with open(self.EDR_OUTLAWS_RECENTS_CACHE, 'rb') as handle:
self.recents = pickle.load(handle)
except:
self.recents = deque(maxlen=config.outlaws_max_recents())
self.timespan = config.outlaws_recent_threshold()
self.reports_check_interval = config.reports_check_interval()
def __init__(self, server):
edr_config = edrconfig.EDRConfig()
try:
with open(self.EDR_SYSTEMS_CACHE, 'rb') as handle:
self.systems_cache = pickle.load(handle)
except:
self.systems_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.systems_max_age())
try:
with open(self.EDR_NOTAMS_CACHE, 'rb') as handle:
self.notams_cache = pickle.load(handle)
except:
self.notams_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.notams_max_age())
try:
with open(self.EDR_SITREPS_CACHE, 'rb') as handle:
self.sitreps_cache = pickle.load(handle)
except:
self.sitreps_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.sitreps_max_age())
try:
with open(self.EDR_CRIMES_CACHE, 'rb') as handle:
self.crimes_cache = pickle.load(handle)
except:
self.crimes_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.crimes_max_age())
try:
with open(self.EDR_TRAFFIC_CACHE, 'rb') as handle:
self.traffic_cache = pickle.load(handle)
except:
self.traffic_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.traffic_max_age())
self.reports_check_interval = edr_config.reports_check_interval()
self.notams_check_interval = edr_config.notams_check_interval()
self.timespan = edr_config.sitreps_timespan()
self.server = server
def __init__(self, server):
self.server = server
self.inara = edrinara.EDRInara()
edr_config = edrconfig.EDRConfig()
try:
with open(self.EDR_CMDRS_CACHE, 'rb') as handle:
self.cmdrs_cache = pickle.load(handle)
except:
self.cmdrs_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.cmdrs_max_age())
try:
with open(self.EDR_INARA_CACHE, 'rb') as handle:
self.inara_cache = pickle.load(handle)
except:
self.inara_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.inara_max_age())
def __init__(self, server):
self.reasonable_sc_distance = 1500
self.reasonable_hs_radius = 50
edr_config = edrconfig.EDRConfig()
try:
with open(self.EDR_SYSTEMS_CACHE, 'rb') as handle:
self.systems_cache = pickle.load(handle)
except:
self.systems_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.systems_max_age())
try:
with open(self.EDR_NOTAMS_CACHE, 'rb') as handle:
self.notams_cache = pickle.load(handle)
except:
self.notams_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.notams_max_age())
try:
with open(self.EDR_SITREPS_CACHE, 'rb') as handle:
self.sitreps_cache = pickle.load(handle)
except:
self.sitreps_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.sitreps_max_age())
try:
with open(self.EDR_CRIMES_CACHE, 'rb') as handle:
self.crimes_cache = pickle.load(handle)
except:
self.crimes_cache = lrucache.LRUCache(edr_config.lru_max_size(),
edr_config.crimes_max_age())
try:
with open(self.EDR_TRAFFIC_CACHE, 'rb') as handle:
self.traffic_cache = pickle.load(handle)
except:
self.traffic_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.traffic_max_age())
try:
with open(self.EDSM_SYSTEMS_CACHE, 'rb') as handle:
self.edsm_systems_cache = pickle.load(handle)
except:
self.edsm_systems_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.edsm_systems_max_age())
try:
with open(self.EDSM_STATIONS_CACHE, 'rb') as handle:
self.edsm_stations_cache = pickle.load(handle)
except:
self.edsm_stations_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.edsm_stations_max_age())
try:
with open(self.EDSM_FACTIONS_CACHE, 'rb') as handle:
self.edsm_factions_cache = pickle.load(handle)
except:
self.edsm_factions_cache = lrucache.LRUCache(
edr_config.lru_max_size(), edr_config.edsm_factions_max_age())
try:
with open(self.EDSM_SYSTEMS_WITHIN_RADIUS_CACHE, 'rb') as handle:
self.edsm_systems_within_radius_cache = pickle.load(handle)
except:
self.edsm_systems_within_radius_cache = lrucache.LRUCache(
edr_config.edsm_within_radius_max_size(),
edr_config.edsm_systems_max_age())
self.reports_check_interval = edr_config.reports_check_interval()
self.notams_check_interval = edr_config.notams_check_interval()
self.timespan = edr_config.sitreps_timespan()
self.timespan_notams = edr_config.notams_timespan()
self.server = server
self.edsm_server = edsmserver.EDSMServer()
def __init__(self, value):
self.value = value
config = edrconfig.EDRConfig()
self.threshold = config.intel_bounty_threshold()
def __init__(self):
config = edrconfig.EDRConfig()
self.EDSM_API_KEY = config.edsm_api_key()
self.EDSM_SERVER = config.edsm_server()
def __init__(self):
config = edrconfig.EDRConfig()
self.REST_firebase = RESTFirebase.RESTFirebaseAuth()
self.EDR_API_KEY = config.edr_api_key()
self.EDR_SERVER = config.edr_server()
def __init__(self):
config = edrconfig.EDRConfig()
self.version = config.edr_version()
self.INARA_API_KEY = config.inara_api_key()
self.INARA_ENDPOINT = config.inara_endpoint()
self.requester = None
def __init__(self):
config = edrconfig.EDRConfig()
self.importance_threshold = self.LEVEL_MAPPING.get(config.logging_level(), 0)
