Example #1
0
    def add_all_movies(self):
        local_http = http.request('GET', self._movies_url)
        date = BeautifulSoup(local_http.data,
                             'html.parser').find('a',
                                                 attrs={
                                                     'class': 'selected'
                                                 }).text[:5]
        year = str(date) + "." + str(current_year)
        for movie in self.get_all_movies():
            local_soup = BeautifulSoup(str(movie), 'html.parser')
            movie_name = local_soup.find('h5').text

            try:
                self._movies[movie_name]['projections']
            except KeyError:
                if movie_name in Movie.all_movies:
                    self._movies[movie_name] = Movie.all_movies[movie_name]
                else:
                    time.sleep(10)
                    movie = Movie(url=home + local_soup.a['href'])
                    movie.load_movie(movie_name)
                    self._movies[str(movie)] = movie.__dict__

            row = local_soup.find_all('div', attrs={'class': 'row'})
            for current in row:
                mini_soup = BeautifulSoup(str(current), 'html.parser')
                attributes = []
                for image in mini_soup.find_all('img'):
                    if image['alt']:
                        attributes.append(image['alt'])
                if attributes:
                    for item in current.find('div',
                                             attrs={
                                                 'class': 'timelineSet'
                                             }).text.split():
                        try:
                            self._movies[str(movie)]['projections'].append({
                                'features':
                                attributes,
                                'projection':
                                item,
                                'date':
                                year
                            })
                        except KeyError:
                            self._movies[movie_name]['projections'].append({
                                'features':
                                attributes,
                                'projection':
                                item,
                                'date':
                                year
                            })
Example #2
0
    def parse_add(self, imdbID):
        print('Inform the database file name: ')
        db_filename = input()
        movie = Movie(http_get(imdbID))
        pos = ms.writeAppend(db_filename, movie, keep_open=False)

        print('Inform the B Tree indexing fields: ')
        btree_fields = input().replace(' ', '').split(',')
        for field in btree_fields:
            node_element = BTreeNodeElement(movie.__dict__[field], pos, [])
            bt = BTree.load(field)
            bt.insert(node_element)
            bt.save(field)

        print('Inform the Patricia Trie indexing fields: ')
        ptrie_fields = input().replace(' ', '').split(',')
        for field in ptrie_fields:
            pt = PatriciaTrie.load(field)
            pt.insert(movie,
                      position=pos,
                      db_filepath=db_filename,
                      λ=lambda x: x.__dict__[field].lower())
            pt.save(field)

        print('Inform the Reversed File indexing fields: ')
        rf_fields = input().replace(' ', '').split(',')
        for field in rf_fields:
            rf.inc_reversed_file(db_filename, movie, field)

        return movie.title + ' was added to the database'
Example #3
0
    def read_json(self, json_file):
        '''
        read the data from a json file to create the movie list
        keyword arguments:
        json_file (string) the path to the json file
        '''
        def parse_params(json_element):
            '''
            returns an array of objects to compose a media with ease
            keywords arguments:
            json_element (Object) -- a python object converted from a json
            element

            attributes:
            title    (string)  -- the media title
            summary  (string)  -- the media summary
            url      (string)  -- the media url
            featured (boolean) -- if the media is featured or not.
            Default false
            '''
            def evaluate(param, else_value=None):
                '''
                check if the given param has value to return or returns an
                optional value if it has not

                keyword arguments:
                param      (string)  -- the attribute name from the jsn_element
                else_value (variant) -- the value to be used if the attribute
                has no value. defautl None
                '''
                if param not in json_element:
                    return else_value

                return json_element[param]

            title = evaluate('title')
            summary = evaluate('description')
            url = evaluate('url')
            featured = evaluate('featured', False)
            return title, url, summary, featured

        json_file = json.load(open(json_file, 'r'))
        for json_nodes in json_file:
            movie = Movie(json_nodes['title'],
                          json_nodes['sinopse'], json_nodes['year'])
            if 'trailers' in json_nodes:
                for trailer in json_nodes['trailers']:
                    attr = parse_params(trailer)
                    movie.add_trailer(attr[0], attr[1], attr[3])
            if 'posters' in json_nodes:
                for poster in json_nodes['posters']:
                    attr = parse_params(poster)
                    movie.add_poster(attr[0], attr[1], attr[2])
            self.add(movie)
Example #4
0
def process(movie_path, record_dir_format, class_mapping):
    try:
        records = []
        for label in class_mapping.items():
            record = Record()
            record.dir_format = record_dir_format
            record.label = label
            record.threshold = config["threshold"]
            record.skip_frame_interval = config["skip_frame_interval"]
            record.prepare()
            records.append(record)

        model = keras.models.load_model(model_file_path, compile=False)
        predictor = Predictor(model, config["image_size_px"])
        movie = Movie(movie_path, config["skip_frame_interval"], records, predictor)
        if movie.is_completed_clip():
            return
        movie.capture()
        movie.write_period_to_file()
    except Exception as e:
        print("record ERROR: ", movie_path)
        print(e)
        print(traceback.format_exc())
import math

from matplotlib import patches

from lib.Interpolation import Interpolation
from lib.data.interval import Interval
from lib.data.options import Options
from lib.data.property import Property
from lib.movie import Movie
from lib.scene import Scene
from lib.shapes.animated_grid import AnimatedGrid
from lib.animation_initializers.value_animation import ValueAnimation

# Create a new movie with one scene
movie = Movie()
scene = Scene()
movie.scenes.append(scene)

# Create a grid with center (0, 0), with 30 points in each direction that are .05 apart
grid = AnimatedGrid((0, 0), 30, .05)

# Add the visible parts of the grid to the scene
scene.add_artists(grid.artists)

# Add a circle (the "unit circle") to the scene
scene.add_artists([patches.Circle((0, 0), .5, facecolor='None')])

interpolation = Interpolation.quintic

# Add an animation of the theta parameters of the points in the grid to the scene (rotate every point pi radians with
#  respect to the origin)
Example #6
0
def step_set_movie_name(context, movie_name):
    context.movie = Movie()
    context.movie.set_movie(movie_name)
	def test_read_movies_from_file(self):
		Store.set_file(file_path)
		a = Movie.read_movies_from_file()[0]
		self.assertIsInstance(a, Movie)
	def test_add_movie_into_file(self):
		Store.set_file(file_path)
		args = ["Super Man", "2013", "8.5"]
		self.assertTrue(Movie.add_movie_into_file(args))
	def test_accessors_value(self):
		a = Movie("Iron Man3", "2013", "8.5")
		self.assertEqual("Iron Man3", a.get_movie() )
		self.assertEqual("2013",	  a.get_date()  )
		self.assertEqual("8.5", 	  a.get_rating())