コード例 #1
0
def search_movie(request):
    if request.method == 'GET':
        form = FilmSearchForm()
        return render(request, 'save_search.html', {'form': form})
    elif request.method == 'POST':
        form = FilmSearchForm(request.POST)
        if form.is_valid():
            tmdb = TMDb()
            tmdb.api_key = os.environ['KEY-MDB']
            movie = Movie()
            query = request.POST.get('query', 'Marlina')
            search = movie.search(query)

            db, token, uid = initializationDb()
            for p in search:
                data = {
                    "id": p.id,
                    "title": p.title,
                    "overview": p.overview,
                    "poster_path": p.poster_path,
                    "release_date": p.release_date,
                    "popularity": p.popularity,
                    "original_title": p.original_title,
                    "vote_count": p.vote_count,
                    "vote_average": p.vote_average
                }
                db.child(uid).child("movie_list").child(p.id).set(data, token)
            response = {"status": 200, "message": "Success Save"}
            return JsonResponse(response)
        else:
            response = {"status": 401, "message": "Invalid Input"}
            return JsonResponse(response)
コード例 #2
0
def search_movie(query):
    tmdb = TMDb()
    tmdb.api_key = 'PLEASE GENERATE UR OWN API KEY, ALL INFO IN README FILE'
    movie = Movie()

    result = movie.search(query)
    number_of_movies = len(result)

    if number_of_movies == 0:
        print("SORRY, I CAN'T FIND ANYTHING, PLEASE TRY ANOTHER PHRASE")
    else:
        random_movie_title = choice(result).title
        print(
            f'I have found {number_of_movies} movies, here is a random choice for you:'
        )
        print(f'Title: {random_movie_title}')
        for res in result:
            if res.title == random_movie_title:
                if res.overview == "":
                    print('Sorry, no plot available :c')
                else:
                    print(f'Movie id: {res.id}')
                    print(f'Plot: {res.overview}')
                    print(f'Released in {res.release_date}')

                    similar = movie.similar(res.id)
                    for sim in similar:
                        print(
                            f'Similar movie: {sim} (movie id: {sim.id}), released in {sim.release_date}'
                        )
                        break
                break
コード例 #3
0
ファイル: db.py プロジェクト: andresryes/love-my-movies
    def getMovies(self):
        tmdb = TMDb()
        tmdb.api_key = '1dc5bcb73c0781470cb348d5e02a05a5'
        tmdb.language = 'en'
        tmdb.debug = False

        movie = Movie()
        self.movie = movie
        self.popular = movie.popular()
        self.now = movie.now_playing()
        self.top = movie.top_rated()

        discover = Discover()
        self.movie_discovered = discover.discover_movies(
            {'sort_by': 'vote_average.desc'})

        lists = [self.top, self.now, self.popular, self.movie_discovered]
        self.all_movies = []

        for li in lists:
            for m in li:
                exist = False
                for r in self.all_movies:
                    if r.id == m.id:
                        exist = True
                if (not exist):
                    self.all_movies.append(m)
コード例 #4
0
ファイル: views.py プロジェクト: dan1keen/djangoMovies
def single_page(request, movie_id):
    conn = http.client.HTTPSConnection("api.themoviedb.org")
    tmdb3 = TMDb()
    tmdb3.api_key = 'bf4a7e22bb42072d024a9c1b6f88597f'
    movie = Movie()
    details = movie.details(movie_id)
    credits = movie.credits(movie_id)

    conn.request(
        "GET",
        "/3/movie/" + str(movie_id) + "/translations?api_key=" + tmdb3.api_key)
    res = conn.getresponse()
    data = res.read()
    json_data = json.loads(data)
    translations = json_data['translations']
    rus = []
    for indx in range(0, 10):
        if translations[indx]['iso_639_1'] == 'ru':
            rus = translations[indx]

    context = {
        'details': details,
        'credits': credits,
        "rus": rus,
    }

    return render(request, "kinopoiskapi/single.html", context)
コード例 #5
0
 def __init__(self):
     # key = self.load_api_key()
     tmdb = TMDb()
     tmdb.api_key = '76796d972576af7067d952e53839883b'
     tmdb.language = 'en'
     tmdb.debug = True
     self.tmdb = tmdb
コード例 #6
0
    def add_poster(self, movie_title):
        import requests
        from PyQt5.QtGui import QIcon, QPixmap
        from tmdbv3api import TMDb
        from tmdbv3api import Movie
        tmdb = TMDb()
        tmdb.api_key = '1437062848d1dda19bd3907cf120e9f4'
        tmdb.language = 'en'
        #tmdb.debug = True
        movie = Movie()
        m = movie.search(movie_title)
        for i in m:
            continue_path = i.poster_path
            if continue_path != "None":
                continue_path = i.poster_path
                #print(continue_path)
                break

        url = 'http://image.tmdb.org/t/p/w185'
        combine = url + continue_path
        #readlink
        href = combine
        r = requests.get(href, stream=True)

        pixmap = QPixmap()
        pixmap.loadFromData(r.content)

        self.poster.setPixmap(pixmap)
        self.poster.setScaledContents(True)  #fullsizepic
        self.poster.show()
コード例 #7
0
def popular_movie(request):
    if request.method == 'GET':
        return render(request, 'search_popular.html')
    elif request.method == 'POST':
        tmdb = TMDb()
        tmdb.api_key = os.environ['KEY-MDB']
        movie = Movie()
        popular = movie.popular()

        db, token, uid = initializationDb()
        db.child("movie_popular").remove(token)
        for p in popular:
            data = {
                "id": p.id,
                "title": p.title,
                "overview": p.overview,
                "poster_path": p.poster_path,
                "release_date": p.release_date,
                "popularity": p.popularity,
                "original_title": p.original_title,
                "vote_count": p.vote_count,
                "vote_average": p.vote_average
            }
            db.child(uid).child("movie_popular").child(p.id).set(data, token)
        response = {"status": 200, "message": "Success Save"}
        return JsonResponse(response)
コード例 #8
0
    def discoverMedia(self, start_date, end_date):
        sd_str = datetime.strftime(start_date, '%Y-%m-%d')
        ed_str = datetime.strftime(end_date, '%Y-%m-%d')
        tmdb = TMDb()
        tmdb.api_key = tmdb_key
        tmdb.language = 'en'

        discover = Discover()
        movies = discover.discover_movies({
            'primary_release_date.gte': sd_str,
            'primary_release_date.lte': ed_str
        })

        for res in movies:
            try:
                Media.objects.get(external_id=res.id)
                continue
            except Media.DoesNotExist as ex:
                if res.release_date == '':
                    res.release_date = None
                if res.poster_path == None:
                    poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
                else:
                    poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
                Media.objects.create(
                    title = res.title,
                    description = res.overview,
                    poster_url = poster,
                    release_date = res.release_date,
                    media_type= "Movie",
                    external_id= res.id
                )

        
        series = discover.discover_tv_shows({
            'first_air_date.gte': sd_str,
            'first_air_date.lte': ed_str
        })

        for res in series:
            if res.first_air_date == '':
                    res.first_air_date = None
            if res.poster_path == None:
                poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
            else:
                poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
            try:
                Media.objects.get(external_id=res.id)
                continue
            except Media.DoesNotExist as ex:
                Media.objects.create(
                    title = res.name,
                    description = res.overview,
                    poster_url = poster,
                    release_date = res.first_air_date,
                    media_type= "TV",
                    external_id= res.id
                )
コード例 #9
0
ファイル: db.py プロジェクト: Danisnowman/love-my-movies
    def start(self):
        movie = Movie()
        if self.enviroment == "development":
            self.enviroment="localhost"
        else:
            self.enviroment="docker_redis"

        self.redis_server = redis.StrictRedis(host=self.enviroment, port=6379, db=0)
        tmdb = TMDb()
        tmdb.api_key = self.api_key
        self.getPopular(movie)
コード例 #10
0
    def query_api(self, name):
        tmdb = TMDb()
        tmdb.api_key = tmdb_key
        tmdb.language = 'en'

        #search movies
        movie = Movie()
        search_movie = movie.search(name)
        
        for res in search_movie:
            try:
                Media.objects.get(external_id=res.id)
                continue
            except Media.DoesNotExist as ex:
                if res.release_date == '':
                    res.release_date = None
                if res.poster_path == None:
                    poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
                else:
                    poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
                Media.objects.create(
                    title = res.title,
                    description = res.overview,
                    poster_url = poster,
                    release_date = res.release_date,
                    media_type= "Movie",
                    external_id= res.id
                )


        #search TV
        tv = TV()
        search_tv = tv.search(name)

        for res in search_tv:
            if res.first_air_date == '':
                    res.first_air_date = None
            if res.poster_path == None:
                poster = "https://lascrucesfilmfest.com/wp-content/uploads/2018/01/no-poster-available-737x1024.jpg"
            else:
                poster = "https://www.themoviedb.org/t/p/w600_and_h900_bestv2" + res.poster_path
            try:
                Media.objects.get(external_id=res.id)
                continue
            except Media.DoesNotExist as ex:
                Media.objects.create(
                    title = res.name,
                    description = res.overview,
                    poster_url = poster,
                    release_date = res.first_air_date,
                    media_type= "TV",
                    external_id= res.id
                )
コード例 #11
0
def imdb_get_movies(config_path, plex, data):
    title_ids = data[1]
    print("| {} Movies found on IMDb".format(len(title_ids)))
    tmdb = TMDb()
    tmdb.api_key = config_tools.TMDB(config_path).apikey
    movie = Movie()
    imdb_map = {}
    matched_imdb_movies = []
    missing_imdb_movies = []
    current_length = 0
    current_count = 0
    plex_tools.create_cache(config_path)
    plex_movies = plex.Library.all()
    for m in plex_movies:
        current_count += 1
        print_display = "| Processing: {}/{} {}".format(current_count, len(plex_movies), m.title)
        print(adjust_space(current_length, print_display), end="\r")
        current_length = len(print_display)
        if 'plex://' in m.guid:
            item = m
            # Check cache for imdb_id
            imdb_id = plex_tools.query_cache(config_path, item.guid, 'imdb_id')
            if not imdb_id:
                imdb_id, tmdb_id = plex_tools.alt_id_lookup(plex, item)
                print(adjust_space(current_length, "| Cache | + | {} | {} | {} | {}".format(item.guid, imdb_id, tmdb_id, item.title)))
                plex_tools.update_cache(config_path, item.guid, imdb_id=imdb_id, tmdb_id=tmdb_id)
        elif 'themoviedb://' in m.guid:
            if not tmdb.api_key == "None":
                tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
                tmdbapi = movie.details(tmdb_id)
                imdb_id = tmdbapi.imdb_id if hasattr(tmdbapi, 'imdb_id') else None
            else:
                imdb_id = None
        elif 'imdb://' in m.guid:
            imdb_id = m.guid.split('imdb://')[1].split('?')[0]
        else:
            imdb_id = None

        if imdb_id and imdb_id in title_ids:
            imdb_map[imdb_id] = m
        else:
            imdb_map[m.ratingKey] = m

    print(adjust_space(current_length, "| Processed {} Movies".format(len(plex_movies))))

    for imdb_id in title_ids:
        movie = imdb_map.pop(imdb_id, None)
        if movie:
            matched_imdb_movies.append(plex.Server.fetchItem(movie.ratingKey))
        else:
            missing_imdb_movies.append(imdb_id)

    return matched_imdb_movies, missing_imdb_movies
コード例 #12
0
ファイル: views.py プロジェクト: dan1keen/djangoMovies
def index(request):
    tmdb3 = TMDb()
    tmdb3.api_key = 'bf4a7e22bb42072d024a9c1b6f88597f'

    movie = Movie()
    popular = movie.popular()
    for p in popular:
        print(p.title)
        print(p.poster_path)
        print("===================BREAKLINE=====================")

    context = {'popular': popular}
    return render(request, "kinopoiskapi/kinopoisk.html", context)
コード例 #13
0
def initTmdb(api_key):
    """ Returns a TMDB object initialized with the given api key

    Args:
    api_key (str) : TMDB api key

    Returns:
    tmdb : TMDB object
    """
    tmdb = TMDb()
    tmdb.api_key = api_key
    tmdb.language = 'en'
    return tmdb
コード例 #14
0
ファイル: views.py プロジェクト: chooolie/FinalYearProject
def ViewGroup(request, pk):
    #When a groups is clicked on - all the details
    #pk is group id
    #Recommender is in group_recommender.py
    template_name = 'movies/group_details.html'
    tmdb = TMDb()
    tmdb.api_key = '69c1026aa20e6449c7a0f74f69dffd7d'
    tmdb.language = 'en'
    people = GroupUsers.objects.filter(group_id=pk)
    group_name = GroupInfo.objects.filter(group_id=pk)
    group_movies = GroupMovieList.objects.filter(group_id=pk)
    m = []
    vote_score = []
    test = []
    #Getting movies for watch list
    for movie in group_movies:
        vote_score.append(movie.vote)
        my_movies = Movie.objects.filter(movie_id=movie.movie_id)
        for mov in my_movies:
            tmdbId = mov.tmdbId
        movs = tmdb_movie()
        m.append(movs.details(tmdbId))
        #Appending the vote count to the TMDB api link of top movies
    for index, i in enumerate(m):
        test.append((i, vote_score[index]))

    #Getting recommendations for group
    merging = []
    for user in people:
        u_id = user.user_id
        user_info = UserProfile.objects.filter(id=u_id)
        for users in user_info:
            user_age = users.Age
            user_occupation = users.Occupation
        rec_movs = group_rec(user_age, user_occupation)
        rec_movs = rec_movs.index.values.tolist()
        merging.extend(rec_movs)
    all_mov = [word for word, word_count in Counter(merging).most_common(10)]
    id = pk

    args = {
        'id': id,
        'test': test,
        'people': people,
        'group_name': group_name,
        'group_movies': group_movies,
        'm': m,
        'merging': merging,
        'all_mov': all_mov
    }
    return render(request, template_name, args)
コード例 #15
0
ファイル: views.py プロジェクト: chooolie/FinalYearProject
def Top10(request):
    #Display top 10 rated movies
    template_name = 'movies/movie_list.html'
    top_movies = TopMovies.objects.all()
    tmdb = TMDb()
    tmdb.api_key = '69c1026aa20e6449c7a0f74f69dffd7d'
    tmdb.language = 'en'
    movie = tmdb_movie()

    m = []
    for mov in top_movies:
        m.append(movie.details(mov.tmdbId))

    args = {'top_movies': top_movies, 'm': m}
    return render(request, template_name, args)
コード例 #16
0
def IMDBtoTMDB(args):
    if args.tmdb != "AUTO-DETECT":
        return
    format = ""
    movie = Movie()
    tv = TV()
    tmdb = TMDb()
    tmdb.api_key = args.tmdbapi
    if (args.type == "TV"):
        format = 'tv_results'
    if (args.type == "Movie"):
        format = 'movie_results'
    tmdb = movie.external(f"{args.imdb}", f'imdb_id')
    if len(tmdb.get(format)) != 0:
        args.tmdb = tmdb.get(format)[0].get("id", "")
コード例 #17
0
ファイル: tmdb.py プロジェクト: LowerDeez/movies_finder
 def __init__(self, language: str):
     self.tmdb = TMDb()
     self.tmdb.api_key = config.MOVIE_DB_API_KEY  # '26e13c6a960c2e640f5e1867b9c52a46'
     self.tmdb.language = language or settings.LANGUAGE_CODE
     self.movie = Movie()
     self.discover = Discover()
     self.genre = Genre()
コード例 #18
0
 def __init__(self):
     self.tmdb = TMDb()
     self.tmdb.api_key = "e00b72174e4ae097af808f34a8f220fc"
     self.tv = TV()
     self.season = Season()
     self.movie = Movie()
     self.discover = Discover()
コード例 #19
0
    def __init__(self, bot):
        self.bot = bot
        config = configparser.ConfigParser()
        config.read('../auth.ini')

        self.tmdb = TMDb()
        self.tmdb.api_key = config.get('TMDB', 'api_key')
コード例 #20
0
    def __init__(self, api_key: str, language: str = 'en'):
        self.tmbd = TMDb()
        self.tmbd.api_key = api_key
        self.tmbd.language = language

        self.__tv = QueryTV(TV())
        self.__movie = QueryMovie(Movie())
コード例 #21
0
def imdb_get_movies(config_path, plex, data):
    tmdb = TMDb()
    movie = Movie()
    tmdb.api_key = config_tools.TMDB(config_path).apikey
    imdb_url = data
    if imdb_url[-1:] == " ":
        imdb_url = imdb_url[:-1]
    imdb_map = {}
    library_language = plex.Library.language
    try:
        r = requests.get(imdb_url,
                         headers={'Accept-Language': library_language})
    except requests.exceptions.MissingSchema:
        return
    tree = html.fromstring(r.content)
    title_ids = tree.xpath("//div[contains(@class, 'lister-item-image')]"
                           "//a/img//@data-tconst")
    if title_ids:
        for m in plex.Library.all():
            if 'themoviedb://' in m.guid:
                if not tmdb.api_key == "None":
                    tmdb_id = m.guid.split('themoviedb://')[1].split('?')[0]
                    tmdbapi = movie.details(tmdb_id)
                    imdb_id = tmdbapi.imdb_id
                else:
                    imdb_id = None
            elif 'imdb://' in m.guid:
                imdb_id = m.guid.split('imdb://')[1].split('?')[0]
            else:
                imdb_id = None

            if imdb_id and imdb_id in title_ids:
                imdb_map[imdb_id] = m
            else:
                imdb_map[m.ratingKey] = m

        matched_imbd_movies = []
        missing_imdb_movies = []
        for imdb_id in title_ids:
            movie = imdb_map.pop(imdb_id, None)
            if movie:
                matched_imbd_movies.append(
                    plex.Server.fetchItem(movie.ratingKey))
            else:
                missing_imdb_movies.append(imdb_id)

        return matched_imbd_movies, missing_imdb_movies
コード例 #22
0
 def setUp(self):
     self.tmdb = TMDb()
     self.tmdb.api_key = os.environ['TMDB_API_KEY']
     self.tmdb.language = "en"
     self.tmdb.debug = True
     self.tmdb.wait_on_rate_limit = True
     self.tmdb.cache = False
     self.network = Network()
コード例 #23
0
ファイル: tests.py プロジェクト: AnthonyBloomer/tmdbv3api
class TMDbTests(unittest.TestCase):
    def setUp(self):
        self.tmdb = TMDb('')

    def test_search(self):
        movie = self.tmdb.search("Pokémon")
        for l in movie:
            print l.title
コード例 #24
0
 def setUp(self):
     self.tmdb = TMDb()
     self.tmdb.api_key = os.environ["TMDB_API_KEY"]
     self.tmdb.language = "en-US"
     self.tmdb.debug = True
     self.tmdb.wait_on_rate_limit = True
     self.tmdb.cache = False
     self.certification = Certification()
コード例 #25
0
 def setUp(self):
     self.tmdb = TMDb()
     self.tmdb.api_key = '48f5c3a8e871801d8ad36d4360ef1f84'
     self.tmdb.language = "en-US"
     self.tmdb.debug = True
     self.tmdb.wait_on_rate_limit = True
     self.tmdb.cache = False
     self.episode = Episode()
コード例 #26
0
ファイル: image_scraper.py プロジェクト: Caff1982/MatchFlix
def scrape_images(filepath, save_to='media/images/'):
    """
    Takes path to a csv file as argument and uses
    TMDB API to download images by searching
    for title
    """
    BASE_IMG_URL = 'https://image.tmdb.org/t/p/w500'

    tmdb = TMDb()
    tmdb.api_key = TMDB_API_KEY
    tmdb.language = 'en'
    tmdb.debug = True

    with open(filepath, 'r') as f:
        reader = csv.DictReader(f)
        movie = Movie()
        tv = TV()
        for i, row in enumerate(reader):
            title = row['title']
            print(f'{i} Title: {title}')
            if row['type'] == 'TV Show':
                res = tv.search(title)
            else:
                res = movie.search(title)
            if len(res) == 0:
                print('No results found')
                continue
            elif len(res) > 1:
                print('Length of results: ', len(res))
                print(res)
            # Check to see if image is available
            try:
                image_url = BASE_IMG_URL + res[0].poster_path
            except TypeError as e:
                print('No image available')
                continue

            image_response = requests.get(image_url)
            if image_response.status_code == 200:
                with open(save_to + row['show_id'] + '.jpg', 'wb') as f:
                    f.write(image_response.content)
            else:
                print(f'Error retreiving image for: {title}')
                print(f'Status code: {image_response.status_code}')

            time.sleep(0.1)
コード例 #27
0
 def __init__(self):
     '''
     A custom client for The Movie Database API for French movies
     '''
     self.client = TMDb()
     self.client.language = 'fr-FR'
     self.movie_db = Movie()
     self.search = Search()
コード例 #28
0
 def setUp(self):
     self.tmdb = TMDb()
     self.tmdb.api_key = os.environ["TMDB_API_KEY"]
     self.tmdb.language = "en-US"
     self.tmdb.debug = True
     self.tmdb.wait_on_rate_limit = True
     self.tmdb.cache = False
     self.discover = Discover()
コード例 #29
0
 def setUp(self):
     self.tmdb = TMDb()
     self.tmdb.api_key = os.environ['TMDB_API_KEY']
     self.tmdb.language = "en-US"
     self.tmdb.debug = True
     self.tmdb.wait_on_rate_limit = True
     self.tmdb.cache = False
     self.genre = Genre()
コード例 #30
0
def init():
    movieName = input("\nMovie Name?")
    tmdb = TMDb()
    tmdb.api_key = "10163a322f4558e7cc6411377702d81d"

    movie = Movie()

    try:
        search = movie.search(movieName)

        if search is not None:
            for e in search:
                movieID = e.id
                break
            else:
                movieID = None

        m = movie.details(movieID)

        initial_budget = m.budget
        revenue = m.revenue
        title = m.original_title

        print("-Full name: " + title)

        if (initial_budget is not 0):
            print("-Intial Budget: " + (str(int(initial_budget))))

        else:
            print(
                "NO INITIAL BUDGET REPORTED. DO NOT USE THIS ENTRY FOR TRAINING DATA."
            )

        if (revenue is not 0):
            print("-Revenue: " + (str(int(revenue))))

        else:
            print(
                "NO REVENUE REPORTED. DO NOT USE THIS ENTRY FOR TRAINING DATA."
            )
            exit()
    except:
        print("\nBad movie entry?")

    return title, initial_budget, revenue
コード例 #31
0
 def __init__(self, movieId, api_key, tmdb):
     tmdb = TMDb()
     self.language = 'en'
     self.base = "https://api.themoviedb.org/3/movie/"
     self.append_to_response = "videos"
     self.key = []
     self.name = []
     self.site = []
     self.movieId = movieId
     self.api_key = api_key
コード例 #32
0
ファイル: moviebot.py プロジェクト: AnthonyBloomer/moviebot
            for g in movie.genres:
                genre += '#' + g['name'].replace(' ', '') + ' '
        image = movie.poster_path
        if image:
            image_path = pictures_path + image
            urllib.urlretrieve(config.TMDB_BASE_IMAGE_PATH + image, image_path)
            status = '%s - %s #movies %s' % (movie.title, movie.url, genre.lower())
            try:
                api.update_with_media(image_path, status=status)
            except Exception as e:
                print(e.message)
            os.remove(image_path)
            print('Status updated: ' + status.encode('utf-8'))


if __name__ == '__main__':
    tmdb = TMDb(api_key=None)
    tmdb.api_key = config.TMDB_API_KEY
    reddit = praw.Reddit(client_id=config.REDDIT_CLIENT_ID,
                         client_secret=config.REDDIT_CLIENT_SECRET,
                         user_agent=config.REDDIT_USER_AGENT)
    pictures_path = expanduser(config.PICTURES_PATH)
    auth = tweepy.OAuthHandler(config.CONSUMER_KEY, config.CONSUMER_SECRET)
    auth.set_access_token(config.ACCESS_KEY, config.ACCESS_SECRET)
    api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
    Bot()
    schedule.every(60).minutes.do(Bot())
    while 1:
        schedule.run_pending()
        time.sleep(1)
コード例 #33
0
ファイル: tests.py プロジェクト: AnthonyBloomer/tmdbv3api
 def setUp(self):
     self.tmdb = TMDb('')