Пример #1
0
    def get(self, request, *args, **kwargs):
        form = self.form_class()
        torrent_form = TorrentForm()
        if 'search_string' in request.GET:
            form = self.form_class(request.GET)
            torrent_form = TorrentForm()
            results = None

            # get cleaned form data
            search_string = request.GET.get('search_string', "")
            category_string = request.GET.get('category', "")

            # construct search arguments
            # hardcoded to get first page, sort by number of seeders in descending order
            t = TPB(settings.TPB_URL)
            category = match_category(category_string)
            search = t.search(search_string,
                              category=category).order(ORDERS.SEEDERS.ASC)
            results = search.page(1)

            # set results to None if search didn't return anything
            results = None if get_results_length(results) == 0 else results

            return render(request, self.template_name, {
                'form': form,
                'results': results,
                'torrent_form': torrent_form
            })
        else:
            return render(request, self.template_name, {
                'form': form,
                'results': None,
                'torrent_form': torrent_form
            })
Пример #2
0
    def get(self, request, *args, **kwargs):
        form = self.form_class()
        torrent_form = TorrentForm()
        if "search_string" in request.GET:
            form = self.form_class(request.GET)
            torrent_form = TorrentForm()
            results = None

            # get cleaned form data
            search_string = request.GET.get("search_string", "")
            category_string = request.GET.get("category", "")

            # construct search arguments
            # hardcoded to get first page, sort by number of seeders in descending order
            t = TPB(settings.TPB_URL)
            category = match_category(category_string)
            search = t.search(search_string, category=category).order(ORDERS.SEEDERS.ASC)
            results = search.page(1)

            # set results to None if search didn't return anything
            results = None if get_results_length(results) == 0 else results

            return render(request, self.template_name, {"form": form, "results": results, "torrent_form": torrent_form})
        else:
            return render(request, self.template_name, {"form": form, "results": None, "torrent_form": torrent_form})
Пример #3
0
    def generate_search_results(self, request):

        query = request.GET.get('q', None)

        cleaned_results = []

        if not query:
            cleaned_results = request.session.get('search_results', None)
            query = request.session.get('search_query', None)
        elif 'sanni' in query.lower():
            cleaned_results = [{'display_name': 'I <3 Sanni Harrison :-D'}]
        else:
            t = TPB('https://thepiratebay.org')
            results = t.search(query, category=CATEGORIES.VIDEO.ALL)

            cleaned_results = [{'display_name': result.title,
                                'url': urllib.quote(result.magnet_link),
                                'seeder_count': result.seeders,
                                'leecher_count': result.leechers
                               } for result in results]

            request.session['search_results'] = cleaned_results
            request.session['search_query'] = query

        return render(request, 'search_results.html', {'object_list': cleaned_results, 'search_query': query})
Пример #4
0
    def load(self):
        self.settings.load()

        tpb_base_url = self.settings.get('tpb_base_url')
        self.api_tpb = TPB(
            'https://thepiratebay.se' if not tpb_base_url else tpb_base_url)
        tvdb_api_key = self.settings.get('tvdb_api_key')
        self.api_tvdb = TVDB.TVDB(
            '81DD35DB106172E7' if not tvdb_api_key else tvdb_api_key)
Пример #5
0
	def get_items(self):
	        proto = "https" if __kupfer_settings__["https"] else "http"
                url = proto + "://" + __kupfer_settings__["pirate_bay_host"]
                api = TPB(url)
                results = api.search(self.query)
		for result in results:
			yield UrlLeaf(result.magnet_link, result.title)
		yield CustomDescriptionUrl(results.url,
				_('Show More Results For "%s"') % self.query,
				_("More results"))
Пример #6
0
def search_torrent(title):
    result = None
    pirate = TPB('https://thepiratebay.org')
    search = pirate.search(title, category=CATEGORIES.VIDEO.MOVIES).order(ORDERS.SEEDERS.DES)
    for torrent in search:
        result = torrent
        break; 
    if(result == None or result.seeders < int(get_setting("seeders"))):
        return None
    else:
        return result
Пример #7
0
def _find_torrent(movie, minimum_torrent_quality=2):
    t = TPB('https://thepiratebay.org')
    search = t.search("%s %s" % (movie.name, _year(movie)), category=CATEGORIES.VIDEO)
    search.order(ORDERS.SEEDERS.DES).page(1)
    best_torrent = None
    best_torrent_quality = None
    for torrent in search:
        (created, current_time) = torrent._created

        quality = _torrent_quality(torrent, created, movie)
        if not best_torrent or quality > best_torrent_quality:
            best_torrent = torrent
            best_torrent_quality = quality

    if best_torrent_quality > minimum_torrent_quality:
        return best_torrent
Пример #8
0
class TorrentProvider(object):
    def __init__(self):
        self.provider = TPB("https://thepiratebay.pe")
        self.MINIMUM_SEEDS = 5

    def find(self, seriename):
        return self._find(seriename)

    @timeout_decorator.timeout(15)
    def _find(self, seriename):
        print("Searching for %s" % seriename)
        search = self.provider.search(seriename)
        search.order(ORDERS.SEEDERS.ASC).multipage()
        torrent = True
        while torrent:
            try:
                torrent = next(search.items())
            except StopIteration:
                return None
            except URLError:
                print("Can't connect to the torrent provider")
                return None
            else:
                if torrent.seeders > self.MINIMUM_SEEDS:
                    return torrent.magnet_link
                else:
                    print("Can't find torrent with the minimun required seeds")
                    torrent = False
Пример #9
0
def scrape():

    content = request.get_json()

    if content != {}:
        res = {}

        keywords = get_keywords(content['page_url'])
        unique_kws = create_unique_combinations(keywords)

        tpb, torrents = TPB('https://thepiratebay.org'), []

        for kw in unique_kws:
            existing_magnets = [t['magnet'] for t in torrents]
            new_torrents = find_torrents('{} {}'.format(kw[0], kw[1]), tpb)

            for t in new_torrents:
                if t['magnet'] not in existing_magnets:
                    torrents.append(t)

        torrents = sorted(torrents, key=lambda torrent:
                          (torrent['seeders']))[-3:]

        return jsonify(torrents)

    return jsonify('Provide valid URL')
Пример #10
0
def main():
    t = TPB('https://thepiratebay.org')
    createTorrentDirectory()
    movieFile = open("movieList.txt", "r")
    totRes = 0
    totMovies = 0
    for line in movieFile.readlines():
        print "MOVIE - " + line.split("\n")[0]
        search = t.search(line.split("\n")[0])
        for torrent in search:
            saveTorrentInDir("./Torrents", torrent)
            print "\t" + torrent.title
            totRes += 1
        totMovies += 1

    print "Total Movies = " + str(totMovies)
    print "TotalRes = " + str(totRes)
Пример #11
0
def get_torrent():
    with open(globals.json_weekly, "r") as readfile:
        l_weekly = json.load(readfile)

    for item in l_weekly:
        #if item.get("torrents"):
        #    continue

        tpb = TPB('https://thepiratebay.org') # create a TPB object with default domain
        # search for 'public domain' in 'movies' category
        search_text = item["title"]+" "+str(item["year"])

        print "*" * 10
        print "Searching for:", search_text
        search = tpb.search(search_text, category=CATEGORIES.VIDEO).order(ORDERS.SEEDERS.DES).page(0)
        

        torrent = [v for i,v in enumerate(search) if i==0]
        
        if len(torrent) < 1:
            continue

        # 1. no torrents retrieved
        # 2. do have torrents and title is different, always get the top rank of torrent
        if (not item.get("torrents")) or \
                (item.get("torrents") and item.get("torrents")[0]["title"] != torrent[0].title):
            item["torrents"] = [
                    {
                        "title":torrent[0].title,
                        "magnet_link":torrent[0].magnet_link,
                        "created":str(torrent[0].created),
                        "size":torrent[0].size,
                        "seeders":torrent[0].seeders,
                        "files":torrent[0].files
                        }
                    ]

            print item["torrents"][0]


    with open(globals.json_weekly, "w") as outfile:
        json.dump(l_weekly, outfile, indent=4)
Пример #12
0
def  melhor_torrent(nome_busca, qtd = None):
    from tpb import TPB
    from tpb import CATEGORIES, ORDERS

    t = TPB('https://thepiratebay.se') # configurando o site do TPB
    # Buscando todos os tipos de Video
    if not qtd:
        search = t.search(nome_busca, category=CATEGORIES.VIDEO.ALL).order(ORDERS.SEEDERS.DES).page(0)
    else:
        search = t.search(nome_busca, category=CATEGORIES.VIDEO.ALL).order(ORDERS.SEEDERS.DES)

    torrents = []
    for torrent in search:
        torrents.append(torrent)

    try:
        if not qtd:
            return torrents[0].magnet_link
        else:
            return torrents[0:qtd]
    except IndexError:
        return None
Пример #13
0
class ZTShows:
    def __init__(self):
        self.settings = Settings('config.yml')
        self.download_manager = DownloadManager(self)
        self.api_tpb = None
        self.api_tvdb = None

    def load(self):
        self.settings.load()

        tpb_base_url = self.settings.get('tpb_base_url')
        self.api_tpb = TPB(
            'https://thepiratebay.se' if not tpb_base_url else tpb_base_url)
        tvdb_api_key = self.settings.get('tvdb_api_key')
        self.api_tvdb = TVDB.TVDB(
            '81DD35DB106172E7' if not tvdb_api_key else tvdb_api_key)

    def unload(self):
        self.settings.save()

    def search(self, query, callback):
        def work(w_callback):
            w_callback(self.api_tvdb.search(query, 'en'))

        Thread(target=work, args=(callback, )).start()
        print(self.download_manager.get_torrents())

    def search_episode(self, episode, callback):
        def work(w_callback):
            results = self.api_tpb.search(query).order(TPB_ORDERS.SEEDERS.DES)
            w_callback(results)

        query = '{} s{:02d}e{:02d}'.format(episode.season.show.SeriesName,
                                           episode.season.season_number,
                                           episode.EpisodeNumber)
        Thread(target=work, args=(callback, )).start()

    def download(self, torrent, completion_callback=None, play_callback=None):
        self.download_manager.add_magnet(torrent.magnet_link,
                                         completion_callback, play_callback)

    def open_player(self, torrent):
        def work(path):
            os.system(path)

        player_path = self.settings.get('player_path').format(
            video='"' + self.settings.get('save_path') +
            torrent.handler.name() + '"',
            subtitles='')
        t = Thread(target=work, args=(player_path, )).start()
        t.daemon = True
Пример #14
0
def melhor_torrent(nome_busca, qtd=None):
    from tpb import TPB
    from tpb import CATEGORIES, ORDERS

    t = TPB('https://thepiratebay.se')  # configurando o site do TPB
    # Buscando todos os tipos de Video
    if not qtd:
        search = t.search(nome_busca, category=CATEGORIES.VIDEO.ALL).order(
            ORDERS.SEEDERS.DES).page(0)
    else:
        search = t.search(nome_busca, category=CATEGORIES.VIDEO.ALL).order(
            ORDERS.SEEDERS.DES)

    torrents = []
    for torrent in search:
        torrents.append(torrent)

    try:
        if not qtd:
            return torrents[0].magnet_link
        else:
            return torrents[0:qtd]
    except IndexError:
        return None
Пример #15
0
class Pirate_API():
    '''
    This class allows my endpoints to interact with the database as well as retrieve
    information from ThePirateBay's database.
    '''
    def __init__(self):

        self.iAPI = ImageAPI()
        self.config = ConfigManager()
        self.website = TPB(
            "https://thepiratebay.monster/")  #Base URL for ThePirateBay

    def get_none(self) -> List[dict]:
        '''
        Returns an empty torrent object

        @returns -> None
        '''

        return [{"name": "", "magnet": "", "image": ""}]

    def get_torrents(self, req: str) -> List[dict]:
        '''
        Gets all torrents relative to the search query.

        @param {str} req: The search query to be made to ThePirateBay
        @returns {List[dict]} 3 top torrent results sorted by seeders.
        '''

        counter: int = 0
        obj: List[dict] = []

        button_id: str = "pirate_button_"
        button_count: int = 1

        for torrent in self.website.search(req).order(ORDERS.SEEDERS.DES):
            if counter <= 2:
                obj.append({
                    "name": torrent.title,
                    "magnet": torrent.magnet_link,
                    "image_url": self.iAPI.get_image(req),
                    "button_id": button_id + str(button_count),
                })
            counter += 1
            button_count += 1
        return obj
Пример #16
0
class TorrentFinder:
    '''A class which handles finding good torrents under given keyword.'''
    def __init__(self):
        self.tpb = TPB(THEPIRATEBAY)

    def find(self, keyword, filters=[], min_seeders=0, category=0):
        '''Finds torrents under given keyword which also pass specified
        filters.

        Returns:
            A list of found tpb.Torrent objects.
        '''
        search = self.tpb.search(keyword, category=category).multipage()
        good_torrents = []
        for torrent in search:
            if (torrent.seeders < min_seeders):
                break

            if all([filter_function(torrent) for filter_function in filters]):
                good_torrents.append(torrent)
        return good_torrents
Пример #17
0
class TorrentSearcher(object):

    def __init__(self):
        self._pirategateway = TPB('https://thepiratebay.org')

    def search_for_serie(self, name, season):
        chapters = {}
        for page in range(0, 10):
            torrents = self._pirategateway.search(name).order(ORDERS.SEEDERS.DES).page(page)
            for torrent in torrents:
                try:
                    file = str(torrent).lower()
                    seas = re.sub(r".*s([0-9]*)e[0-9]*.*", r"\1", file)
                    chapter = re.sub(r".*e([0-9][0-9]).*", r"\1", file)
                    if chapter == file or seas == file:
                        continue
                    if chapter != "" and seas != "" and int(seas) == season:
                        if not int(chapter) in chapters.keys():
                            chapters[int(chapter)] = torrent
                except:
                    continue
        return chapters
Пример #18
0
class TorrentSearcher(object):
    def __init__(self):
        self._pirategateway = TPB('https://thepiratebay.org')

    def search_for_serie(self, name, season):
        chapters = {}
        for page in range(0, 10):
            torrents = self._pirategateway.search(name).order(
                ORDERS.SEEDERS.DES).page(page)
            for torrent in torrents:
                try:
                    file = str(torrent).lower()
                    seas = re.sub(r".*s([0-9]*)e[0-9]*.*", r"\1", file)
                    chapter = re.sub(r".*e([0-9][0-9]).*", r"\1", file)
                    if chapter == file or seas == file:
                        continue
                    if chapter != "" and seas != "" and int(seas) == season:
                        if not int(chapter) in chapters.keys():
                            chapters[int(chapter)] = torrent
                except:
                    continue
        return chapters
Пример #19
0
    rt2 = []

    for i in formatted:
        rt.append([i[2].replace("\"",""),i[1].replace("\"","")])
    for i in rt:
        if not(i in rt2):
            rt2.append(i)

    return rt






t = TPB('https://thepiratebay.se')
print("----- MENU -----")
print("1: Search for Album")
print("2. Import CSV list")
menu = input('? ')
if menu == '1':
    searching = 1
    magnets = []
    while searching == 1 :
        search = input('Search for? ')
        s = t.search(search)
        sr = []


        #Rip torrent data
        for i in s:
Пример #20
0
class PirateBay(object):
    def __init__(self):
        self.t = TPB('https://thepiratebay.org')

    # This is the generic "Name S00E00" format seen on TPB
    def gen_query_generic(self, ep):
        return '%s S%02dE%02d' % (ep.show.name, ep.seasonid, ep.episodeid)

    # This format should help with episodes that don't really fall under S00E00
    def gen_query_simple(self, ep):
        return '%s %s' % (ep.show.name, ep.name)

    def find_episode(self, episode):
        item = None
        for gen in [self.gen_query_generic, self.gen_query_simple]:
            item = self.search(gen(episode),
                best_exts=config['torrents']['best_formats'],
                best_users=config['torrents']['best_users'],
                min_seeders=config['torrents']['min_seeders'],
                max_seeders=config['torrents']['max_seeders'])
            if item:
                return item
        return None

    def search(self, query, min_seeders=35, max_seeders=10000, best_users=[], best_exts=["mkv"]):
        """
        A pirate bay search function that takes a query, and trys to find
        an optimal torrent based on a few options. It implements a basic
        ranking algorithim to help decided which torrents are the bets, an
        allows format preference, seeder amount preference, and a list of
        preferred users.
        """
        log.info("Searching for %s" % query)
        s = self.t.search(query, category=CATEGORIES.VIDEO.TV_SHOWS)
        s.order(ORDERS.SEEDERS.DES)

        results = {}
        for item in s.page(1):
            log.debug("Valuating result %s" % item)
            rank = 0

            if item.seeders <= 0:
                continue

            if item.user.lower() in best_users:
                log.debug("\tIs ranked user!")
                rank += 1

            if min_seeders <= item.seeders <= max_seeders:
                log.debug("\tHas good amount of seeders")
                rank += 1

            for term in config['torrents']['terms']:
                if term in item.title:
                    log.debug("\tHas search term `%s`" % term)
                    rank += 1

            files = getValidFiles([k for k in item.files.keys()])

            if len(files) != 1:
                continue

            for f in files:
                if os.path.splitext(f)[-1][1:] in best_exts:
                    log.debug("\tFile has preferred format")
                    rank += 1

            results[item] = rank

        best = sorted(results.iteritems(), key=operator.itemgetter(1))
        if len(best):
            return best[-1][0]

        return None
Пример #21
0
	def __init__(self, domain):
		if domain != None:
			self.domain = domain
		else:
			self.domain = "https://thepiratebay.se"
		self.tpb = TPB(self.domain)
Пример #22
0
# -*- coding: utf-8 -*-
import imdb 
from tpb import TPB
from tpb import CATEGORIES, ORDERS
import sqlite3
import re
movies = []
ia = imdb.IMDb() 
t = TPB('http://thepiratebay.org') 
counter=0
for i in t.top().category(CATEGORIES.VIDEO.MOVIES):
    # Make TPB titles nice and searchable
    nicestring = re.split(r'\d{4}',i.title)[0][:-1].replace('.',' ')

    imdbmovie = ia.search_movie(nicestring)[0]
    ia.update(imdbmovie)

    movie_rating = "none"
    if  imdbmovie.has_key('rating'):
        movie_rating=imdbmovie['rating']

    movie_title = "unknown"
    if imdbmovie.has_key('long imdb canonical title'):
        movie_title=imdbmovie['long imdb canonical title'] 

    listing = dict(title=movie_title,rating=movie_rating,magnet=i.magnet_link,tpbtitle=i.title)
    print("updating db with: " +str(listing))
    movies.append(listing) 
    counter += 1
    print counter
Пример #23
0
 def __init__(self):
     self.tpb = TPB(THEPIRATEBAY)
Пример #24
0
from tpb import TPB
from tpb import CATEGORIES, ORDERS

t = TPB('https://thepiratebay.org') # create a TPB object with default domain

# search for 'public domain' in 'movies' category
search = t.search('public domain', category=CATEGORIES.VIDEO.MOVIES)

# return listings from page 2 of this search
search.page(2)

# sort this search by count of seeders, and return a multipage result
search.order(ORDERS.SEEDERS.ASC).multipage()

# search, order by seeders and return page 3 results
t.search('python').order(ORDERS.SEEDERS.ASC).page(3)

# multipage beginning on page 4
t.search('recipe book').page(4).multipage()

# search, in a category and return multipage results
t.search('something').category(CATEGORIES.OTHER.OTHER).multipage()

# get page 3 of recent torrents
t.recent().page(3)

# get top torrents in Movies category
t.top().category(CATEGORIES.VIDEO.MOVIES)

# print all torrent descriptions
for torrent in t.search('public domain'):
Пример #25
0
 def __init__(self):
     self.provider = TPB("https://thepiratebay.pe")
     self.MINIMUM_SEEDS = 5
Пример #26
0
from tpb import TPB
import os
# from tpb import CATEGORIES, ORDERS

startlink = raw_input("what is start of the link ?\n")
endlink = raw_input("\nwhat is the end of the link ?\n")

# startlink = 'Scorpion.S02E'
# endlink = '.HDTV.x264-LOL[ettv]'

print("\nprocessing...")

magnetList = []

for x in range(1, 20):
    t = TPB(
        'https://thepiratebay.se')  # create a TPB object with default domain

    s = startlink
    if (x < 10): s += "0"
    s += str(x) + endlink

    search = t.search(s)

    if (search.items() > 0):
        for t in search:
            print(t.title)
            magnetList.append(t.magnet_link)

print("done looping")
wannaDoThis = raw_input("Do you wish to download all of those ?")
if ('y' in wannaDoThis):
Пример #27
0
# Transmission
import transmissionrpc

# Post data
form = cgi.FieldStorage()

# Transmission
tc = transmissionrpc.Client(address="localhost", port=9091, user="******", password="******")

# Get search text
searchText = "" 
torrents = 0
totalTorrents = 0
if "searchText" in form:
    searchText = form["searchText"].value
    t = TPB('https://thepiratebay.se') # create a TPB object with default domain
    torrents = list(iter(t.search(searchText).category(CATEGORIES.AUDIO.MUSIC).order(ORDERS.SEEDERS.DES).items()))
    totalTorrents = len(torrents)

# Add torrent
torrentAdded = 0
torrentTitle = ""
if "download" and "magnetLink" in form:
    torrentAdded = 1
    torrentTitle = form["torrentTitle"].value
    tc.add_torrent(form["magnetLink"].value)

# Header
headerTemplate = Template(open("html/header.html", "r").read())
renderedHeader = headerTemplate.render().encode("utf-8").strip()
Пример #28
0
    def download(self,jsonep):
        t = TPB('https://thepiratebay.org')
        #search = t.search('Game Of Thrones s04e01', category=CATEGORIES.VIDEO)
        no_of_season=self.ses.get()
        if(int(no_of_season)<10):
            no_of_season='0'+no_of_season
        epno=self.ep.get()
        if(int(epno)<10):
            epno='0'+epno
            
        searchquery=self.title+' s'+no_of_season+'e'+epno
        print searchquery
        
      
        i=0
	try:
		for torrent in t.search(searchquery,category=CATEGORIES.VIDEO.TV_SHOWS):
		    nameoftorr=torrent.title
		    nameoftorr=nameoftorr.lower()
		    size=torrent.size
		    i=i+1
		    if(nameoftorr.find(searchquery.lower())):
		        link=torrent.magnet_link;
			
			webbrowser.open_new_tab(link)
			
		        try:
		            shortdescp=jsonep['episodes'][int(self.ep.get())-1]['overview']
		            #print jsonep['episodes'][int(self.ep.get())]['overview']
		            sdesc=StringVar()
		            sdesc.set('Short Description :')
		            label = Label( top, textvariable=sdesc,fg='#0e385f',bg='#D3D8E8')
		            label.place(x=50,y=375,width=300,height=30)

		            lengthofshort=len(shortdescp)
		            no=lengthofshort/75
		            temp2=0
		            temp3=0
		            for j in range(0,no+1) :
		                shortdesc=StringVar()
		                
		                temp=shortdescp.find(' ',(75*j)+75,(75*j)+90)
		                temp2=temp
		                temp=temp%75
		                stri=shortdescp[(75*j)+temp3:(75*j)+75+temp]
		                temp3=temp2%75
		                shortdesc.set(stri)
		                label = Label( top, textvariable=shortdesc,fg='#0e385f',bg='#D3D8E8')
		                if j!=no:
		                    label.place(x=50,y=(400+(30*j)),width=600,height=30)
		                else:
		                    t=j%8
		                    label.place(x=50,y=(400+(30*j)),width=600,height=30)
		                    label = Label( top, text='',fg='#0e385f',bg='#D3D8E8')
		                    label.place(x=50,y=(400+(30*(j+1))),width=600,height=30*t)
		        except(Exception):
		            print "Error";
		        break;
		    if(i>10):
		        tkMessageBox.showerror(title='Not Available',message='Torrent File not available on PirateBay')
		        break;
		    
		if(i==0):
		    tkMessageBox.showerror(title='Not Available',message='Torrent File not available on PirateBay')
	except Exception:
		print "Net connection not established or Pirate Bay Blocked"	
Пример #29
0
#!/usr/bin/env python
from tpb import TPB
recherche = raw_input('Que voulez vous rechercher ? :')
t = TPB('https://thepiratebay.org')
results = t.search(recherche, category=0)

for r in results:
	print '*' * 50
	r.print_torrent()
	print '\n'


Пример #30
0
#!/usr/bin/env python

from tpb import TPB

t = TPB()

# when using a proxy site
# t = TPB(domain='http://uberproxy.net/thepiratebay.sx')

for to in t.get_recent_torrents():
    print '*' * 50
    to.print_torrent()
    print '\n'
"""
# search for programming ebooks
results = t.search('hello world', category=601)

for r in results:
    print '*' * 50
    r.print_torrent()
    print '\n'
"""
Пример #31
0
        quality = form["quality"].value

    # Torrent result defaults
    torrents = 0
    totalTorrents = 0

    # Get search text and perform search
    searchText = "*" 
    if "searchText" in form:
        searchText = form["searchText"].value

    category = CATEGORIES.VIDEO.HD_MOVIES
    if quality == 'sd':
        category = CATEGORIES.VIDEO.MOVIES

    t = TPB('https://thepiratebay.se') # create a TPB object with default domain
    torrents = list(iter(t.search(searchText).category(category).order(ORDERS.SEEDERS.DES).items()))
    totalTorrents = len(torrents)

    # Add torrent
    torrentAdded = 0
    torrentTitle = ""
    if "download" and "magnetLink" in form:
        # Clear form
        searchText = ""
        quality = "hd"
        # Add torrent    
        torrentAdded = 1
        torrentTitle = form["torrentTitle"].value
        tc.add_torrent(form["magnetLink"].value)
Пример #32
0
from bs4 import BeautifulSoup
from tpb import TPB, CATEGORIES, ORDERS
from first import first
from docopt import docopt
from itertools import islice
import requests, os.path, os, webbrowser


t = TPB('https://thepiratebay.org') # create a TPB object with default domain


doc = '''
Usage:
  best_new_albums.py [ -a <num_torrents> ]

Options:
  -a                Automatically download the last <num_torrents> torrents.
'''

def get_bnm():

    i = 1
    while True:
        page = requests.get('http://pitchfork.com/reviews/best/albums/' + str(i))
        html = page.text

        soup = BeautifulSoup(html, 'html5lib')
        reviews = soup.find(id='main')
        info = reviews.find_all(class_='info')

        for item in info:
Пример #33
0
 def __init__(self):
     self._pirategateway = TPB('https://thepiratebay.org')
Пример #34
0
#!/usr/bin/env python

from tpb import TPB

t = TPB()

# when using a proxy site
# t = TPB('http://uberproxy.net/thepiratebay.sx')


for to in t.get_recent_torrents():
    print('*' * 50)
    to.print_torrent()
    print('\n')
"""
# search for programming ebooks
results = t.search('hello world', category=601)

for r in results:
    print '*' * 50
    r.print_torrent()
    print '\n'
"""
Пример #35
0
# -*- coding: utf-8 -*-
# <nbformat>3.0</nbformat>

# <headingcell level=1>

# The Pirate Bay

# <codecell>

from tpb import TPB
from tpb import CATEGORIES, ORDERS

# <codecell>

t = TPB('https://thepriatebay.sx')

# <codecell>

search = t.search('homeland', category=CATEGORIES.VIDEO.MOVIES)

# <codecell>

pagSea = search.page(0).multipage()

for pag in pagSea:
    print pag

# <codecell>

t.top().category(CATEGORIES.VIDEO.MOVIES)
Пример #36
0
# Very simple RESTful interface to TPB
# Uses:
#   * https://github.com/karan/TPB
#   * http://flask-restful.readthedocs.org/en/latest

from flask import Flask
from flask.ext.restful import abort, Api, Resource
from tpb import TPB
from tpb import CATEGORIES, ORDERS

tpburl = 'https://thepiratebay.se'

app = Flask(__name__)
api = Api(app)

t = TPB(tpburl)

# main subject and default value
constants = {
    'cat': [CATEGORIES, CATEGORIES.ALL],
    'order': [ORDERS, ORDERS.SEEDERS.DES]
}


def abort_on_mistake(var, filtr):
    try:
        if not ':' in filtr:
            # return default value
            return constants[var][1]
        k, v = filtr.split(':')
        return getattr(getattr(constants[var][0], k.upper()), v.upper())
Пример #37
0
from tpb import TPB
from tpb import CATEGORIES, ORDERS

t = TPB('https://thepiratebay.org')  # create a TPB object with default domain

# search for 'public domain' in 'movies' category
search = t.search('public domain', category=CATEGORIES.VIDEO.MOVIES)

# return listings from page 2 of this search
search.page(2)

# sort this search by count of seeders, and return a multipage result
search.order(ORDERS.SEEDERS.ASC).multipage()

# search, order by seeders and return page 3 results
t.search('python').order(ORDERS.SEEDERS.ASC).page(3)

# multipage beginning on page 4
t.search('recipe book').page(4).multipage()

# search, in a category and return multipage results
t.search('something').category(CATEGORIES.OTHER.OTHER).multipage()

# get page 3 of recent torrents
t.recent().page(3)

# get top torrents in Movies category
t.top().category(CATEGORIES.VIDEO.MOVIES)

# print all torrent descriptions
for torrent in t.search('public domain'):
Пример #38
0
#!/usr/bin/env python
#-*- coding: utf-8 -*-
#title :news_pb.py
#description :get last torrents from ThePirateBay or do a research.
#author :[email protected]
#date :20130902
#version :0.1
#usage :python news_pb.py
#notes :I love Hyena...beautiful creature.

from tpb import TPB
#t = TPB()

# when using a proxy site
t = TPB('https://thepiratebay.org')

print '*' * 50
print '1) Voir les torrents récents'
print '2) Faire une recherche de torrent'
print '*' * 50
question_1 = raw_input('Taper le chiffre qui correspond (1 ou 2) : ')
print '*' * 50


if question_1 == '1':
	for tr in t.recent():
		print '*' * 50
		tr.print_torrent()
		print '\n'
else:
	recherche = raw_input('Que voulez vous rechercher ? :')
Пример #39
0
 def __init__(self):
     self.t = TPB('https://thepiratebay.org')
Пример #40
0
    def __init__(self):

        self.iAPI = ImageAPI()
        self.website = TPB(
            "https://thepiratebay.org/")  #Base URL for ThePirateBay
Пример #41
0
from urlparse import urlparse
import json
import threading
import urllib

from models import ComplexEncoder, Torrent, dict_to_download_status, dict_to_torrent
from database import Database
from torrent_client import TorrentClient
from tpb import TPB

t = TPB('https://thepiratebay.org')  # create a TPB object with default domain
client = TorrentClient('Downloads')

database = Database()


def search(handler):
    query = query_from_path(handler.path)
    if 'query' not in query:
        handler.send_error(400)
        handler.wfile.write(json.dumps({'error': "'query' is required."}))
        return
    s = t.search(urllib.unquote(query['query']))
    items = []
    for item in s.items():
        torrent = Torrent(item.title, item.size, item.seeders, item.id,
                          item.category, item.sub_category, item.magnet_link)
        database.set(item.id, torrent.reprDB())
        items.append(torrent)
    handler.wfile.write(json.dumps(items, cls=ComplexEncoder))
    return
Пример #42
0
import sys
import re
from tpb import TPB
from tpb import CATEGORIES, ORDERS

seeking = sys.argv[1]
minSize = sys.argv[2]
scale = sys.argv[3]

if scale == 'G': scale = "GiB"
elif scale == 'M': scale = "MiB"
else: exit(1)

t = TPB('https://thepiratebay.org')
result = t.search(seeking).order(ORDERS.SEEDERS.DES).page(1)

files = []
for torrent in result: 
	match = re.match(r'.*Size ([\d\.]*?)\s(\w\w\w).*', torrent.description.text)
	if match:
		files.append({'size': match.group(1), 'scale': match.group(2), 'url':torrent.magnet_link, 'title':torrent.title})


files = filter(lambda e: e['scale'] == scale and e['size'] >= minSize, files)

for file in files: 
	print(file['title'], file['size']+file['scale'], file['url'])
	print("")

Пример #43
0
    def __init__(self):

        self.iAPI = ImageAPI()
        self.config = ConfigManager()
        self.website = TPB(
            "https://thepiratebay.monster/")  #Base URL for ThePirateBay
Пример #44
0
import curses
import subprocess, os
from tpb import TPB
from tpb import CATEGORIES, ORDERS
import simplefm

t = TPB('https://thepiratebay.org')


def searchTor(keyword):
    lista = []
    for i, tor in enumerate(t.search(keyword)):
        lista.append({'selected': True if i == 0 else False, 'torrent': tor})
    return lista


def print_list(stdscr, lista):
    for i, v in enumerate(lista):
        stdscr.addstr(
            i + 1, 0,
            ('*' if v['selected'] else 'o') + ' -- ' + v['torrent'].title,
            curses.color_pair(1) if v['selected'] else curses.color_pair(0))


def print_search(win, keyword, mode):
    height, width = win.getmaxyx()

    if mode == 0:
        win.attron(curses.color_pair(2))
        win.addstr(0, len(keyword), " " * (width - len(keyword)))
Пример #45
0
from tpb import TPB
from tpb import CATEGORIES, ORDERS

t = TPB('https://thepiratebay.org') # create a TPB object with default domain

search = t.search('public domain', category=CATEGORIES.VIDEO.MOVIES)
Пример #46
0
class Search(object):
	def __init__(self, domain):
		if domain != None:
			self.domain = domain
		else:
			self.domain = "https://thepiratebay.se"
		self.tpb = TPB(self.domain)

	def list_categories(self):
		print """List of category codes:
ALL - 0
AUDIO:
	All - 100
	Music - 101
	Audio books - 102
	Sound clips - 103
	Flac - 104
	Other - 199
VIDEO:
	All - 200
	Movies - 201
	Movies DVDR - 202
	Music videos - 203
	Movie clips - 204
	TV shows - 205
	Handheld - 206
	HD movies - 207
	HD TV shows - 208
	3D - 209
	Other - 299
APPLICATIONS:
	All - 300
	Windows - 301
	Mac - 302
	Unix - 303
	Handheld - 304
	iOS - 305
	Android - 306
	Other - 399
GAMES:
	All - 400
	PC - 401
	Mac - 402
	PSX - 403
	Xbox 360 - 404
	Wii - 405
	Handheld - 406
	iOS - 407
	Android - 408
	Other - 499
P**N:
	All - 500
	Movies - 501
	Movies DVDR - 502
	Pictures - 503
	Games - 504
	HD Movies - 505
	Movie clips - 506
	Other - 599
OTHER:
	E-books - 601
	Comics - 602
	Pictures - 603
	Covers - 604
	Physibles - 605
	Other - 699
"""
		sys.exit(0)

	def list_orders(self):
		print """List of sorting codes:
NAME:
    Descending = 1
    Ascending = 2

UPLOADED:
    Descending = 3
    Ascending = 4

SIZE:
    Descending = 5
    Ascending = 6

SEEDERS:
    Descending = 7
    Ascending = 8

LEECHERS:
    Descending = 9
    Ascending = 10

UPLOADER:
    Descending = 11
    Ascending = 12

TYPE:
    Descending = 13
    Ascending = 14

			  """
		sys.exit(0)


	def search(self, category_number=0, query='', order_number=1, limit=0):
		self.query = query
		self.limit = limit
		self.categories = {  
			0   : CATEGORIES.ALL,
			100 : CATEGORIES.AUDIO.ALL,
			101 : CATEGORIES.AUDIO.MUSIC,
			102 : CATEGORIES.AUDIO.AUDIO_BOOKS,
			103 : CATEGORIES.AUDIO.SOUND_CLIPS,
			104 : CATEGORIES.AUDIO.FLAC,
			199 : CATEGORIES.AUDIO.OTHER,
			200 : CATEGORIES.VIDEO.ALL,
			201 : CATEGORIES.VIDEO.MOVIES,
			202 : CATEGORIES.VIDEO.MOVIES_DVDR,
			203 : CATEGORIES.VIDEO.MUSIC_VIDEOS,
			204 : CATEGORIES.VIDEO.MOVIE_CLIPS,
			205 : CATEGORIES.VIDEO.TV_SHOWS,
			206 : CATEGORIES.VIDEO.HANDHELD,
			207 : CATEGORIES.VIDEO.HD_MOVIES,
			208 : CATEGORIES.VIDEO.HD_TV_SHOWS,
			209 : CATEGORIES.VIDEO.THREE_DIMENSIONS,
			299 : CATEGORIES.VIDEO.OTHER,
			300 : CATEGORIES.APPLICATIONS.ALL,
			301 : CATEGORIES.APPLICATIONS.WINDOWS,
			302 : CATEGORIES.APPLICATIONS.MAC,
			303 : CATEGORIES.APPLICATIONS.UNIX,
			304 : CATEGORIES.APPLICATIONS.HANDHELD,
			305 : CATEGORIES.APPLICATIONS.IOS,
			306 : CATEGORIES.APPLICATIONS.ANDROID,
			399 : CATEGORIES.APPLICATIONS.OTHER,
			400 : CATEGORIES.GAMES.ALL,
			401 : CATEGORIES.GAMES.PC,
			402 : CATEGORIES.GAMES.MAC,
			403 : CATEGORIES.GAMES.PSX,
			404 : CATEGORIES.GAMES.XBOX360,
			405 : CATEGORIES.GAMES.WII,
			406 : CATEGORIES.GAMES.HANDHELD,
			407 : CATEGORIES.GAMES.IOS,
			408 : CATEGORIES.GAMES.ANDROID,
			499 : CATEGORIES.GAMES.OTHER,
			#FIXME: Getting bug when trying to include these entries
			#FIX: pip install --upgrade git+https://github.com/karan/TPB.git
			500 : CATEGORIES.P**N.ALL,
			501 : CATEGORIES.P**N.MOVIES,
			502 : CATEGORIES.P**N.MOVIES_DVDR,
			503 : CATEGORIES.P**N.PICTURES,
			504 : CATEGORIES.P**N.GAMES,
			505 : CATEGORIES.P**N.HD_MOVIES,
			506 : CATEGORIES.P**N.MOVIE_CLIPS,
			599 : CATEGORIES.P**N.OTHER,
			601 : CATEGORIES.OTHER.EBOOKS,
			602 : CATEGORIES.OTHER.COMICS,
			603 : CATEGORIES.OTHER.PICTURES,
			604 : CATEGORIES.OTHER.COVERS,
			605 : CATEGORIES.OTHER.PHYSIBLES,
			699 : CATEGORIES.OTHER.OTHER 
			}

		self.orders = {
			1  : ORDERS.NAME.DES,
			2  : ORDERS.NAME.ASC,
			3  : ORDERS.UPLOADED.DES,
			4  : ORDERS.UPLOADED.ASC,
			5  : ORDERS.SIZE.DES,
			6  : ORDERS.SIZE.ASC,
			7  : ORDERS.SEEDERS.DES,
			8  : ORDERS.SEEDERS.ASC,
			9  : ORDERS.LEECHERS.DES,
			10 : ORDERS.LEECHERS.ASC,
			11 : ORDERS.UPLOADER.DES,
			12 : ORDERS.UPLOADER.ASC,
			13 : ORDERS.TYPE.DES,
			15 : ORDERS.TYPE.ASC
			}

		try:
			self.category = self.categories[category_number]
		except KeyError:
			print "Provide correct category code."
			sys.exit(2)
	
		try:
			self.order = self.orders[order_number]
		except KeyError:
			print "Provide correct sorting code."
			sys.exit(3)

		if self.limit == 0:
			for torrent in self.tpb.search(self.query, category=self.category).order(self.order):
				print torrent.title, " - ", torrent.user
				print "Seeders: ", torrent.seeders
				print "Leechers: ", torrent.leechers
				print torrent.magnet_link, "\n"
		sys.exit(0)
Пример #47
0
    airedEpisodes = getAiredEpisodesTMDB(show)
    print "Getting diff episodes for show: {}".format(show.title)
    diffEpi = diffEpisodes(show, airedEpisodes, watchedEpisodes)

    if bool(diffEpi):
        # if there is diff - scan all present downloaded files (prevent duplicates)
        presentEpisodes = scanPresentFiles(BASE_URL, ttv.slugify(show.title))
        # get new diff of old_diff and that present files that on your computer
        diffPresent = diffEpisodes(show, diffEpi, presentEpisodes)
        if bool(diffPresent):
            # if there are files to download that you havn't already downloaded - add to download dict
            print "\t\tAdding show {} to dict".format(show.title)
            EpisodesToDownload[show.title] = diffPresent

# Start of TBP API
t = TPB("http://thepiratebay.org")

# list of valid publishers - don't want any torrent from anyone..
validPublishers = [
    'ettv', 'LOL', 'FUM', 'DIMENSION', 'KILLERS', 'FLEET', 'AFG'
]

print
print "I'm going to download the following shows and episodes:"

# go over all the "to download" shows
for _show, season in EpisodesToDownload.items():
    print _show,
    for entry in season.values():
        s = "0" + str(entry.season) if len(str(entry.season)) == 1 else str(
            entry.season)
Пример #48
0
from tpb import TPB
from tpb import CATEGORIES, ORDERS

t = TPB('https://thepiratebay.org')  # create a TPB object with default domain

# # search for 'public domain' in 'movies' category
# search = t.search('public domain', category=CATEGORIES.VIDEO.MOVIES)

# # return listings from page 2 of this search
# search.page(2)

# # sort this search by count of seeders, and return a multipage result
# search.order(ORDERS.SEEDERS.ASC).multipage()

# # search, order by seeders and return page 3 results
# t.search('python').order(ORDERS.SEEDERS.ASC).page(3)

# # multipage beginning on page 4
# t.search('recipe book').page(4).multipage()

# # search, in a category and return multipage results
# t.search('something').category(CATEGORIES.OTHER.OTHER).multipage()

# # get page 3 of recent torrents
# t.recent().page(3)

# get top torrents in Movies category
t.top().category(CATEGORIES.VIDEO.HD_MOVIES)

# print all torrent descriptions
for torrent in t.search('public domain'):
Пример #49
0
 def __init__(self):
     self._pirategateway = TPB('https://thepiratebay.org')