from typing import Dict, List
from vbet.game.accounts import RecoverAccount
from vbet.game.tickets import Bet, Event, Ticket
from vbet.utils.log import get_logger
from .base import Player
NAME = 'rooney'
logger = get_logger(NAME)
class CustomPlayer(Player):
def __init__(self, competition):
super(CustomPlayer, self).__init__(competition, NAME)
self.account = RecoverAccount(self.competition.user.account_manager)
self.account._initial_token = 5
self.team = None
self.event_id = None
self.event_data = {}
self.odd_id = 0
self.min_week = 3
self.bet_flag = False
self.reset_flag = True
self.shutdown_event.set()
async def forecast(self):
table = self.competition.table.table # type: List[Dict]
league_games = self.competition.league_games # type: Dict[int, Dict]
if self.competition.week == 3:
self.team = table[-1].get('team')
import asyncio
import socket
import time
from typing import Dict, Optional, TYPE_CHECKING
import aiohttp
import websockets
from vbet.game.api.auth import login_hash, WSS_URL
from vbet.utils.log import get_logger
from vbet.utils.parser import decode_json, encode_json, inspect_websocket_response, Resource
if TYPE_CHECKING:
from vbet.game.user import User
logger = get_logger('socket')
COMPETITION_SOCKET = 0
TICKET_SOCKET = 1
class Socket:
HASH = 0
CONNECTING = 1
CONNECTED = 2
NOT_AUTHORIZED = 3
CLOSED = 4
READY = 5
CLOSE_TIMEOUT = 40
LOGIN_CLOSE_TIMEOUT = 10
import asyncio
from typing import Dict, Optional
import aiohttp
import vbet
from vbet.core import settings
from vbet.utils.exceptions import InvalidUserAuthentication, InvalidUserHash
from vbet.utils.log import get_logger
logger = get_logger('auth')
HEADERS = {f'User-Agent': f'[vbet : {vbet.__VERSION__}]'}
WSS_URL = 'wss://virtual-proxy.golden-race.net:9443/vs'
if settings.API_NAME == settings.BETIKA:
HASH_URL = 'https://api-golden-race.betika.com/betikagr/Login'
LOGIN_URL = 'https://api.betika.com/v1/login'
COOKIES_URL = 'https://api.betika.com'
async def login_hash(username: str, user_id: int, socket_id: int,
http: aiohttp.ClientSession):
pin_hash: Optional[str] = None
while pin_hash is None:
try:
response = await http.post(HASH_URL,
json={'profile_id': user_id}
) # type: aiohttp.ClientResponse
data = await response.json(content_type="text/json"
) # type: Dict
if response.status == 200:
import aiohttp
import aioredis
from vbet.core import settings
from vbet.game.api.auth import COOKIES_URL, HEADERS, login_password
from vbet.game.user import User
from vbet.utils import exceptions
from vbet.utils.log import get_logger
from vbet.utils.parser import decode_json, encode_json
if TYPE_CHECKING:
from vbet.core.vbet import Vbet
logger = get_logger('user_manager')
class UserManager:
users: Dict[str, User] = {}
validating_users: Dict[str, Dict] = {}
login_users: Dict[str, Dict] = {}
ws_queue: asyncio.Queue = asyncio.Queue()
ws_reader_future: Optional[asyncio.Future] = None
redis: Optional[aioredis.ConnectionsPool] = None
app: Vbet
def __init__(self, app: Vbet):
self.app = app
async def setup(self):
from __future__ import annotations
import asyncio
import time
from operator import attrgetter
from typing import Any, Dict, List, Optional, Tuple, TYPE_CHECKING
from vbet.game.socket import Socket, TICKET_SOCKET
from vbet.utils.log import get_logger
from vbet.utils.parser import Resource
if TYPE_CHECKING:
from vbet.game.user import User
logger = get_logger('ticket-manager')
class Bet:
def __init__(self, odd_id: int, market_id: str, odd_value: float,
odd_name: str, stake: float):
self.odd_id: int = odd_id
self.market_id: str = market_id
self.odd_value: float = odd_value
self.odd_name: str = odd_name
self.stake: Optional[float] = stake
self.profit_type: str = "NONE"
self.status: str = 'OPEN'
def __str__(self):
return "OddId: {} MarketId: {} OddName: {} OddValue: {} Stake {}".format(
self.odd_id, self.market_id, self.odd_name, self.odd_value,
from __future__ import annotations
import asyncio
from typing import Any, List, Optional, Tuple, TYPE_CHECKING
from vbet.game.accounts import Account
from vbet.game.markets import Markets
from vbet.game.tickets import Ticket
from vbet.utils.log import get_logger
if TYPE_CHECKING:
from vbet.game.competition import LeagueCompetition
NAME = 'player'
logger = get_logger('player')
class Player:
def __init__(self, competition: LeagueCompetition, name: str = None):
self.competition: LeagueCompetition = competition
self.min_week: int = 1
self.league: Optional[int] = None
self.current_league_complete: bool = False
self._active: bool = False
self.closing: bool = False
self.name: str = name if name else NAME
self.bet_ready: bool = False
self.jackpot_ready: bool = False
self._bet: bool = False
self._forecast: bool = True
import asyncio
import signal
from typing import Optional
import vbet
from vbet.core import settings
from vbet.core.user_manager import UserManager
from vbet.core.ws_server import WsServer
from vbet.utils import exceptions
from vbet.utils.log import get_logger
logger = get_logger('vbet')
STARTING = 0
CLOSING = 1
LIVE = 100
EXIT_SUCCESS = 100
EXIT_INTERRUPT = 101
def setup_signal_handlers():
signal.signal(signal.SIGTERM, sig_term)
def sig_term(sig: int, frame):
logger.info('SIG_TERM terminating server')
raise KeyboardInterrupt
class Vbet:
from __future__ import annotations
from typing import Dict, Optional, TYPE_CHECKING, Union
import websockets
from vbet.core import settings
from vbet.core.session import Session
from vbet.utils.log import get_logger
if TYPE_CHECKING:
from vbet.core.vbet import Vbet
logger = get_logger('ws_server')
class WsServer:
ws_server: Optional[websockets.WebSocketServer] = None
sessions: Dict[int, Session] = {}
session_index: int = 0
app: Vbet
def __init__(self, app: Vbet):
self.app = app
async def setup(self):
logger.info(
f'Starting the websocket server [{websockets.__version__}] url=ws://{settings.WS_HOST}:'
f'{settings.WS_PORT}')
self.ws_server = await websockets.serve(self.handle, settings.WS_HOST,
settings.WS_PORT)
from __future__ import annotations
import asyncio
from typing import Any, Callable, Coroutine, Dict, Optional, TYPE_CHECKING, Union
import websockets
from vbet.utils.log import get_logger
from vbet.utils.parser import decode_json, encode_json, inspect_ws_server_payload
if TYPE_CHECKING:
from vbet.core.ws_server import WsServer
logger = get_logger('session')
SUDO_URI = {
'exit': 'application',
'add': 'manager',
'login': '******',
'check': 'manager'
}
CLIENT_URI = {'player': 'manager'}
class Session:
def __init__(self, ws_server: WsServer, session_key: int, sudo=True):
self.sudo: bool = sudo
self.session_key: int = session_key
self.ws_server: WsServer = ws_server
self.websocket: Optional[websockets.WebSocketServerProtocol] = None
import aiofile
import aiohttp
from vbet.core import settings
from vbet.game.socket import Socket
from vbet.utils.log import get_logger
from vbet.utils.parser import decode_json, encode_json, get_ticket_timestamp, Resource
from .accounts import AccountManager
from .competition import LeagueCompetition
from .tickets import Ticket, TicketManager
if TYPE_CHECKING:
from vbet.core.user_manager import UserManager
logger = get_logger('user')
class GameSettings:
def __init__(self):
self._odd_settings_id: int = 0
self._playlists: Dict[int, Dict] = {}
self._taxes_settings: Dict = {}
self._game_settings: Dict = {}
self._unit_id: Optional[int] = None
self._ext_id = None
self._ext_data = None
self._player_name: Optional[str] = None
self._currency: Dict = {}
self.configured: bool = False
