def show_files(self):
        if self.files:
            return

        self.files = pyxbmct.List("font14")
        self.placeControl(self.files, 0, 0)

        cursel = self.list.getSelectedItem()
        debug(cursel.getLabel())
        link = cursel.getProperty("link")

        match = re.search("torrent=(.+)&", str(link))
        if not match:
            pattern2 = "torrent=(.+)"
            match = re.search(pattern2, str(link))

        if match:
            link = match.group(1)

        self.list.setVisible(False)

        tempPath = xbmc.translatePath("special://temp").decode("utf-8")
        from downloader import TorrentDownloader
        import player

        settings = self.settings
        import urllib

        torr_downloader = TorrentDownloader(urllib.unquote(link), tempPath, settings)
        path = filesystem.join(
            settings.torrents_path(), torr_downloader.get_subdir_name(), torr_downloader.get_post_index() + ".torrent"
        )
        if not filesystem.exists(path):
            torr_downloader.download()
            path = torr_downloader.get_filename()

        debug(path)
        if filesystem.exists(path):
            import base

            player = base.TorrentPlayer()
            player.AddTorrent(path)
            data = player.GetLastTorrentData()
            if data:
                for f in data["files"]:
                    li = xbmcgui.ListItem(f["name"])
                    li.setProperty("index", str(f["index"]))
                    self.files.addItem(li)

        self.setFocus(self.files)
        self.connect(self.files, self.select_file)
	def download_torrent(self, link):
		tempPath = xbmc.translatePath('special://temp').decode('utf-8')
		from downloader import TorrentDownloader
		import player
		settings = self.settings
		import urllib
		torr_downloader = TorrentDownloader(urllib.unquote(link), tempPath, settings)
		path = filesystem.join(settings.torrents_path(), torr_downloader.get_subdir_name(), torr_downloader.get_post_index() + '.torrent')
		if not filesystem.exists(path):
			torr_downloader.download()
			path = torr_downloader.get_filename()

		debug(path)

		return path
Example #3
0
def write_tvshow(fulltitle,
                 link,
                 settings,
                 parser,
                 path,
                 skip_nfo_exists=False):
    from nfowriter import NFOWriter
    from strmwriter import STRMWriter
    import requests

    from downloader import TorrentDownloader
    dl = TorrentDownloader(parser.link(), settings.torrents_path(), settings)
    if not dl.download():
        return None

    #r = requests.get(link)
    #if r.status_code == requests.codes.ok:
    with filesystem.fopen(dl.get_filename(), 'rb') as torr:
        content = torr.read()
        files = parse_torrent(content, season_from_title(fulltitle))

        title = parser.get_value('title')
        debug(title)
        originaltitle = parser.get_value('originaltitle')
        debug(originaltitle)

        imdb_id = parser.get('imdb_id', None)
        kp_id = parser.get('kp_id', None)
        tvshow_api = TVShowAPI.get_by(originaltitle, title, imdb_id, kp_id)

        api_title = parser.movie_api().get('title')
        if not api_title:
            api_title = tvshow_api.Title()
        tvshow_path = make_fullpath(
            api_title if api_title is not None else title, '')
        debug(tvshow_path)

        if tvshow_path:
            tvshow_path = filesystem.join(path, tvshow_path)
            with filesystem.save_make_chdir_context(tvshow_path):

                NFOWriter(
                    parser,
                    tvshow_api=tvshow_api,
                    movie_api=parser.movie_api()).write_tvshow_nfo(tvshow_path)

                # cnt = 0
                for f in files:
                    # cnt += 1
                    s_num = f['season'] if f['season'] else 1
                    try:
                        episode = tvshow_api.Episode(s_num, f['episode'])
                        if not episode:
                            episode = {
                                'title': title,
                                'seasonNumber': s_num,
                                'episodeNumber': f['episode'],
                                'image': '',
                                'airDate': ''
                            }

                        season_path = 'Season %d' % s_num
                    except BaseException as e:
                        print_tb(e)
                        continue

                    season_path = filesystem.join(tvshow_path, season_path)
                    with filesystem.save_make_chdir_context(season_path):

                        results = filter(
                            lambda x: x['season'] == s_num and x['episode'] ==
                            f['episode'], files)
                        if len(results) > 1:  # Has duplicate episodes
                            filename = f['name']
                        else:
                            try:
                                cnt = f['episode']
                                filename = '%02d. episode_s%02de%02d' % (
                                    cnt, s_num, f['episode'])
                            except BaseException as e:
                                print_tb(e)
                                filename = f['name']

                        try:
                            debug(filename)
                            filename = filename.decode('utf-8')
                        except:
                            debug([filename])

                        STRMWriter(parser.link()).write(filename,
                                                        season_path,
                                                        index=f['index'],
                                                        settings=settings,
                                                        parser=parser)
                        NFOWriter(parser,
                                  tvshow_api=tvshow_api,
                                  movie_api=parser.movie_api()).write_episode(
                                      episode,
                                      filename,
                                      season_path,
                                      skip_nfo_exists=skip_nfo_exists)
            return tvshow_path
            # end for
        else:
            return None
def write_tvshow(fulltitle, link, settings, parser):
	from nfowriter import NFOWriter
	from strmwriter import STRMWriter
	import requests

	from downloader import TorrentDownloader
	dl = TorrentDownloader(parser.link(), settings.torrents_path(), settings)
	if not dl.download():
		return

	#r = requests.get(link)
	#if r.status_code == requests.codes.ok:
	with filesystem.fopen(dl.get_filename(), 'rb') as torr:
		content = torr.read()
		files = parse_torrent(content, season_from_title(fulltitle))

		title = parser.get_value('title')
		debug(title.encode('utf-8'))
		originaltitle = parser.get_value('originaltitle')
		debug(originaltitle.encode('utf-8'))

		imdb_id = parser.get('imdb_id', None)
		kp_id = parser.get('kp_id', None)
		tvshow_api = TVShowAPI(originaltitle, title, imdb_id, kp_id)

		api_title = tvshow_api.Title()
		tvshow_path = make_fullpath(api_title if api_title is not None else title, '')
		debug(tvshow_path.encode('utf-8'))

		if tvshow_path:
			with filesystem.save_make_chdir_context(tvshow_path):

				NFOWriter(parser, tvshow_api=tvshow_api, movie_api=parser.movie_api()).write_tvshow_nfo()

				# cnt = 0
				for f in files:
					# cnt += 1
					s_num = f['season'] if f['season'] else 1
					try:
						episode = tvshow_api.Episode(s_num, f['episode'])
						if not episode:
							episode = {
								'title': title,
								'seasonNumber': s_num,
								'episodeNumber': f['episode'],
								'image': '',
								'airDate': ''
							}

						season_path = 'Season %d' % s_num
					except BaseException as e:
						print_tb(e)
						continue

					with filesystem.save_make_chdir_context(season_path):

						results = filter(lambda x: x['season'] == s_num and x['episode'] == f['episode'], files)
						if len(results) > 1:	# Has duplicate episodes
							filename = f['name']
						else:
							try:
								cnt = f['episode']
								filename = '%02d. episode_s%02de%02d' % (cnt, s_num, f['episode'])
							except BaseException as e:
								print_tb(e)
								filename = f['name']

						try:
							debug(filename)
							filename = filename.decode('utf-8')
						except:
							debug([filename])

						STRMWriter(parser.link()).write(filename, index=f['index'], settings=settings, parser=parser)
						NFOWriter(parser, tvshow_api=tvshow_api, movie_api=parser.movie_api()).write_episode(episode, filename)