1377 lines
44 KiB
Python
1377 lines
44 KiB
Python
import datetime
|
|
import hashlib
|
|
import threading
|
|
import warnings
|
|
import weakref
|
|
from decimal import Decimal
|
|
from io import BytesIO
|
|
from typing import Any, Dict, Generator, Iterable, List, NamedTuple, NoReturn, Optional, Tuple, Union
|
|
|
|
from requests import HTTPError, Response, Session, post
|
|
|
|
from erepublik import _types as types
|
|
from erepublik import constants, utils
|
|
|
|
__all__ = [
|
|
"Battle",
|
|
"BattleDivision",
|
|
"BattleSide",
|
|
"Company",
|
|
"Config",
|
|
"Details",
|
|
"Energy",
|
|
"ErepublikException",
|
|
"ErepublikNetworkException",
|
|
"CloudFlareSessionError",
|
|
"CaptchaSessionError",
|
|
"EnergyToFight",
|
|
"Holding",
|
|
"Inventory",
|
|
"MyCompanies",
|
|
"OfferItem",
|
|
"Politics",
|
|
"Reporter",
|
|
"TelegramReporter",
|
|
]
|
|
|
|
|
|
class ErepublikException(Exception):
|
|
def __init__(self, message):
|
|
super().__init__(message)
|
|
|
|
|
|
class ErepublikNetworkException(ErepublikException):
|
|
def __init__(self, message, request):
|
|
super().__init__(message)
|
|
self.request = request
|
|
|
|
|
|
class CloudFlareSessionError(ErepublikNetworkException):
|
|
pass
|
|
|
|
|
|
class CaptchaSessionError(ErepublikNetworkException):
|
|
pass
|
|
|
|
|
|
class Holding:
|
|
id: int
|
|
region: int
|
|
companies: List["Company"]
|
|
name: str
|
|
_citizen = weakref.ReferenceType
|
|
|
|
def __init__(self, _id: int, region: int, citizen, name: str = None):
|
|
self._citizen = weakref.ref(citizen)
|
|
self.id: int = _id
|
|
self.region: int = region
|
|
self.companies: List["Company"] = list()
|
|
if name:
|
|
self.name = name
|
|
else:
|
|
comp_sum = len(self.companies)
|
|
name = f"Holding (#{self.id}) with {comp_sum} "
|
|
if comp_sum == 1:
|
|
name += "company"
|
|
else:
|
|
name += "companies"
|
|
self.name = name
|
|
|
|
@property
|
|
def wam_count(self) -> int:
|
|
return len([1 for company in self.companies if company.wam_enabled and not company.already_worked])
|
|
|
|
@property
|
|
def wam_companies(self) -> Iterable["Company"]:
|
|
return [company for company in self.companies if company.wam_enabled]
|
|
|
|
@property
|
|
def employable_companies(self) -> Iterable["Company"]:
|
|
return [company for company in self.companies if company.preset_works]
|
|
|
|
def add_company(self, company: "Company") -> NoReturn:
|
|
self.companies.append(company)
|
|
self.companies.sort()
|
|
|
|
def get_wam_raw_usage(self) -> Dict[str, Decimal]:
|
|
frm = Decimal("0.00")
|
|
wrm = Decimal("0.00")
|
|
for company in self.wam_companies:
|
|
if company.industry in [1, 7, 8, 9, 10, 11]:
|
|
frm += company.raw_usage
|
|
elif company.industry in [2, 12, 13, 14, 15, 16]:
|
|
wrm += company.raw_usage
|
|
return dict(frm=frm, wrm=wrm)
|
|
|
|
def get_wam_companies(self, raw_factory: bool = None) -> List["Company"]:
|
|
raw = []
|
|
factory = []
|
|
for company in self.wam_companies:
|
|
if not company.already_worked and not company.cannot_wam_reason == "war":
|
|
if company.is_raw:
|
|
raw.append(company)
|
|
else:
|
|
factory.append(company)
|
|
if raw_factory is None:
|
|
return raw + factory
|
|
else:
|
|
return raw if raw_factory else factory
|
|
|
|
def __str__(self) -> str:
|
|
comp = len(self.companies)
|
|
name = f"Holding (#{self.id}) with {comp} "
|
|
if comp == 1:
|
|
name += "company"
|
|
else:
|
|
name += "companies"
|
|
return name
|
|
|
|
def __repr__(self):
|
|
return str(self)
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[str, int, List[Dict[str, Union[str, int, bool, float, Decimal]]]]]:
|
|
return dict(
|
|
name=self.name,
|
|
id=self.id,
|
|
region=self.region,
|
|
companies=[c.as_dict for c in self.companies],
|
|
wam_count=self.wam_count,
|
|
)
|
|
|
|
@property
|
|
def citizen(self):
|
|
return self._citizen()
|
|
|
|
|
|
class Company:
|
|
_holding: weakref.ReferenceType
|
|
holding: Holding
|
|
id: int
|
|
quality: int
|
|
is_raw: bool
|
|
raw_usage: Decimal
|
|
products_made: Decimal
|
|
wam_enabled: bool
|
|
can_wam: bool
|
|
cannot_wam_reason: str
|
|
industry: int
|
|
already_worked: bool
|
|
preset_works: int
|
|
|
|
def __init__(
|
|
self,
|
|
holding: Holding,
|
|
_id: int,
|
|
quality: int,
|
|
is_raw: bool,
|
|
effective_bonus: Decimal,
|
|
raw_usage: Decimal,
|
|
base_production: Decimal,
|
|
wam_enabled: bool,
|
|
can_wam: bool,
|
|
cannot_wam_reason: str,
|
|
industry: int,
|
|
already_worked: bool,
|
|
preset_works: int,
|
|
):
|
|
self._holding = weakref.ref(holding)
|
|
self.id: int = _id
|
|
self.industry: int = industry
|
|
self.quality: int = self._get_real_quality(quality)
|
|
self.is_raw: bool = is_raw
|
|
self.wam_enabled: bool = wam_enabled
|
|
self.can_wam: bool = can_wam
|
|
self.cannot_wam_reason: str = cannot_wam_reason
|
|
self.already_worked: bool = already_worked
|
|
self.preset_works: int = preset_works
|
|
|
|
self.products_made = self.raw_usage = Decimal(base_production) * Decimal(effective_bonus)
|
|
if not self.is_raw:
|
|
self.raw_usage = -self.products_made * raw_usage
|
|
|
|
def _get_real_quality(self, quality) -> int:
|
|
# 7: 'FRM q1', 8: 'FRM q2', 9: 'FRM q3', 10: 'FRM q4', 11: 'FRM q5',
|
|
# 12: 'WRM q1', 13: 'WRM q2', 14: 'WRM q3', 15: 'WRM q4', 16: 'WRM q5',
|
|
# 18: 'HRM q1', 19: 'HRM q2', 20: 'HRM q3', 21: 'HRM q4', 22: 'HRM q5',
|
|
# 24: 'ARM q1', 25: 'ARM q2', 26: 'ARM q3', 27: 'ARM q4', 28: 'ARM q5',
|
|
if 7 <= self.industry <= 11:
|
|
return self.industry % 6
|
|
elif 12 <= self.industry <= 16:
|
|
return self.industry % 11
|
|
elif 18 <= self.industry <= 22:
|
|
return self.industry % 17
|
|
elif 24 <= self.industry <= 28:
|
|
return self.industry % 23
|
|
else:
|
|
return quality
|
|
|
|
@property
|
|
def _internal_industry(self) -> int:
|
|
# 7: 'FRM q1', 8: 'FRM q2', 9: 'FRM q3', 10: 'FRM q4', 11: 'FRM q5',
|
|
# 12: 'WRM q1', 13: 'WRM q2', 14: 'WRM q3', 15: 'WRM q4', 16: 'WRM q5',
|
|
# 18: 'HRM q1', 19: 'HRM q2', 20: 'HRM q3', 21: 'HRM q4', 22: 'HRM q5',
|
|
# 24: 'ARM q1', 25: 'ARM q2', 26: 'ARM q3', 27: 'ARM q4', 28: 'ARM q5',
|
|
if 7 <= self.industry <= 11:
|
|
return 7
|
|
elif 12 <= self.industry <= 16:
|
|
return 12
|
|
elif 18 <= self.industry <= 22:
|
|
return 18
|
|
elif 24 <= self.industry <= 28:
|
|
return 24
|
|
else:
|
|
return self.industry
|
|
|
|
@property
|
|
def _sort_keys(self):
|
|
return not self.is_raw, self._internal_industry, self.quality, self.id
|
|
|
|
def __hash__(self):
|
|
return hash(self._sort_keys)
|
|
|
|
def __lt__(self, other: "Company"):
|
|
return self._sort_keys < other._sort_keys
|
|
|
|
def __le__(self, other: "Company"):
|
|
return self._sort_keys <= other._sort_keys
|
|
|
|
def __gt__(self, other: "Company"):
|
|
return self._sort_keys > other._sort_keys
|
|
|
|
def __ge__(self, other: "Company"):
|
|
return self._sort_keys >= other._sort_keys
|
|
|
|
def __eq__(self, other: "Company"):
|
|
return self._sort_keys == other._sort_keys
|
|
|
|
def __ne__(self, other: "Company"):
|
|
return self._sort_keys != other._sort_keys
|
|
|
|
def __str__(self):
|
|
name = f"(#{self.id:>9d}) {constants.INDUSTRIES[self.industry]}"
|
|
if not self.is_raw:
|
|
name += f" q{self.quality}"
|
|
return name
|
|
|
|
def __repr__(self):
|
|
return str(self)
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[str, int, bool, float, Decimal]]:
|
|
return dict(
|
|
name=str(self),
|
|
holding=self.holding.id,
|
|
id=self.id,
|
|
quality=self.quality,
|
|
is_raw=self.is_raw,
|
|
raw_usage=self.raw_usage,
|
|
products_made=self.products_made,
|
|
wam_enabled=self.wam_enabled,
|
|
can_wam=self.can_wam,
|
|
cannot_wam_reason=self.cannot_wam_reason,
|
|
industry=self.industry,
|
|
already_worked=self.already_worked,
|
|
preset_works=self.preset_works,
|
|
)
|
|
|
|
def dissolve(self) -> Response:
|
|
self.holding.citizen.write_log(f"{self} dissolved!")
|
|
# noinspection PyProtectedMember
|
|
return self.holding.citizen._post_economy_sell_company(self.id, self.holding.citizen.details.pin, sell=False)
|
|
|
|
def upgrade(self, level: int) -> Response:
|
|
# noinspection PyProtectedMember
|
|
return self.holding.citizen._post_economy_upgrade_company(self.id, level, self.holding.citizen.details.pin)
|
|
|
|
@property
|
|
def holding(self) -> Holding:
|
|
return self._holding()
|
|
|
|
|
|
class MyCompanies:
|
|
work_units: int = 0
|
|
next_ot_time: datetime.datetime
|
|
ff_lockdown: int = 0
|
|
|
|
holdings: Dict[int, Holding]
|
|
_companies: weakref.WeakSet
|
|
_citizen: weakref.ReferenceType
|
|
companies: Generator[Company, None, None]
|
|
_frm_fab_ids = (1, 7, 8, 9, 10, 11)
|
|
_wrm_fab_ids = (2, 12, 13, 14, 15, 16)
|
|
_hrm_fab_ids = (4, 18, 19, 20, 21, 22)
|
|
_arm_fab_ids = (23, 24, 25, 26, 27, 28)
|
|
|
|
def __init__(self, citizen):
|
|
self._citizen = weakref.ref(citizen)
|
|
self.holdings = dict()
|
|
self._companies = weakref.WeakSet()
|
|
self.next_ot_time = utils.now()
|
|
|
|
def prepare_holdings(self, holdings: Dict[str, Dict[str, Any]]):
|
|
"""
|
|
:param holdings: Parsed JSON to dict from en/economy/myCompanies
|
|
"""
|
|
for holding in holdings.values():
|
|
if holding.get("id") not in self.holdings:
|
|
self.holdings.update(
|
|
{
|
|
int(holding.get("id")): Holding(
|
|
holding["id"], holding["region_id"], self.citizen, holding["name"]
|
|
)
|
|
}
|
|
)
|
|
if not self.holdings.get(0):
|
|
self.holdings.update({0: Holding(0, 0, self.citizen, "Unassigned")}) # unassigned
|
|
|
|
def prepare_companies(self, companies: Dict[str, Dict[str, Any]]):
|
|
"""
|
|
:param companies: Parsed JSON to dict from en/economy/myCompanies
|
|
"""
|
|
self.__clear_data()
|
|
for company_dict in companies.values():
|
|
holding = self.holdings.get(int(company_dict["holding_company_id"]))
|
|
quality = company_dict.get("quality")
|
|
is_raw = company_dict.get("is_raw")
|
|
if is_raw:
|
|
raw_usage = Decimal("0.0")
|
|
else:
|
|
raw_usage = Decimal(str(company_dict.get("upgrades").get(str(quality)).get("raw_usage")))
|
|
company = Company(
|
|
holding,
|
|
company_dict.get("id"),
|
|
quality,
|
|
is_raw,
|
|
Decimal(str(company_dict.get("effective_bonus"))) / 100,
|
|
raw_usage,
|
|
Decimal(str(company_dict.get("base_production"))),
|
|
company_dict.get("wam_enabled"),
|
|
company_dict.get("can_work_as_manager"),
|
|
company_dict.get("cannot_work_as_manager_reason"),
|
|
company_dict.get("industry_id"),
|
|
company_dict.get("already_worked"),
|
|
company_dict.get("preset_works"),
|
|
)
|
|
self._companies.add(company)
|
|
holding.add_company(company)
|
|
|
|
def get_employable_factories(self) -> Dict[int, int]:
|
|
return {company.id: company.preset_works for company in self.companies if company.preset_works}
|
|
|
|
def get_total_wam_count(self) -> int:
|
|
return sum([holding.wam_count for holding in self.holdings.values()])
|
|
|
|
@staticmethod
|
|
def get_needed_inventory_usage(companies: Union[Company, Iterable[Company]]) -> Decimal:
|
|
if isinstance(companies, list):
|
|
return sum(company.products_made * (100 if company.is_raw else 1) for company in companies)
|
|
else:
|
|
return companies.products_made
|
|
|
|
def remove_factory_from_wam_list(self, raw_factories, final_factories):
|
|
frm, wrm, *_ = self.get_raw_usage_for_companies(*final_factories, *raw_factories)
|
|
inv_raw = self.citizen.inventory.raw
|
|
for raw, ids, exc in [(frm, self._frm_fab_ids, False), (wrm, self._wrm_fab_ids, False), (None, None, True)]:
|
|
if exc:
|
|
if final_factories:
|
|
final_factories.sort(key=lambda c: c.raw_usage)
|
|
return final_factories.pop(-1)
|
|
elif raw_factories:
|
|
raw_factories.sort(key=lambda c: c.raw_usage)
|
|
return raw_factories.pop(-1)
|
|
else:
|
|
if raw:
|
|
raw += Decimal(
|
|
inv_raw.get(constants.INDUSTRIES[ids[1]], {}).get(0, {}).get("amount", Decimal("0.0"))
|
|
)
|
|
if raw > 0:
|
|
to_remove = sorted(raw_factories, key=lambda c: (c.industry not in ids, c.raw_usage))
|
|
if to_remove:
|
|
return raw_factories.pop(raw_factories.index(to_remove[0]))
|
|
else:
|
|
to_remove = sorted(final_factories, key=lambda c: (c.industry != ids[0], c.raw_usage))
|
|
if to_remove:
|
|
return final_factories.pop(final_factories.index(to_remove[0]))
|
|
|
|
def get_raw_usage_for_companies(self, *companies: Company) -> Tuple[Decimal, Decimal, Decimal, Decimal]:
|
|
frm = wrm = hrm = arm = Decimal("0.00")
|
|
for company in companies:
|
|
if company.industry in self._frm_fab_ids:
|
|
frm += company.raw_usage
|
|
elif company.industry in self._wrm_fab_ids:
|
|
wrm += company.raw_usage
|
|
elif company.industry in self._hrm_fab_ids:
|
|
hrm += company.raw_usage
|
|
elif company.industry in self._arm_fab_ids:
|
|
arm += company.raw_usage
|
|
return frm, wrm, hrm, arm
|
|
|
|
@property
|
|
def companies(self) -> Generator[Company, None, None]:
|
|
return (c for c in self._companies)
|
|
|
|
def get_wam_holdings(self) -> Generator[Holding, None, None]:
|
|
for holding in sorted(self.holdings.values(), key=lambda h: (-len(h.get_wam_companies(False)), -len(h.get_wam_companies()))):
|
|
yield holding
|
|
|
|
def __str__(self):
|
|
return f"MyCompanies: {sum(1 for _ in self.companies)} companies in {len(self.holdings)} holdings"
|
|
|
|
def __repr__(self):
|
|
return str(self)
|
|
|
|
def __clear_data(self):
|
|
for holding in self.holdings.values():
|
|
for company in holding.companies: # noqa
|
|
del company
|
|
holding.companies.clear()
|
|
self._companies.clear()
|
|
|
|
@property
|
|
def as_dict(
|
|
self,
|
|
) -> Dict[
|
|
str,
|
|
Union[
|
|
str,
|
|
int,
|
|
datetime.datetime,
|
|
Dict[str, Dict[str, Union[str, int, List[Dict[str, Union[str, int, bool, float, Decimal]]]]]],
|
|
],
|
|
]:
|
|
return dict(
|
|
name=str(self),
|
|
work_units=self.work_units,
|
|
next_ot_time=self.next_ot_time,
|
|
ff_lockdown=self.ff_lockdown,
|
|
holdings={str(hi): h.as_dict for hi, h in self.holdings.items()},
|
|
company_count=sum(1 for _ in self.companies),
|
|
)
|
|
|
|
@property
|
|
def citizen(self):
|
|
return self._citizen()
|
|
|
|
|
|
class Config:
|
|
email = ""
|
|
password = ""
|
|
work = True
|
|
train = True
|
|
wam = False
|
|
ot = True
|
|
auto_sell: List[str] = None
|
|
auto_sell_all = False
|
|
employees = False
|
|
interactive = True
|
|
auto_buy_raw = False
|
|
force_wam = False
|
|
telegram = True
|
|
telegram_chat_id = 0
|
|
telegram_token = ""
|
|
spin_wheel_of_fortune = False
|
|
# fight = False
|
|
# air = False
|
|
# ground = False
|
|
# all_in = False
|
|
# next_energy = False
|
|
# boosters = False
|
|
# travel_to_fight = False
|
|
# always_travel = False
|
|
# epic_hunt = False
|
|
# epic_hunt_ebs = False
|
|
# rw_def_side = False
|
|
# continuous_fighting = False
|
|
# sort_battles_time = True
|
|
# force_travel = False
|
|
# maverick = False
|
|
|
|
def __init__(self):
|
|
self.auto_sell = []
|
|
|
|
def reset(self):
|
|
self.work = True
|
|
self.train = True
|
|
self.wam = False
|
|
self.ot = True
|
|
self.auto_sell = list()
|
|
self.auto_sell_all = False
|
|
self.employees = False
|
|
self.interactive = True
|
|
self.auto_buy_raw = False
|
|
self.force_wam = False
|
|
self.telegram = True
|
|
self.telegram_chat_id = 0
|
|
self.telegram_token = ""
|
|
self.spin_wheel_of_fortune = False
|
|
# self.fight = False
|
|
# self.air = False
|
|
# self.ground = False
|
|
# self.all_in = False
|
|
# self.next_energy = False
|
|
# self.boosters = False
|
|
# self.travel_to_fight = False
|
|
# self.always_travel = False
|
|
# self.epic_hunt = False
|
|
# self.epic_hunt_ebs = False
|
|
# self.rw_def_side = False
|
|
# self.continuous_fighting = False
|
|
# self.sort_battles_time = True
|
|
# self.force_travel = False
|
|
# self.maverick = False
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[bool, int, str, List[str]]]:
|
|
return dict(
|
|
email=self.email,
|
|
work=self.work,
|
|
train=self.train,
|
|
wam=self.wam,
|
|
ot=self.ot,
|
|
auto_sell=self.auto_sell,
|
|
auto_sell_all=self.auto_sell_all,
|
|
employees=self.employees,
|
|
interactive=self.interactive,
|
|
auto_buy_raw=self.auto_buy_raw,
|
|
force_wam=self.force_wam,
|
|
telegram=self.telegram,
|
|
telegram_chat_id=self.telegram_chat_id,
|
|
telegram_token=self.telegram_token,
|
|
spin_wheel_of_fortune=self.spin_wheel_of_fortune,
|
|
# fight=self.fight,
|
|
# air=self.air,
|
|
# ground=self.ground,
|
|
# all_in=self.all_in,
|
|
# next_energy=self.next_energy,
|
|
# travel_to_fight=self.travel_to_fight,
|
|
# always_travel=self.always_travel,
|
|
# epic_hunt=self.epic_hunt,
|
|
# epic_hunt_ebs=self.epic_hunt_ebs,
|
|
# rw_def_side=self.rw_def_side,
|
|
# maverick=self.maverick,
|
|
# continuous_fighting=self.continuous_fighting,
|
|
# sort_battles_time=self.sort_battles_time,
|
|
# force_travel=self.force_travel,
|
|
)
|
|
|
|
|
|
class Energy:
|
|
limit = 500 # energyToRecover
|
|
interval = 10 # energyPerInterval
|
|
energy = 0 # energy
|
|
_recovery_time = None
|
|
|
|
def __init__(self):
|
|
self._recovery_time = utils.now()
|
|
|
|
def __repr__(self):
|
|
return f"{self.energy:4}/{self.limit:4}, {self.interval:3}hp/6min"
|
|
|
|
@property
|
|
def recovered(self):
|
|
warnings.warn("Deprecated since auto auto-eat! Will be removed soon. Use Energy.energy", DeprecationWarning)
|
|
return self.energy
|
|
|
|
@property
|
|
def recoverable(self):
|
|
warnings.warn("Deprecated since auto auto-eat! Will be removed soon. Use Energy.energy", DeprecationWarning)
|
|
return 0
|
|
|
|
def set_reference_time(self, recovery_time: datetime.datetime):
|
|
self._recovery_time = recovery_time.replace(microsecond=0)
|
|
|
|
@property
|
|
def food_fights(self):
|
|
return self.energy // 10
|
|
|
|
@property
|
|
def reference_time(self):
|
|
if self.is_energy_full or self._recovery_time < utils.now():
|
|
ret = utils.now()
|
|
else:
|
|
ret = self._recovery_time
|
|
return ret
|
|
|
|
@property
|
|
def is_recoverable_full(self):
|
|
warnings.warn(
|
|
"Deprecated since auto auto-eat! Will be removed soon. Use Energy.is_energy_full", DeprecationWarning
|
|
)
|
|
return self.is_energy_full
|
|
|
|
@property
|
|
def is_recovered_full(self):
|
|
warnings.warn(
|
|
"Deprecated since auto auto-eat! Will be removed soon. Use Energy.is_energy_full", DeprecationWarning
|
|
)
|
|
return self.is_energy_full
|
|
|
|
@property
|
|
def is_energy_full(self):
|
|
return self.energy >= self.limit - self.interval
|
|
|
|
@property
|
|
def available(self):
|
|
warnings.warn("Deprecated since auto auto-eat! Will be removed soon. Use Energy.energy", DeprecationWarning)
|
|
return self.energy
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[int, datetime.datetime, bool]]:
|
|
return dict(
|
|
limit=self.limit,
|
|
interval=self.interval,
|
|
energy=self.energy,
|
|
reference_time=self.reference_time,
|
|
food_fights=self.food_fights,
|
|
is_energy_full=self.is_energy_full,
|
|
)
|
|
|
|
|
|
class Details:
|
|
xp: int = 0
|
|
cc: float = 0
|
|
pp: int = 0
|
|
pin: str = None
|
|
gold: float = 0
|
|
level: int = 0
|
|
next_pp: List[int] = None
|
|
citizen_id: int = 0
|
|
citizenship: constants.Country
|
|
current_region: int = 0
|
|
current_country: constants.Country
|
|
residence_region: int = 0
|
|
residence_country: constants.Country
|
|
daily_task_done: bool = False
|
|
daily_task_reward: bool = False
|
|
mayhem_skills: Dict[int, int]
|
|
|
|
def __init__(self):
|
|
self.next_pp = []
|
|
self.mayhem_skills = {1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0, 7: 0, 8: 0, 9: 0, 10: 0, 11: 0, 12: 0, 13: 0, 14: 0}
|
|
_default_country = constants.Country(0, "Unknown", "Unknown", "XX")
|
|
self.citizenship = self.current_country = self.residence_country = _default_country
|
|
|
|
@property
|
|
def xp_till_level_up(self):
|
|
if self.xp >= 10000:
|
|
next_level_up = (1 + (self.xp // 5000)) * 5000
|
|
elif self.xp >= 7000:
|
|
next_level_up = 10000
|
|
elif self.xp >= 3000:
|
|
next_level_up = (1 + ((self.xp - 1000) // 2000)) * 2000 + 1000
|
|
elif self.xp >= 2000:
|
|
next_level_up = 3000
|
|
elif self.xp >= 450:
|
|
next_level_up = (1 + (self.xp // 500)) * 500
|
|
elif self.xp >= 370:
|
|
next_level_up = (1 + ((self.xp - 10) // 40)) * 40 + 10
|
|
elif self.xp >= 300:
|
|
next_level_up = (1 + ((self.xp - 20) // 35)) * 35 + 20
|
|
elif self.xp >= 150:
|
|
next_level_up = (1 + (self.xp // 30)) * 30
|
|
elif self.xp >= 50:
|
|
next_level_up = (1 + ((self.xp - 10) // 20)) * 20 + 10
|
|
elif self.xp >= 20:
|
|
next_level_up = (1 + ((self.xp - 5) // 15)) * 15 + 5
|
|
else:
|
|
next_level_up = (1 + (self.xp // 10)) * 10
|
|
return next_level_up - self.xp
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[int, float, str, constants.Country, bool]]:
|
|
return dict(
|
|
xp=self.xp,
|
|
cc=self.cc,
|
|
pp=self.pp,
|
|
pin=self.pin,
|
|
gold=self.gold,
|
|
next_pp=self.next_pp,
|
|
level=self.level,
|
|
citizen_id=self.citizen_id,
|
|
citizenship=self.citizenship,
|
|
current_region=self.current_region,
|
|
current_country=self.current_country,
|
|
residence_region=self.residence_region,
|
|
residence_country=self.residence_country,
|
|
daily_task_done=self.daily_task_done,
|
|
daily_task_reward=self.daily_task_reward,
|
|
mayhem_skills=self.mayhem_skills,
|
|
xp_till_level_up=self.xp_till_level_up,
|
|
)
|
|
|
|
@property
|
|
def is_elite(self):
|
|
return self.level > 100
|
|
|
|
|
|
class Politics:
|
|
is_party_member: bool = False
|
|
|
|
party_id: int = 0
|
|
party_slug: str = ""
|
|
is_party_president: bool = False
|
|
is_congressman: bool = False
|
|
is_country_president: bool = False
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[bool, int, str]]:
|
|
return dict(
|
|
is_party_member=self.is_party_member,
|
|
party_id=self.party_id,
|
|
party_slug=self.party_slug,
|
|
is_party_president=self.is_party_president,
|
|
is_congressman=self.is_congressman,
|
|
is_country_president=self.is_country_president,
|
|
)
|
|
|
|
|
|
class House:
|
|
quality = None
|
|
unactivated_count = 0
|
|
active_until = utils.good_timedelta(utils.now(), -datetime.timedelta(days=1))
|
|
|
|
def __init__(self, quality: int):
|
|
if 0 < quality < 6:
|
|
self.quality = quality
|
|
|
|
@property
|
|
def next_ot_point(self) -> datetime.datetime:
|
|
return self.active_until
|
|
|
|
|
|
class Reporter:
|
|
__to_update: List[Dict[Any, Any]] = None
|
|
key: str = ""
|
|
allowed: bool = False
|
|
|
|
@property
|
|
def name(self) -> str:
|
|
return self.citizen.name
|
|
|
|
@property
|
|
def email(self) -> str:
|
|
return self.citizen.config.email
|
|
|
|
@property
|
|
def citizen_id(self) -> int:
|
|
return self.citizen.details.citizen_id
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[bool, int, str, List[Dict[Any, Any]]]]:
|
|
return dict(
|
|
name=self.name,
|
|
email=self.email,
|
|
citizen_id=self.citizen_id,
|
|
key=self.key,
|
|
allowed=self.allowed,
|
|
queue=self.__to_update,
|
|
)
|
|
|
|
def __init__(self, citizen):
|
|
self._citizen = weakref.ref(citizen)
|
|
self._req = Session()
|
|
self.url = "https://erep.lv"
|
|
self._req.headers.update({"user-agent": "eRepublik Script Reporter v3", "erep-version": utils.__version__})
|
|
self.__to_update = []
|
|
self.__registered: bool = False
|
|
|
|
def do_init(self):
|
|
self.key: str = ""
|
|
self.__update_key()
|
|
self._req.headers.update({"erep-user-id": str(self.citizen_id), "erep-user-name": self.name})
|
|
self.register_account()
|
|
self.allowed = True
|
|
|
|
@property
|
|
def citizen(self):
|
|
return self._citizen()
|
|
|
|
def __update_key(self):
|
|
self.key = hashlib.md5(bytes(f"{self.name}:{self.email}", encoding="UTF-8")).hexdigest()
|
|
|
|
def __bot_update(self, data: dict) -> Response:
|
|
if self.__to_update:
|
|
for unreported_data in self.__to_update:
|
|
unreported_data.update(player_id=self.citizen_id, key=self.key)
|
|
unreported_data = utils.json_loads(utils.json_dumps(unreported_data))
|
|
r = self._req.post(f"{self.url}/bot/update", json=unreported_data)
|
|
r.raise_for_status()
|
|
self.__to_update.clear()
|
|
data = utils.json.loads(utils.json_dumps(data))
|
|
r = self._req.post(f"{self.url}/bot/update", json=data)
|
|
r.raise_for_status()
|
|
return r
|
|
|
|
def _bot_update(self, data: Dict[str, Any]) -> Optional[Response]:
|
|
if not self.__registered:
|
|
self.do_init()
|
|
if self.allowed:
|
|
try:
|
|
return self.__bot_update(data)
|
|
except HTTPError:
|
|
self.__to_update.append(data)
|
|
else:
|
|
self.__to_update.append(data)
|
|
|
|
def register_account(self):
|
|
if not self.__registered:
|
|
r = self.__bot_update(dict(key=self.key, check=True, player_id=self.citizen_id))
|
|
if r:
|
|
if not r.json().get("status"):
|
|
self._req.post(
|
|
f"{self.url}/bot/register",
|
|
json=dict(name=self.name, email=self.email, player_id=self.citizen_id),
|
|
)
|
|
self.__registered = True
|
|
self.allowed = True
|
|
self.report_action("STARTED", value=utils.now().strftime("%F %T"))
|
|
|
|
def send_state_update(
|
|
self,
|
|
xp: int,
|
|
cc: float,
|
|
gold: float,
|
|
inv_total: int,
|
|
inv: int,
|
|
hp_limit: int,
|
|
hp_interval: int,
|
|
hp_available: int,
|
|
food: int,
|
|
pp: int,
|
|
):
|
|
|
|
data = dict(
|
|
key=self.key,
|
|
player_id=self.citizen_id,
|
|
state=dict(
|
|
xp=xp,
|
|
cc=cc,
|
|
gold=gold,
|
|
inv_total=inv_total,
|
|
inv_free=inv_total - inv,
|
|
inv=inv,
|
|
food=food,
|
|
pp=pp,
|
|
hp_limit=hp_limit,
|
|
hp_interval=hp_interval,
|
|
hp_available=hp_available,
|
|
),
|
|
)
|
|
self._bot_update(data)
|
|
|
|
def report_action(self, action: str, json_val: Dict[Any, Any] = None, value: str = None):
|
|
json_data = dict(
|
|
player_id=getattr(self, "citizen_id", None), log={"action": action}, key=getattr(self, "key", None)
|
|
)
|
|
if json_val:
|
|
json_data["log"].update(dict(json=json_val))
|
|
if value:
|
|
json_data["log"].update(dict(value=value))
|
|
if not any([self.key, self.email, self.name, self.citizen_id]):
|
|
return
|
|
self._bot_update(json_data)
|
|
|
|
def report_fighting(self, battle: "Battle", invader: bool, division: "BattleDivision", damage: float, hits: int):
|
|
side = battle.invader if invader else battle.defender
|
|
self.report_action(
|
|
"FIGHT",
|
|
dict(
|
|
battle_id=battle.id,
|
|
side=side,
|
|
dmg=damage,
|
|
air=battle.has_air,
|
|
hits=hits,
|
|
round=battle.zone_id,
|
|
extra=dict(battle=battle, side=side, division=division),
|
|
),
|
|
)
|
|
|
|
def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
|
|
cur = "cc" if is_currency else "gold"
|
|
self.report_action(
|
|
"DONATE_MONEY",
|
|
dict(citizen_id=citizen_id, amount=amount, currency=cur),
|
|
f"Successfully donated {amount}{cur} to citizen with id {citizen_id}!",
|
|
)
|
|
|
|
def report_item_donation(self, citizen_id: int, amount: float, quality: int, industry: str):
|
|
self.report_action(
|
|
"DONATE_ITEMS",
|
|
dict(citizen_id=citizen_id, amount=amount, quality=quality, industry=industry),
|
|
f"Successfully donated {amount} x {industry} q{quality} to citizen with id {citizen_id}!",
|
|
)
|
|
|
|
def report_promo(self, kind: str, time_until: datetime.datetime):
|
|
self._req.post(f"{self.url}/promos/add/", data=dict(kind=kind, time_untill=time_until))
|
|
|
|
def fetch_battle_priorities(self, country: constants.Country) -> List["Battle"]:
|
|
try:
|
|
battle_response = self._req.get(f"{self.url}/api/v1/battles/{country.id}")
|
|
return [
|
|
self.citizen.all_battles[bid]
|
|
for bid in battle_response.json().get("battle_ids", [])
|
|
if bid in self.citizen.all_battles
|
|
]
|
|
except: # noqa
|
|
return []
|
|
|
|
def fetch_tasks(self) -> List[Dict[str, Any]]:
|
|
try:
|
|
task_response = self._req.post(
|
|
f"{self.url}/api/v1/command", data=dict(citizen=self.citizen_id, key=self.key)
|
|
).json()
|
|
if task_response.get("status"):
|
|
return task_response.get("data")
|
|
else:
|
|
return []
|
|
except: # noqa
|
|
return []
|
|
|
|
|
|
class BattleSide:
|
|
points: int
|
|
deployed: List[constants.Country]
|
|
allies: List[constants.Country]
|
|
battle: "Battle"
|
|
_battle: weakref.ReferenceType
|
|
country: constants.Country
|
|
is_defender: bool
|
|
|
|
def __init__(
|
|
self,
|
|
battle: "Battle",
|
|
country: constants.Country,
|
|
points: int,
|
|
allies: List[constants.Country],
|
|
deployed: List[constants.Country],
|
|
defender: bool,
|
|
):
|
|
self._battle = weakref.ref(battle)
|
|
self.country = country
|
|
self.points = points
|
|
self.allies = allies
|
|
self.deployed = deployed
|
|
self.is_defender = defender
|
|
|
|
@property
|
|
def id(self) -> int:
|
|
return self.country.id
|
|
|
|
def __repr__(self):
|
|
side_text = "Defender" if self.is_defender else "Invader "
|
|
return f"<BattleSide: {side_text} {self.country.name}|{self.points:>2d}p>"
|
|
|
|
def __str__(self):
|
|
side_text = "Defender" if self.is_defender else "Invader "
|
|
return f"{side_text} {self.country.name} - {self.points:>2d} points"
|
|
|
|
def __format__(self, format_spec):
|
|
return self.country.iso
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[int, constants.Country, bool, List[constants.Country]]]:
|
|
return dict(
|
|
points=self.points,
|
|
country=self.country,
|
|
is_defender=self.is_defender,
|
|
allies=self.allies,
|
|
deployed=self.deployed,
|
|
)
|
|
|
|
@property
|
|
def battle(self):
|
|
return self._battle()
|
|
|
|
|
|
class BattleDivision:
|
|
id: int
|
|
end: datetime.datetime
|
|
epic: bool
|
|
dom_pts: Dict[str, int]
|
|
wall: Dict[str, Union[int, float]]
|
|
def_medal: Dict[str, int]
|
|
inv_medal: Dict[str, int]
|
|
terrain: int
|
|
div: int
|
|
battle: "Battle"
|
|
_battle: weakref.ReferenceType
|
|
|
|
@property
|
|
def as_dict(self):
|
|
return dict(
|
|
id=self.id,
|
|
division=self.div,
|
|
terrain=(self.terrain, self.terrain_display),
|
|
wall=self.wall,
|
|
epic=self.epic,
|
|
end=self.div_end,
|
|
)
|
|
|
|
@property
|
|
def is_air(self):
|
|
return self.div == 11
|
|
|
|
@property
|
|
def div_end(self) -> bool:
|
|
return utils.now() >= self.end
|
|
|
|
def __init__(
|
|
self,
|
|
battle: "Battle",
|
|
div_id: int,
|
|
end: datetime.datetime,
|
|
epic: bool,
|
|
div: int,
|
|
wall_for: int,
|
|
wall_dom: float,
|
|
terrain_id: int = 0,
|
|
):
|
|
"""Battle division helper class
|
|
|
|
:type div_id: int
|
|
:type end: datetime.datetime
|
|
:type epic: bool
|
|
:type div: int
|
|
:type terrain_id: int
|
|
:type wall_for: int
|
|
:type wall_dom: float
|
|
"""
|
|
self._battle = weakref.ref(battle)
|
|
self.id = div_id
|
|
self.end = end
|
|
self.epic = epic
|
|
self.wall = {"for": wall_for, "dom": wall_dom}
|
|
self.terrain = terrain_id
|
|
self.div = div
|
|
|
|
@property
|
|
def terrain_display(self):
|
|
return constants.TERRAINS[self.terrain]
|
|
|
|
def __str__(self):
|
|
base_name = f"D{self.div} #{self.id}"
|
|
if self.terrain:
|
|
base_name += f" ({self.terrain_display})"
|
|
if self.div_end:
|
|
base_name += " Ended"
|
|
return base_name
|
|
|
|
def __repr__(self):
|
|
return f"<BattleDivision #{self.id} (battle #{self.battle.id})>"
|
|
|
|
@property
|
|
def battle(self):
|
|
return self._battle()
|
|
|
|
|
|
class Battle:
|
|
id: int
|
|
war_id: int
|
|
zone_id: int
|
|
is_rw: bool
|
|
is_dict_lib: bool
|
|
start: datetime.datetime
|
|
invader: BattleSide
|
|
defender: BattleSide
|
|
div: Dict[int, BattleDivision]
|
|
region_id: int
|
|
region_name: str
|
|
|
|
@property
|
|
def as_dict(self):
|
|
return dict(
|
|
id=self.id,
|
|
war_id=self.war_id,
|
|
divisions=self.div,
|
|
zone=self.zone_id,
|
|
rw=self.is_rw,
|
|
dict_lib=self.is_dict_lib,
|
|
start=self.start,
|
|
sides={"inv": self.invader, "def": self.defender},
|
|
region=[self.region_id, self.region_name],
|
|
link=self.link,
|
|
)
|
|
|
|
@property
|
|
def has_air(self) -> bool:
|
|
for div in self.div.values():
|
|
if div.div == 11:
|
|
return True
|
|
return not bool(self.zone_id % 4)
|
|
|
|
@property
|
|
def has_started(self) -> bool:
|
|
return self.start <= utils.now()
|
|
|
|
@property
|
|
def has_ground(self) -> bool:
|
|
for div in self.div.values():
|
|
if div.div != 11:
|
|
return True
|
|
return bool(self.zone_id % 4)
|
|
|
|
@property
|
|
def link(self):
|
|
return f"https://www.erepublik.com/en/military/battlefield/{self.id}"
|
|
|
|
def __init__(self, battle: Dict[str, Any]):
|
|
"""Object representing eRepublik battle.
|
|
|
|
:param battle: Dict object for single battle from '/military/campaignsJson/list' response's 'battles' object
|
|
"""
|
|
|
|
self.id = int(battle.get("id"))
|
|
self.war_id = int(battle.get("war_id"))
|
|
self.zone_id = int(battle.get("zone_id"))
|
|
self.is_rw = bool(battle.get("is_rw"))
|
|
self.is_as = bool(battle.get("is_as"))
|
|
self.is_dict_lib = bool(battle.get("is_dict")) or bool(battle.get("is_lib"))
|
|
self.region_id = battle.get("region", {}).get("id")
|
|
self.region_name = battle.get("region", {}).get("name")
|
|
self.start = datetime.datetime.fromtimestamp(int(battle.get("start", 0)), tz=constants.erep_tz)
|
|
|
|
self.invader = BattleSide(
|
|
self,
|
|
constants.COUNTRIES[battle.get("inv", {}).get("id")],
|
|
battle.get("inv", {}).get("points"),
|
|
[constants.COUNTRIES[row.get("id")] for row in battle.get("inv", {}).get("ally_list")],
|
|
[constants.COUNTRIES[row.get("id")] for row in battle.get("inv", {}).get("ally_list") if row["deployed"]],
|
|
False,
|
|
)
|
|
|
|
self.defender = BattleSide(
|
|
self,
|
|
constants.COUNTRIES[battle.get("def", {}).get("id")],
|
|
battle.get("def", {}).get("points"),
|
|
[constants.COUNTRIES[row.get("id")] for row in battle.get("def", {}).get("ally_list")],
|
|
[constants.COUNTRIES[row.get("id")] for row in battle.get("def", {}).get("ally_list") if row["deployed"]],
|
|
True,
|
|
)
|
|
|
|
self.div = {}
|
|
for div, data in battle.get("div", {}).items():
|
|
div = int(div)
|
|
if data.get("end"):
|
|
end = datetime.datetime.fromtimestamp(data.get("end"), tz=constants.erep_tz)
|
|
else:
|
|
end = constants.max_datetime
|
|
|
|
battle_div = BattleDivision(
|
|
self,
|
|
div_id=data.get("id"),
|
|
div=data.get("div"),
|
|
end=end,
|
|
epic=data.get("epic_type") in [1, 5],
|
|
wall_for=data.get("wall").get("for"),
|
|
wall_dom=data.get("wall").get("dom"),
|
|
terrain_id=data.get("terrain", 0),
|
|
)
|
|
|
|
self.div.update({div: battle_div})
|
|
|
|
def __str__(self):
|
|
time_now = utils.now()
|
|
is_started = self.start < utils.now()
|
|
if is_started:
|
|
time_part = f" {time_now - self.start}"
|
|
else:
|
|
time_part = f"-{self.start - time_now}"
|
|
|
|
return (
|
|
f"Battle {self.id} for {self.region_name[:16]:16} | "
|
|
f"{self.invader} : {self.defender} | Round time {time_part} | {'R'+str(self.zone_id):>3}"
|
|
)
|
|
|
|
def __repr__(self):
|
|
return f"<Battle #{self.id} {self.invader}:{self.defender} R{self.zone_id}>"
|
|
|
|
|
|
class EnergyToFight:
|
|
energy: int = 0
|
|
|
|
def __init__(self, energy: int = 0):
|
|
self.energy = energy
|
|
|
|
def __int__(self):
|
|
return self.energy
|
|
|
|
def __str__(self):
|
|
return str(self.energy)
|
|
|
|
def __repr__(self):
|
|
return str(self.energy)
|
|
|
|
@property
|
|
def i(self):
|
|
return self.__int__()
|
|
|
|
@property
|
|
def s(self):
|
|
return self.__str__()
|
|
|
|
def check(self, new_energy: int):
|
|
if not isinstance(new_energy, (tuple, int)):
|
|
return self.energy
|
|
if 0 < new_energy < self.energy:
|
|
self.energy = new_energy
|
|
return self.energy
|
|
|
|
|
|
class TelegramReporter:
|
|
__initialized: bool = False
|
|
__queue: List[str]
|
|
chat_id: int = 0
|
|
api_url: str = ""
|
|
player_name: str = ""
|
|
__thread_stopper: threading.Event
|
|
_last_time: datetime.datetime
|
|
_last_full_energy_report: datetime.datetime
|
|
_next_time: datetime.datetime
|
|
_threads: List[threading.Thread]
|
|
|
|
def __init__(self, stop_event: threading.Event = None):
|
|
self._threads = []
|
|
self.__queue = []
|
|
self.__thread_stopper = threading.Event() if stop_event is None else stop_event
|
|
self._last_full_energy_report = self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(hours=1))
|
|
self._next_time = utils.now()
|
|
|
|
@property
|
|
def as_dict(self):
|
|
return {
|
|
"chat_id": self.chat_id,
|
|
"api_url": self.api_url,
|
|
"player": self.player_name,
|
|
"last_time": self._last_time,
|
|
"next_time": self._next_time,
|
|
"queue": self.__queue,
|
|
"initialized": self.__initialized,
|
|
"has_threads": not self._threads,
|
|
}
|
|
|
|
def do_init(self, chat_id: int, token: str = None, player_name: str = None):
|
|
if token is None:
|
|
token = "864251270:AAFzZZdjspI-kIgJVk4gF3TViGFoHnf8H4o"
|
|
self.chat_id = chat_id
|
|
self.api_url = f"https://api.telegram.org/bot{token}"
|
|
self.player_name = player_name or ""
|
|
self.__initialized = True
|
|
self._last_time = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-5))
|
|
self._last_full_energy_report = utils.good_timedelta(utils.now(), datetime.timedelta(minutes=-30))
|
|
if self.__queue:
|
|
self.send_message("Telegram initialized")
|
|
|
|
def send_message(self, message: str) -> bool:
|
|
self.__queue.append(message)
|
|
if not self.__initialized:
|
|
if self._last_time < utils.now():
|
|
self.__queue.clear()
|
|
return True
|
|
self._threads = [t for t in self._threads if t.is_alive()]
|
|
self._next_time = utils.good_timedelta(utils.now(), datetime.timedelta(seconds=20))
|
|
if not self._threads:
|
|
name = f"telegram_{f'{self.player_name}_' if self.player_name else ''}send"
|
|
send_thread = threading.Thread(target=self.__send_messages, name=name)
|
|
send_thread.start()
|
|
self._threads.append(send_thread)
|
|
|
|
return True
|
|
|
|
def report_full_energy(self, available: int, limit: int, interval: int):
|
|
if (utils.now() - self._last_full_energy_report).total_seconds() >= 30 * 60:
|
|
self._last_full_energy_report = utils.now()
|
|
message = f"Full energy ({available}hp/{limit}hp +{interval}hp/6min)"
|
|
self.send_message(message)
|
|
|
|
def report_medal(self, msg, multiple: bool = True):
|
|
new_line = "\n" if multiple else ""
|
|
self.send_message(f"New award: {new_line}*{msg}*")
|
|
|
|
def report_fight(self, battle: "Battle", invader: bool, division: "BattleDivision", damage: float, hits: int):
|
|
side_txt = (battle.invader if invader else battle.defender).country.iso
|
|
self.send_message(
|
|
f"*Fight report*:\n{int(damage):,d} dmg ({hits} hits) in"
|
|
f" [battle {battle.id} for {battle.region_name[:16]}]({battle.link}) in d{division.div} on "
|
|
f"{side_txt} side"
|
|
)
|
|
|
|
def report_item_donation(self, citizen_id: int, amount: float, product: str):
|
|
self.send_message(
|
|
f"*Donation*: {amount} x {product} to citizen "
|
|
f"[{citizen_id}](https://www.erepublik.com/en/citizen/profile/{citizen_id})"
|
|
)
|
|
|
|
def report_money_donation(self, citizen_id: int, amount: float, is_currency: bool = True):
|
|
self.send_message(
|
|
f"*Donation*: {amount}{'cc' if is_currency else 'gold'} to citizen "
|
|
f"[{citizen_id}](https://www.erepublik.com/en/citizen/profile/{citizen_id})"
|
|
)
|
|
|
|
def __send_messages(self):
|
|
while self._next_time > utils.now():
|
|
if self.__thread_stopper.is_set():
|
|
break
|
|
self.__thread_stopper.wait(utils.get_sleep_seconds(self._next_time))
|
|
|
|
message = "\n\n".join(self.__queue)
|
|
if self.player_name:
|
|
message = f"Player *{self.player_name}*\n\n" + message
|
|
response = post(
|
|
f"{self.api_url}/sendMessage", json=dict(chat_id=self.chat_id, text=message, parse_mode="Markdown")
|
|
)
|
|
self._last_time = utils.now()
|
|
if response.json().get("ok"):
|
|
self.__queue.clear()
|
|
return True
|
|
return False
|
|
|
|
def send_photos(self, photos: List[Tuple[str, BytesIO]]):
|
|
for photo_title, photo in photos:
|
|
photo.seek(0)
|
|
post(
|
|
f"https://{self.api_url}/sendPhoto",
|
|
data=dict(chat_id=self.chat_id, caption=photo_title),
|
|
files=[("photo", ("f{utils.slugify(photo_title)}.png", photo))],
|
|
)
|
|
return
|
|
|
|
|
|
class OfferItem(NamedTuple):
|
|
price: float = 999_999_999.0
|
|
country: constants.Country = constants.Country(0, "", "", "")
|
|
amount: int = 0
|
|
offer_id: int = 0
|
|
citizen_id: int = 0
|
|
|
|
|
|
class Inventory:
|
|
final: types.InvFinal
|
|
active: types.InvFinal
|
|
boosters: types.InvBooster
|
|
raw: types.InvRaw
|
|
market: types.InvRaw
|
|
used: int
|
|
total: int
|
|
|
|
def __init__(self):
|
|
self.active = {}
|
|
self.final = {}
|
|
self.boosters = {}
|
|
self.raw = {}
|
|
self.offers = {}
|
|
self.used = 0
|
|
self.total = 0
|
|
|
|
@property
|
|
def as_dict(self) -> Dict[str, Union[types.InvFinal, types.InvRaw, int]]:
|
|
return dict(
|
|
active=self.active,
|
|
final=self.final,
|
|
boosters=self.boosters,
|
|
raw=self.raw,
|
|
offers=self.offers,
|
|
total=self.total,
|
|
used=self.used,
|
|
)
|