def main():
user = "******"
pwd = "ca$hc0w"
dataCenter = None
try:
opts, args = getopt.getopt(sys.argv[1:], "d:u:p:")
except getopt.GetoptError:
Usage("Unknown arguments")
if len(args) == 0:
Usage("Host not specified")
host = args[0]
for a, v in opts:
if a == "-d":
dataCenter = v
if a == "-u":
user = v
if a == "-p":
pwd = v
si = connect.Connect(user=user, pwd=pwd)
atexit.register(connect.Disconnect, si)
dataCenterName = dataCenter is None and "pyDatacenter" or dataCenter
if invt.GetDatacenter(dataCenter) is None:
# No datacenter is specified, or the datacenter specified does not exist.
print("Creating a new datacenter " + dataCenterName)
vc.CreateDatacenter(dataCenterName)
print("Adding host " + host + "...", end='')
vc.AddHost(host=host, dataCenter=dataCenterName)
print("Done!")
def _get_server(self, method, data):
''' Retrieve the Emby server.
'''
try:
if not data.get('ServerId'):
raise Exception("ServerId undefined.")
if method != 'LoadServer' and data['ServerId'] not in self.servers:
try:
connect.Connect().register(data['ServerId'])
self.server_instance(data['ServerId'])
except Exception as error:
LOG.error(error)
dialog("ok", heading="{emby}", line1=_(33142))
return
server = Emby(data['ServerId']).get_client()
except Exception:
server = Emby().get_client()
return server
def receive(link, limit):
client = connect.Connect()
entity = client.get_entity(link)
posts = client(
GetHistoryRequest(peer=entity,
limit=limit,
offset_date=None,
offset_id=0,
max_id=0,
min_id=0,
add_offset=0,
hash=0))
index = 0
for i in posts.messages:
with open('GetMsg.md', 'a', encoding="utf-8", errors='ignore') as f:
f.write("\n")
f.flush()
count = str(index + 1)
f.write(count)
f.write(" ")
print(i.message)
f.write(str(i.message))
# f.write("\n")
index += 1
connect.disConnect(client)
def service(self):
''' Keeps the service monitor going.
Exit on Kodi shutdown or profile switch.
if profile switch happens more than once,
Threads depending on abortRequest will not trigger.
'''
self.monitor = objects.monitor.Monitor()
self.monitor.service = self
self.connect = connect.Connect()
self.player = self['monitor'].player
self._server()
while self.running:
if window('emby_online.bool'):
if self['profile'] != window('emby_kodiProfile'):
LOG.info("[ profile switch ] %s", self['profile'])
break
if self['player'].isPlaying(
) and self['player'].is_playing_file(
self['player'].get_playing_file()):
difference = datetime.today() - self['last_progress']
if difference.seconds > 4:
self['last_progress'] = datetime.today()
update = (datetime.today() -
self['last_progress_report']).seconds > 40
event('ReportProgressRequested', {'Report': update})
if update:
self['last_progress_report'] = datetime.today()
if not WEBSERVICE.is_alive():
LOG.info("[ restarting due to socket disconnect ]")
window('emby.restart.bool', True)
if window('emby.restart.bool'):
dialog("notification",
heading="{emby}",
message=_(33193),
icon="{emby}",
time=1000,
sound=False)
raise Exception('RestartService')
if self.waitForAbort(1):
break
self.shutdown()
raise Exception("ExitService")
def service(self):
''' Keeps the service monitor going.
Exit on Kodi shutdown or profile switch.
if profile switch happens more than once,
Threads depending on abortRequest will not trigger.
'''
self.monitor = monitor.Monitor()
player = self.monitor.player
self.connect = connect.Connect()
self.start_default()
self.settings['mode'] = settings('useDirectPaths')
while self.running:
if window('jellyfin_online.bool'):
if self.settings['profile'] != window('jellyfin_kodiProfile'):
LOG.info("[ profile switch ] %s", self.settings['profile'])
break
if player.isPlaying() and player.is_playing_file(
player.get_playing_file()):
difference = datetime.today(
) - self.settings['last_progress']
if difference.seconds > 10:
self.settings['last_progress'] = datetime.today()
update = (datetime.today() -
self.settings['last_progress_report']
).seconds > 250
event('ReportProgressRequested', {'Report': update})
if update:
self.settings[
'last_progress_report'] = datetime.today()
if window('jellyfin.restart.bool'):
window('jellyfin.restart', clear=True)
dialog("notification",
heading="{jellyfin}",
message=translate(33193),
icon="{jellyfin}",
time=1000,
sound=False)
raise Exception('RestartService')
if self.waitForAbort(1):
break
self.shutdown()
raise Exception("ExitService")
def test_insertdb(self):
obj = connect.Connect()
c, conn = obj.connection()
with open("../dept_emp.txt", 'r') as a:
b = a.read()
obj1 = dbpython.Db()
d = obj1.mycode(c)
self.assertEqual(d, b)
def get_trailer_url(self):
# set the video key in youtube by API database
youtube_string = "https://www.youtube.com/watch?v="
query_string = "/3/movie/" + \
str(self.id) + "/videos?language=en-US&api_key="
video_results = connect.Connect("GET", query_string, 'results')
for x in video_results.decoded_list:
self.trailer_youtube_url = youtube_string + x["key"]
# Ending loop before continue because we need only one URL
break
def updateError(self,massageid):
try:
massageDb = connect.Connect()
db = massageDb.getConn()
curser = db.cursor()
sql = "UPDATE massage SET massage.type = 3 WHERE massage.massageid = "+massageid
curser.execute(sql)
db.commit()
# print(sql)
except Exception as ex:
print(ex)
def _init_main(self, user: str, password: str):
self.ui.form.show()
self.connection = connect.Connect(self.HOSTNAME, user, password)
try:
self.connection.get_token()
except connect.requests.ConnectionError:
self.error('Не удалось подключиться к серверу')
self.update_threads()
# Цикл обновления
self.timer = main_ui.QtCore.QTimer(self.ui.form)
self.timer.start(1000)
self.timer.timeout.connect(self.update_loop)
def gettoken(self, email):
connectDb = connect.Connect()
db = connectDb.getConn()
curser = db.cursor()
try:
sql = "SELECT channel_access_token FROM line WHERE email = '" + email + "'"
curser.execute(sql)
result = curser.fetchall()
# print(result[0][0])
return result[0][0]
except Exception as ex:
print(ex)
return None
def resetpassword(self, email, newpassword):
try:
userDb = connect.Connect()
db = userDb.getConn()
curser = db.cursor()
query = "UPDATE user SET password = '******' WHERE email = '" + str(email) + "'"
# print(query)
curser.execute(query)
db.commit()
return True
except Exception as ex:
return str(ex)
def mycode(self, cb):
str1 = ""
x = connect.Connect()
c, conn = x.connection()
c = cb
try:
cb.execute('SELECT * FROM dept_emp')
for row in cb:
p = ','.join(row)
str1 = str1 + p + '\n'
l = log_file.Log()
l.logging.info("Data selected from the Table")
return (str1)
except Exception as e:
print("Error:", e)
return False
def sign_in_up(self):
"""Функция для регистрации или входа"""
login = self.login_ui.login_login.text()
password = self.login_ui.login_pass.text()
self.connection = connect.Connect(self.HOSTNAME, login, password)
if not self.HOSTNAME:
self.error('Настройте адрес сервера')
return
try:
if self.login_ui.form.sender().objectName() == 'login_btn':
self.connection.get_token()
else:
self.connection.register()
except connect.requests.ConnectionError or connect.requests.exceptions.MissingSchema as e:
self.error('Ошибка', e.__str__())
return
self._login(password, login)
def showMassageDontSent(self):
try:
massageDb = connect.Connect()
db = massageDb.getConn()
curser = db.cursor()
# curser.execute("SELECT massageid,email, REPLACE(massage,'\\n','s'),datein,typemassage,type,timeline,target,recipient,dateout FROM `massage` WHERE massage.type = 1 ORDER BY `massage`.`datein` DESC")
curser.execute("SELECT * FROM `massage` WHERE massage.type = 1 ORDER BY `massage`.`datein` DESC")
result = curser.fetchall()
colum = len(result[0])
# print("colum ==", colum)
# print("row == ", curser.rowcount)
# for row in result:
# for c in range(0,colum):
# print("massage : ",row[2])
if result != None:
return result
else:
return None
except Exception as ex:
# print(ex)
return None
def play():
cols = 5
rows = 3
n = 3
print(f"Let's play connect {n}!")
game = connect.Connect(num_cols=cols,
num_rows=rows,
num_connect=n,
verbose=False)
again = True
while again:
response = yes_no_input("Would you like to play first?")
if response:
run_game(game=game, player1=HumanAgent(), player2=ConnectAgent())
else:
run_game(game=game, player1=ConnectAgent(), player2=HumanAgent())
again = yes_no_input("Would you like to play again?")
if again:
game.reset()
def playGames(QTable, m):
env = connect.Connect(verbose=False)
gamesWon = 0
for i in range(m):
env.reset(first_player='x')
while True:
env.act(action=opponentMove(env))
if env.was_winning_move() or env.grid_is_full():
break
env.change_turn()
env.act(action=agentMove(env, QTable))
if env.was_winning_move():
gamesWon += 1
break
elif env.grid_is_full():
break
else:
env.change_turn()
return gamesWon / m
def client_only():
loop.create_task(wrapper_wait_for_fetch_ip(SSIDpass))
def peer_to_peer():
loop.create_task(wait_for_run_server_socket(15))
loop.create_task(wrapper_wait_for_fetch_ip(SSIDpass))
if __name__ == '__main__':
#instance loop
loop = asyncio.get_event_loop()
#instanse class Connect
Connect = connect.Connect()
#instanse class ServSocket
ServSocket = run_socket.serverSocketClass()
#instanse class Cl_Socket
Cl_Socket = client_socket.clientSocketClass()
#instanse class voltageWriter
V_Writer = vol_writer.voltageWriter()
#instanse class ctl_Relay
Ctl_Relay = ctl_Relay.control_Relay()
#instance class SSIDpass
SSIDpass = extract_credential.SSIDpass()
def ConUi(self): # Открытие окна настроек
self.conwin = conctwin.Connect() # Окно соеденения
self.conwin.show()
#!usr/bin/env python
import connect
# 获取配置
config = connect.Config('../config.ini').getConfig();
mysql_config = config['mysql'];
# 连接数据库
con = connect.Connect(mysql_config['db_host'],mysql_config['db_port'],mysql_config['db_table'],mysql_config['db_user'],mysql_config['db_pwd']);
con.run()
# con.cursor()con
# print(con.execute('SELECT * FROM users'))
import numpy as np
import random
import connect
import math
env = connect.Connect(verbose=False)
Q = {}
setup_game()
print(Q)
Epsilon = 0.5
Alpha = 0.5
def setup_game():
env.reset(first_player='o')
env.act(action=2)
start_grid = np.array_str(env.grid)
for i in range(0, 5):
Q[(start_grid, i)] = 0
def make_random_move(state):
possible_moves = env.available_actions
return random.choice(possible_moves)
def make_q_move(state):
possible_moves = env.available_actions
act = get_best_action(state, possible_moves)
env.act(action=act)
if (not check_win(state)):
import connect
env = connect.Connect(verbose=True)
env.reset(first_player='o')
# Player 'o' plays
print("Current player at turn:", env.player_at_turn)
env.act(action=2)
# Player 'x' plays
env.change_turn()
print("Current player at turn:", env.player_at_turn)
env.act(action=2)
# Player 'o' plays
env.change_turn()
print("Current player at turn:", env.player_at_turn)
env.act(action=2)
# Print grid
print("Printing grid")
current_grid = env.grid
print(current_grid)
# Print available actions
print("Available actions:")
print(env.available_actions)
# Was last game move a win?
print("Winning move?", env.was_winning_move())
# Make some moves
default=True,
help="rotate sent image",
type=str2bool)
ap.add_argument("-c",
"--cam",
required=False,
default=0,
type=int,
help="Enter camera to be used")
args = vars(ap.parse_args())
ROTATE_IMAGE = args["rotate"]
TEST_BOOL = args["test"]
READING_SERIAL = args["read_serial"]
connect = conn.Connect()
if READING_SERIAL:
rs = readserial.ReadSerial()
STREAM = 0
notification_push = False
SECRET = ".YSWORD-DROWSY"
manager = Manager()
trip_data = manager.dict()
TRACKER_ID = "TLO12017000971" # TER'S TRACKER
if TEST_BOOL:
TRACKER_ID = "60000003"
print(f"TRACKER ID: {TRACKER_ID}")
IS_AUTH = False
ear = 0
CO = 0
LPG = 0
import connect
import time
from multiprocessing import Process
import os
name = 'room'
address = ('lancatserver.ddns.net', 8122)
'''
server = Process(target = os.system, args = ('nodejs app.js',))
server.start()
server.join(1)
'''
c1 = connect.Connect(address)
print(c1.search(name))
result = c1.create(name, ('server', 8877), lambda data: print(data))
print(result)
c2 = connect.Connect(address)
print(c2.search(name))
print(c2.join(name, ('client', 1234)))
time.sleep(1)
c1.close()
time.sleep(5)
print(c2.search(name))
c2.close()
#server.terminate()
def __init__(self):
self.game=connect.Connect(verbose=False)
self.game.reset(first_player='o')
if action_value >= beta:
return action_value
else:
beta = min(beta, action_value)
if action_value <= alpha:
return action_value
if maxPlayer:
best_value = max(action_value, best_value)
else:
best_value = min(action_value, best_value)
return best_value
connect = connect.Connect(num_cols=5)
humanAgent = HumanAgent()
connectAgent = ConnectAgent()
game_over = False
while not game_over:
move = humanAgent.next_move(connect)
reward, game_over = connect.act(action=move)
if game_over and reward == 1:
print("Player one wins!")
break
elif game_over and reward == -1:
print("It's a draw.")
break
move = connectAgent.next_move(connect)
def test_connection(self):
obj1 = connect.Connect()
c = obj1.connection()
self.assertNotEqual((c, c), ("False,False"))
def send(link, msg):
client = connect.Connect()
entity = client.get_entity(link)
client.send_message(entity, msg)
connect.disConnect(client)
def __init__(self):
obj = connect.Connect()
c, conn = obj.connection()
self.c = c
self.conn = conn
def onNotification(self, sender, method, data):
if sender.lower() not in ('plugin.video.jellyfin', 'xbmc',
'upnextprovider.signal'):
return
if sender == 'plugin.video.jellyfin':
method = method.split('.')[1]
if method not in ('GetItem', 'ReportProgressRequested',
'LoadServer', 'RandomItems', 'Recommended',
'GetServerAddress', 'GetPlaybackInfo', 'Browse',
'GetImages', 'GetToken', 'PlayPlaylist', 'Play',
'GetIntros', 'GetAdditionalParts', 'RefreshItem',
'Genres', 'FavoriteItem', 'DeleteItem',
'AddUser', 'GetSession', 'GetUsers', 'GetThemes',
'GetTheme', 'Playstate', 'GeneralCommand',
'GetTranscodeOptions', 'RecentlyAdded',
'BrowseSeason', 'LiveTV', 'GetLiveStream'):
return
data = json.loads(data)[0]
elif sender.startswith('upnextprovider'):
LOG.info('Attempting to play the next episode via upnext')
method = method.split('.', 1)[1]
if method not in ('plugin.video.jellyfin_play_action', ):
LOG.info('Received invalid upnext method: %s', method)
return
data = json.loads(data)
method = "Play"
if data:
data = json.loads(binascii.unhexlify(data[0]))
else:
if method not in ('Player.OnPlay', 'VideoLibrary.OnUpdate',
'Player.OnAVChange'):
''' We have to clear the playlist if it was stopped before it has been played completely.
Otherwise the next played item will be added the previous queue.
'''
if method == "Player.OnStop":
xbmc.sleep(
3000
) # let's wait for the player so we don't clear the canceled playlist by mistake.
if xbmc.getCondVisibility(
"!Player.HasMedia + !Window.IsVisible(busydialog)"
):
xbmc.executebuiltin("Playlist.Clear")
LOG.info("[ playlist ] cleared")
return
data = json.loads(data)
LOG.debug("[ %s: %s ] %s", sender, method, JsonDebugPrinter(data))
if self.sleep:
LOG.info("System.OnSleep detected, ignore monitor request.")
return
try:
if not data.get('ServerId'):
server = Jellyfin()
else:
if method != 'LoadServer' and data[
'ServerId'] not in self.servers:
try:
connect.Connect().register(data['ServerId'])
self.server_instance(data['ServerId'])
except Exception as error:
LOG.exception(error)
dialog("ok",
heading="{jellyfin}",
line1=translate(33142))
return
server = Jellyfin(data['ServerId'])
except Exception as error:
LOG.exception(error)
server = Jellyfin()
if method == 'GetItem':
item = server.jellyfin.get_item(data['Id'])
self.void_responder(data, item)
elif method == 'GetAdditionalParts':
item = server.jellyfin.get_additional_parts(data['Id'])
self.void_responder(data, item)
elif method == 'GetIntros':
item = server.jellyfin.get_intros(data['Id'])
self.void_responder(data, item)
elif method == 'GetImages':
item = server.jellyfin.get_images(data['Id'])
self.void_responder(data, item)
elif method == 'GetServerAddress':
server_address = server.auth.get_server_info(
server.auth.server_id)['address']
self.void_responder(data, server_address)
elif method == 'GetPlaybackInfo':
sources = server.jellyfin.get_play_info(data['Id'],
data['Profile'])
self.void_responder(data, sources)
elif method == 'GetLiveStream':
sources = server.jellyfin.get_live_stream(data['Id'],
data['PlaySessionId'],
data['Token'],
data['Profile'])
self.void_responder(data, sources)
elif method == 'GetToken':
token = server.auth.jellyfin_token()
self.void_responder(data, token)
elif method == 'GetSession':
session = server.jellyfin.get_device(self.device_id)
self.void_responder(data, session)
elif method == 'GetUsers':
users = server.jellyfin.get_users()
self.void_responder(data, users)
elif method == 'GetTranscodeOptions':
result = server.jellyfin.get_transcode_settings()
self.void_responder(data, result)
elif method == 'GetThemes':
if data['Type'] == 'Video':
theme = server.jellyfin.get_items_theme_video(data['Id'])
else:
theme = server.jellyfin.get_items_theme_song(data['Id'])
self.void_responder(data, theme)
elif method == 'GetTheme':
theme = server.jellyfin.get_themes(data['Id'])
self.void_responder(data, theme)
elif method == 'Browse':
result = downloader.get_filtered_section(data.get('Id'),
data.get('Media'),
data.get('Limit'),
data.get('Recursive'),
data.get('Sort'),
data.get('SortOrder'),
data.get('Filters'),
data.get('Params'),
data.get('ServerId'))
self.void_responder(data, result)
elif method == 'BrowseSeason':
result = server.jellyfin.get_seasons(data['Id'])
self.void_responder(data, result)
elif method == 'LiveTV':
result = server.jellyfin.get_channels()
self.void_responder(data, result)
elif method == 'RecentlyAdded':
result = server.jellyfin.get_recently_added(
data.get('Media'), data.get('Id'), data.get('Limit'))
self.void_responder(data, result)
elif method == 'Genres':
result = server.jellyfin.get_genres(data.get('Id'))
self.void_responder(data, result)
elif method == 'Recommended':
result = server.jellyfin.get_recommendation(
data.get('Id'), data.get('Limit'))
self.void_responder(data, result)
elif method == 'RefreshItem':
server.jellyfin.refresh_item(data['Id'])
elif method == 'FavoriteItem':
server.jellyfin.favorite(data['Id'], data['Favorite'])
elif method == 'DeleteItem':
server.jellyfin.delete_item(data['Id'])
elif method == 'PlayPlaylist':
server.jellyfin.post_session(
server.config.data['app.session'], "Playing", {
'PlayCommand': "PlayNow",
'ItemIds': data['Id'],
'StartPositionTicks': 0
})
elif method == 'Play':
items = server.jellyfin.get_items(data['ItemIds'])
PlaylistWorker(data.get('ServerId'), items,
data['PlayCommand'] == 'PlayNow',
data.get('StartPositionTicks', 0),
data.get('AudioStreamIndex'),
data.get('SubtitleStreamIndex')).start()
elif method in ('ReportProgressRequested', 'Player.OnAVChange'):
self.player.report_playback(data.get('Report', True))
elif method == 'Playstate':
self.playstate(data)
elif method == 'GeneralCommand':
self.general_commands(data)
elif method == 'LoadServer':
self.server_instance(data['ServerId'])
elif method == 'AddUser':
server.jellyfin.session_add_user(server.config.data['app.session'],
data['Id'], data['Add'])
self.additional_users(server)
elif method == 'Player.OnPlay':
on_play(data, server)
elif method == 'VideoLibrary.OnUpdate':
on_update(data, server)
def newEnv():
env = connect.Connect(verbose=False)
env.reset(first_player='x')
return env
