def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.addon = xbmcaddon.Addon()
self.addonName = self.getAddonName()
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.addonId = clientinfo.ClientInfo().getAddonId()
self.doUtils = downloadutils.DownloadUtils().downloadUrl
self.userClient = userclient.UserClient()
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
clientInfo = clientinfo.ClientInfo()
self.addonName = clientInfo.getAddonName()
self.kodiversion = int(xbmc.getInfoLabel('System.BuildVersion')[:2])
def __init__(self, embycursor):
global log
log = Logging(self.__class__.__name__).log
self.embycursor = embycursor
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
def __init__(self, cursor):
global log
log = Logging(self.__class__.__name__).log
self.cursor = cursor
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
self.artwork = artwork.Artwork()
def __init__(self, item):
global log
log = Logging(self.__class__.__name__).log
# item is the api response
self.item = item
self.clientinfo = clientinfo.ClientInfo()
self.addonName = self.clientinfo.getAddonName()
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
self.doUtils = downloadutils.DownloadUtils()
log("Kodi monitor started.", 1)
def __init__(self, item):
global log
log = Logging(self.__class__.__name__).log
self.item = item
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
self.userid = window('emby_currUser')
self.server = window('emby_server%s' % self.userid)
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
self.doUtils = downloadutils.DownloadUtils().downloadUrl
self.userId = window('emby_currUser')
self.server = window('emby_server%s' % self.userId)
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
self.userid = window('emby_currUser')
self.server = window('emby_server%s' % self.userid)
self.emby = embyserver.Read_EmbyServer()
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.__dict__ = self._shared_state
self.addon = xbmcaddon.Addon()
self.addonName = clientinfo.ClientInfo().getAddonName()
self.doUtils = downloadutils.DownloadUtils()
threading.Thread.__init__(self)
def __init__(self, link):
super().__init__()
self.link = link
self.process_number = self.link.process_number
self.send = self.link.register_abstraction(self)
self.peers = set()
self.detected = set()
self.correct = set()
self.lock = Lock()
self.worker = Thread(target=self.detect_failures)
self.logger = Logging(self.process_number, "PFD")
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.__dict__ = self._shared_state
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
self.doUtils = downloadutils.DownloadUtils().downloadUrl
self.ws = wsc.WebSocket_Client()
self.xbmcplayer = xbmc.Player()
log("Starting playback monitor.", 2)
def __init__(self, link, pfd, beb):
super().__init__(link)
self.beb = beb
self.broadcast = self.beb.register_abstraction(self)
self.pfd = pfd
self.pfd.subscribe_abstraction(self, self.peer_failure)
self.peers = {self.process_number}
self.beb.add_peers(self.process_number)
self.detected = set()
self.reset()
self.finished_peers = {peer: False for peer in self.peers}
self.logger = Logging(self.process_number, "HCO")
def __init__(self, pfd, hco):
super().__init__()
self.process_number = hco.process_number
self.pfd = pfd
self.pfd.subscribe_abstraction(self, self.peer_failure)
self.hco = hco
self.hco.subscribe_abstraction(self, self.decided)
self.peers = {self.process_number}
self.detected = set()
self.leader = None
self.in_election = False
self.logger = Logging(self.process_number, "LEL")
def __init__(self, item):
global log
log = Logging(self.__class__.__name__).log
self.item = item
self.API = api.API(self.item)
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
self.doUtils = downloadutils.DownloadUtils().downloadUrl
self.userid = window('emby_currUser')
self.server = window('emby_server%s' % self.userid)
self.artwork = artwork.Artwork()
self.emby = embyserver.Read_EmbyServer()
self.pl = playlist.Playlist()
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.clientinfo = clientinfo.ClientInfo()
self.addonName = self.clientinfo.getAddonName()
self.enableTextureCache = settings('enableTextureCache') == "true"
self.imageCacheLimitThreads = int(settings('imageCacheLimit'))
self.imageCacheLimitThreads = int(self.imageCacheLimitThreads * 5)
log("Using Image Cache Thread Count: %s" % self.imageCacheLimitThreads,
1)
if not self.xbmc_port and self.enableTextureCache:
self.setKodiWebServerDetails()
self.userId = window('emby_currUser')
self.server = window('emby_server%s' % self.userId)
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.clientInfo = clientinfo.ClientInfo()
self.addonName = self.clientInfo.getAddonName()
logLevel = userclient.UserClient().getLogLevel()
self.monitor = xbmc.Monitor()
window('emby_logLevel', value=str(logLevel))
window('emby_kodiProfile',
value=xbmc.translatePath('special://profile'))
# Initial logging
log("======== START %s ========" % self.addonName, 0)
log("Platform: %s" % (self.clientInfo.getPlatform()), 0)
log("KODI Version: %s" % xbmc.getInfoLabel('System.BuildVersion'), 0)
log("%s Version: %s" % (self.addonName, self.clientInfo.getVersion()),
0)
log("Using plugin paths: %s" % (settings('useDirectPaths') == "0"), 0)
log("Log Level: %s" % logLevel, 0)
# Reset window props for profile switch
properties = [
"emby_online", "emby_serverStatus", "emby_onWake",
"emby_syncRunning", "emby_dbCheck", "emby_kodiScan",
"emby_shouldStop", "emby_currUser", "emby_dbScan",
"emby_sessionId", "emby_initialScan", "emby_customplaylist",
"emby_playbackProps"
]
for prop in properties:
window(prop, clear=True)
# Clear video nodes properties
videonodes.VideoNodes().clearProperties()
# Set the minimum database version
window('emby_minDBVersion', value="1.1.63")
def __init__(
self,
results_dir,
dataloaders,
model,
criterion,
optimizer,
use_gpu,
test_dataset,
test_mode,
seed,
data_parallel=False,
sync_bn=False,
):
# base settings
self.results_dir = results_dir
self.dataloaders = dataloaders
self.model = model
self.criterion = criterion
self.optimizer = optimizer
self.device = torch.device("cuda") if use_gpu else torch.device("cpu")
self.test_dataset = test_dataset
self.test_mode = test_mode
self.seed = seed
assert test_mode in ["all", "in_door"], "test_mode should be 'all' or 'in_door'"
self.loss_meter = MultiItemAverageMeter()
os.makedirs(self.results_dir, exist_ok=True)
self.logging = Logging(os.path.join(self.results_dir, "logging.txt"))
self.model = self.model.to(self.device)
if data_parallel:
if not sync_bn:
self.model = nn.DataParallel(self.model)
if sync_bn:
# torch.distributed.init_process_group(backend='nccl', world_size=4, init_method='...')
self.model = nn.SyncBatchNorm.convert_sync_batchnorm(self.model)
def test(args):
# np.random.seed(1)
# torch.manual_seed(1)
# torch.cuda.manual_seed_all(1)
# random.seed(1)
# np.random.seed(1)
item_num, test_support_data, test_negative_dict, test_negative, test_mat, sup_max = data_prepare.load_all(
args)
if args.dataset == 'amazon_small':
item_num = 9449
elif args.dataset == 'amazon_big':
item_num = 57790
else:
item_num = 3952
test_data = data_prepare.Test_data(test_support_data, item_num, test_mat,
sup_max, args)
test_data.ng_test_sample()
log_str_path = './test_log/hr' + str(args.topK) + '/' + args.model + str(
args.number) + 'test' + args.dataset + 'GL' + str(
args.global_lr) + 'LE' + str(args.local_epoch) + 'LL' + str(
args.local_lr)
mod_str_path = './saved_models/' + args.model + str(
args.number) + 'train' + args.dataset + 'GL' + str(
args.global_lr) + 'LE' + str(args.local_epoch) + 'LL' + str(
args.local_lr)
log = Logging(log_str_path + '.log')
eval_ = args.model + "(item_num,args).cuda()"
model = eval(eval_)
mod = torch.load(mod_str_path + '.mod')
model.load_state_dict(mod)
hrs, ndcgs = model.evaluate_test(test_data, test_negative_dict,
test_negative, test_data.sup_dict)
log.record('------hr:{}-------------ndcg{}'.format(np.mean(hrs),
np.mean(ndcgs)))
def __init__(self, process_number, decide_callback, deliver_callback):
super().__init__()
self.process_number = process_number
self.decide_callback = decide_callback
self.deliver_callback = deliver_callback
self.link = PerfectLink(self.process_number)
self.pfd = PerfectFailureDetector(self.link)
self.pfd.subscribe_abstraction(self, self.peer_failure)
self.erb = EagerReliableBroadcast(self.link)
self.broadcast = self.erb.register_abstraction(self)
self.beb = BestEffortBroadcast(self.link)
self.hco = HierarchicalConsensus(self.link, self.pfd, self.beb)
self.hco.subscribe_abstraction(self, self.consensus_decided)
self.lel_hco = HierarchicalConsensus(self.link, self.pfd, self.beb)
self.lel = LeaderElection(self.pfd, self.lel_hco)
self.lel.subscribe_abstraction(self, self.new_leader)
self.leader = None
self.peers = {self.process_number}
self.detected = set()
self.erb.add_peers(self.process_number)
self.votes = {}
self.voted = {peer: False for peer in self.peers}
self.finished_election = Event()
self.finished_consensus = Event()
self.finished_consensus.set()
self.consensus_result = None
self.proposition = None
self.logger = Logging(self.process_number, "VOT")
import pymongo
from config import *
from utils import Logging
logger = Logging(log_name="collateral_str").getLogger()
conn = pymongo.MongoClient(mongodb_params['host'], mongodb_params['port'])
conn_db = conn[mongodb_params['db_name']]
count = 1
for object in conn_db.account_collateral.find():
logger.info(object)
object["collateral"] = str(object["collateral"])
logger.info(object)
logger.info("--------------- {} ---------------------\n".format(count))
count += 1
conn_db.account_collateral.save(object)
import xbmcgui
#################################################################################################
_addon = xbmcaddon.Addon(id='plugin.video.emby')
_addon_path = _addon.getAddonInfo('path').decode('utf-8')
_base_resource = xbmc.translatePath(
os.path.join(_addon_path, 'resources', 'lib')).decode('utf-8')
sys.path.append(_base_resource)
#################################################################################################
import entrypoint
import utils
from utils import Logging, window, language as lang
log = Logging('Default').log
#################################################################################################
class Main():
# MAIN ENTRY POINT
#@utils.profiling()
def __init__(self):
# Parse parameters
base_url = sys.argv[0]
params = urlparse.parse_qs(sys.argv[2][1:])
log("Parameter string: %s" % sys.argv[2], 0)
try:
import xbmcplugin
import artwork
import utils
import clientinfo
import downloadutils
import librarysync
import read_embyserver as embyserver
import embydb_functions as embydb
import playlist
import playbackutils as pbutils
import playutils
import api
from utils import Logging, window, settings, language as lang
log = Logging('Entrypoint').log
#################################################################################################
def doPlayback(itemId, dbId):
emby = embyserver.Read_EmbyServer()
item = emby.getItem(itemId)
pbutils.PlaybackUtils(item).play(itemId, dbId)
##### DO RESET AUTH #####
def resetAuth():
# User tried login and failed too many times
resp = xbmcgui.Dialog().yesno(heading=lang(30132), line1=lang(33050))
# -*- coding:utf-8 -*-
from PythonMiddleware.notify import Notify
from PythonMiddleware.graphene import Graphene
from PythonMiddlewarebase.operationids import operations
import pymongo
from config import *
from utils import Logging
logger = Logging(console=True).getLogger()
gph = Graphene(node=nodeaddress)
def witness_check():
conn = pymongo.MongoClient(mongodb_params['host'], mongodb_params['port'])
conn_db = conn[mongodb_params['db_name']]
index = 1
witness_id_prefix = "1.6."
while True:
witness_id = "{}{}".format(witness_id_prefix, index)
logger.info("witness_id: {}".format(witness_id))
witness_obj = gph.rpc.get_object(witness_id)
if witness_obj is None:
break
witness_account_obj = gph.rpc.get_object(
witness_obj['witness_account'])
try:
count = conn_db.block.count(
{'witness': witness_account_obj["name"]})
def __init__(self, process_number):
super().__init__()
self.process_number = process_number
self.create_socket()
self.listener = Thread(target=self.receive)
self.logger = Logging(self.process_number, "LINK")
# Option to hash files
if hashing:
hasher.file_hash(url)
if __name__ == "__main__":
banner = rf"""
+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+
| I m a g e D o w n l o a d e r |
+-+-+-+-+-+ +-+-+-+-+-+-+-+-+-+-+-+
{__version__} {__author__}
"""
print(f"\033[36m{banner}\033[m")
log = Logging().logger
# file size range (10kB - 50kB)
def size_limit(arg):
_min = 10000
_max = 1000000
try:
_float = int(float(arg) * 10**3)
except ValueError as err:
raise argparse.ArgumentTypeError(
f"{YELLOW}Argument must be an integer value{RESET}") from err
if _float < _min or _float > _max:
raise argparse.ArgumentTypeError(
f"{YELLOW}Value must be between {_min // 1000:} and {_max // 1000:} (kB){RESET}"
)
def __init__(self, platform, logtag, tz, cloud_auth=None):
self.fp = FilePath(platform, cloud_auth)
self.lg = Logging(platform, "validate", logtag, cloud_auth)
self.lg.logtxt("[START VALIDATION]")
self.tz = tz
def __init__(self, platform, logtag, tz, cloud_auth=None):
self.fp = FilePath(platform, cloud_auth)
self.lg = Logging(platform, "forecast", logtag, cloud_auth)
self.lg.logtxt("[START FORECASTING]")
self.tz = tz
def __init__(self):
global log
log = Logging(self.__class__.__name__).log
self.__dict__ = self._shared_state
