def myPlex(servercfg):
logger = logging.getLogger(__name__)
from plexapi.myplex import MyPlexUser
from plexapi.server import PlexServer
user = MyPlexUser(servercfg['username'], servercfg['password'])
for key in user.keys():
logger.debug("\tKey: %s\tValue: %s" % (key, user[key]))
server = user.getServer(servercfg['server']).connect
for server in user.servers():
logger.info("Server: %s" % (server))
plex = PlexServer(servercfg['host'], servercfg['port'],
user['authenticationToken'])
for section in plex.library.sections():
logger.info("Section: %s" % (section.title))
def main():
tvdb = tvdb_api.Tvdb()
username = os.environ.get('plex_user') or raw_input("Plex username? ")
password = os.environ.get('plex_pass') or getpass.getpass("{0} password? ".format(username))
user = MyPlexUser(username, password)
servers = user.servers()
for i, server in enumerate(servers):
print i, server.name
server_id = int(os.environ.get('plex_server') or raw_input("Server ID? "))
print
server = servers[server_id].connect()
sections = server.library.sections()
for i, section in enumerate(sections):
print i, section.title
section_id = int(os.environ.get('plex_section') or raw_input("Section ID? "))
print
section = sections[section_id]
shows = {}
for show in section.all():
seasons = {}
for season in show.seasons():
ep_list = []
for episode in season.episodes():
ep_list.append(episode.index)
seasons[season.index] = ep_list
shows[show.title] = seasons
# break
missing = []
for show in sorted(shows):
seasons = shows[show]
try:
tvdb_show = tvdb[show]
except:
print "Show named \"" + show + "\" not found on TVDB"
continue
for season in tvdb_show:
if season == 0:
continue
for episode in tvdb_show[season].values():
e = episode['episodenumber']
s = episode['seasonnumber']
fa = episode['firstaired']
# print episode.keys(), episode.values()
try:
aired = datetime.strptime(fa, "%Y-%m-%d %H:%M:%S")
except:
try:
aired = datetime.strptime(fa, "%Y-%m-%d")
except:
aired = datetime(3000,1,1)
if aired > datetime.today():
continue
if not e in seasons.get(s, []):
missing.append((show, s.zfill(2), e.zfill(2), ))
if len(missing):
print "Missing episodes:"
missing.append(('',0,0),)
i = 0
while i < len(missing) - 1:
miss = missing[i]
missing_end = missing[i+1:]
last_inner_miss = None
succession = 0
for j, inner_miss in enumerate(missing_end):
if miss[0] == inner_miss[0] and miss[1] == inner_miss[1] and \
(int(miss[2]) + j + 1) == int(inner_miss[2]):
succession += 1
else:
if succession > 0:
i += succession + 1
print u"{0} S{1}E{2} - S{1}E{3}".format(miss[0], miss[1], miss[2], last_inner_miss[2])
break
last_inner_miss = inner_miss
else:
print u"{0} S{1}E{2}".format(*miss)
i += 1
else:
print "No missing episodes found!"
class PlexClient(object):
def __init__(self):
self.config = get_config()
self.config.verify()
self._logger = get_logger(self.__class__.__name__)
self.c_info = ClientInfo.from_config(self.config)
self._monitor = ThreadMonitor()
# self._monitor.start()
self.registration_thread = ClientRegistration(self.c_info)
# this call will block if XBMC is unresponsive, will resume when XBMC is UP
self._xbmc_rpc = XbmcJSONRPC(self.config['xbmc_host'], self.config['xbmc_port']).wait()
self._xbmc = XBMCPlexPlayer(self._xbmc_rpc, self)
self.xbmc.notify('Plex', 'PlexMyXBMC Connected')
self._user = MyPlexUser(self.config['plex_username'], self.config['plex_password'])
self.xbmc.notify('Plex', 'Logged in as "%s"' % self.config['plex_username'])
self.xbmc.notify('Plex', 'Master server is {0}'.format(self.config['plex_server']))
try:
self._server = self.get_coolest_server()
self.xbmc.notify('Plex', 'using PMS %s' % self._server.friendlyName)
except:
self.xbmc.notify('Plex', 'failed to connect to master server')
raise
self.sub_mgr = PlexSubManager(self)
self.event_mgr = PlexEventsManager(self)
self.httpd = ThreadedAPIServer(self, ('', self.config['port']), PlexClientHandler)
self.httpd.allow_reuse_address = True
self.storage_mgr = PlexStorageManager(self, self.config['local_sync_cache'])
self.sync_mgr = PlexSyncManager(self, self.storage_mgr)
self._keep_running = Event()
self._keep_running.clear()
self._lock = Lock()
def __del__(self):
self.stop()
self.join()
def _serve_loop(self):
while self._keep_running.is_set() is True:
self.httpd.handle_request()
def serve(self):
self.registration_thread.start()
self.event_mgr.start()
self.sync_mgr.start()
self.publish_resources()
self._keep_running.set()
try:
self._serve_loop()
except KeyboardInterrupt:
self._keep_running.clear()
def stop(self):
self._keep_running.clear()
self.registration_thread.stop()
self.event_mgr.stop()
self._xbmc_rpc.stop()
self.sync_mgr.stop()
# self._monitor.stop()
def join(self):
if self.registration_thread.isAlive():
self.registration_thread.join()
if self._monitor.isAlive():
self._monitor.join()
if self.event_mgr.isAlive():
self.event_mgr.join()
if self.sync_mgr.isAlive():
self.sync_mgr.join()
def get_coolest_server(self):
servers = self._user.servers()
self._logger.info('MyPlex registered servers: %s', ', '.join(map(lambda x: x.name, servers)))
master_server = self.config.get('plex_server', '')
for server in servers:
if server.name != master_server:
continue
return MyPlexServer(server).connect()
raise NotFound('could not find master server {0}'.format(master_server))
def authenticated_url(self, url):
"""
:type url: str
"""
url = self._server.url(url) if url.startswith('/') else url
token = 'X-Plex-Token=' + self._user.authenticationToken
return url + ('&' if '?' in url else '?') + token
@property
def headers(self):
plex_headers = {
"Content-Type": "application/x-www-form-urlencoded",
'Access-Control-Expose-Headers': 'X-Plex-Client-Identifier',
"Access-Control-Allow-Origin": "*",
"X-Plex-Device": "PC",
"X-Plex-Username": self._user.username,
"X-Plex-Token": self._user.authenticationToken,
}
plex_headers.update(plexapi.BASE_HEADERS)
return plex_headers
@property
def server(self):
return self._server
@property
def user(self):
return self._user
@property
def xbmc(self):
return self._xbmc
@property
def local_address(self):
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(('www.google.com', 80))
addr, port = s.getsockname()
s.close()
return addr, self.config['port']
def publish_resources(self):
addr, port = self.local_address
connection = 'http://{0}:{1}/'.format(addr, port)
data = {'Connection[][uri]': connection}
url = 'https://plex.tv/devices/{0}'.format(self.config['uuid'])
resp = requests.put(url, data=data, headers=self.headers)
if resp.status_code == 200:
self._logger.info('published device resources to plex.tv successfully')
else:
self._logger.warn('failed to publish devices resources to plex.tv')
