initial commit (#1)

Author: vr-ski

.gitignore

@@ -0,0 +1,9 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+
+# Environment
+venv/
+.venv/
+
+# Project settings
+.idea/

moviedb_analyzer.py

@@ -0,0 +1,36 @@
+#-#!/usr/bin/env python3
+from src.facade import Facade
+
+def main():
+    
+    # Init and load file
+    
+    INPUT_PATH = "resources/movies_metadata.csv"
+    INPUT_TYPE = 'csv'
+    
+    facade = Facade(input_type=INPUT_TYPE, 
+                    input_path=INPUT_PATH)
+
+    # Analyze
+    facade.logger.info(f"Unique movies: {facade.count_unique_rows(['imdb_id', 'original_title'])}")
+
+    facade.logger.info(f"Average ratings of all movies: {facade.find_average('vote_average')}")
+
+    facade.logger.info(f"Top 5 highest rated movies: {facade.find_top(sort_column='vote_average', top=5, return_column='original_title')}")
+    
+    facade.logger.info(f"Movies released each year: {facade.movies_by_year('release_date')}")
+    
+    facade.logger.info(f"Movies released in each genre: {facade.movies_by_genre('genres')}")
+
+    # Save as JSON
+    
+    OUTPUT_PATH = "resources/movies_metadata.json"
+    OUTPUT_TYPE = 'json'
+    
+    facade.save_as(output_type=OUTPUT_TYPE,
+                   output_path=OUTPUT_PATH)
+
+
+if __name__ == "__main__":
+
+    main()

requirements.txt

@@ -0,0 +1 @@
+pandas==2.2.2

requirements_test.txt

@@ -0,0 +1 @@
+coverage==7.5.4

resources/movies_metadata.csv

@@ -0,0 +1,17 @@
+from io import open as io_open
+from setuptools import setup, find_packages
+
+# read module requirements from requirements.txt instead of repeating th edependencies here:
+with open("requirements.txt") as f:
+    requirements = f.read().splitlines()
+    install_requires = [r for r in requirements if not r == ""]
+
+setup(
+        name="moviedb_analyzer",
+        version="0.1",
+        description="Pandas analyzer for moviedb files",
+        long_description=io_open("README.md", encoding="utf-8").read(),
+        package_dir={"": "src"},
+        packages=find_packages("src"),
+        install_requires=install_requires
+)

setup.py

@@ -0,0 +1,101 @@
+from typing import List
+from pandas import DataFrame, to_datetime
+
+from src.logger import Logger
+
+class Analyzer:
+    """Analyzer class. Uses pandas dataframe method and functions to provide statistics and aggregations
+    """
+    def __init__(self, dataframe: DataFrame):
+        """Init method
+
+        Args:
+            dataframe (DataFrame): Dataframe to be analyzed
+        """
+        self._dataframe = dataframe
+        self._logger = Logger()
+
+        self._logger.debug(f"{self._dataframe.columns=}")
+
+    def count_unique_rows(self, columns: List[str]) -> int:
+        """Count unique rows 
+
+        Args:
+            columns (List[str]): List of columns
+
+        Returns:
+            int: Number of unique rows
+        """
+        count = self._dataframe[columns].drop_duplicates().shape[0]
+
+        return count
+
+    def find_average(self, column) -> float:
+        """Find average based on column
+
+        Args:
+            column (_type_): column to get average of
+
+        Returns:
+            float: the average of the column values
+        """
+        average = self._dataframe[column].mean()
+
+        return average
+
+    def find_top_rows(self, column: str, top: int) -> DataFrame:
+        """Find top N rows
+
+        Args:
+            column (str): column to sort by
+            top (int): number of top rows to return
+
+        Returns:
+            DataFrame: Dataframe containing the top rows only
+        """
+        top_rows = self._dataframe.sort_values(by=[column], ascending=False).head(top)
+
+        return top_rows
+
+    def movies_by_year(self, column: str) -> DataFrame:
+        """Count movies by year
+
+        Args:
+            column (str): Movies column name
+
+        Returns:
+            DataFrame: Dataframe containing the counts
+        """
+        tmp_df = self._dataframe
+        
+        tmp_df['year'] = tmp_df[column].str[:4]
+        
+        self._logger.debug(f"{tmp_df.columns=}")
+
+        counts = tmp_df.groupby(['year']).size()
+
+        self._logger.debug(f"{type(counts)=}")
+        
+        return counts
+    
+    def movies_by_genre(self, column: str) -> DataFrame:
+        """Count movies by genre
+
+        Args:
+            column (str): Genre column name
+
+        Returns:
+            DataFrame: Dataframe containing the counts
+        """
+        tmp_df = self._dataframe
+        
+        tmp_df = tmp_df.explode(column)
+        
+        self._logger.debug(f"{tmp_df.head(5)=}")
+
+        counts = tmp_df.groupby(column).size()
+        
+        self._logger.debug(f"{type(counts)=}")
+        
+        return counts
+

src/analyzer.py

@@ -0,0 +1,103 @@
+from typing import List
+from pathlib import Path
+
+from src.file_handler import FileHandler
+from src.analyzer import Analyzer
+from src.logger import Logger
+
+class Facade:
+    """Facade class for the app. 
+    """
+
+    def __init__(self, input_type: str, input_path: str):
+        """Init method
+
+        Args:
+            input_type (str): Type of input file
+            input_path (str): Path of input file
+        """
+        self.logger = Logger()
+
+        self._file_handler = FileHandler(input_type=input_type,
+                                        input_path=input_path)
+
+        self._dataframe = self._file_handler.dataframe
+
+        self._analyzer = Analyzer(self._dataframe)
+
+    def count_unique_rows(self, columns: List[str]) -> int:
+        """Count unique rows based on column combination. 
+
+        Args:
+            columns (List[str]): List of columns to be used in aggregation.
+
+        Returns:
+            int: Return number of rows
+        """
+        count = self._analyzer.count_unique_rows(columns)
+        
+        return count
+
+    def find_average(self, column: str) -> float:
+        """Find average value of values in column
+
+        Args:
+            column (str): column name
+
+        Returns:
+            float: return average
+        """
+        average = self._analyzer.find_average(column)
+
+        return average
+
+    def find_top(self, sort_column: str, top: int, return_column: str) -> str:
+        """Find the top N values of return_column, based on sort_column.
+
+        Args:
+            sort_column (str): Column to sort by
+            top (int): Number of records to return
+            return_column (str): Column to return values for
+
+        Returns:
+            str: Top N values for return_column
+        """
+        top_rated_movies = self._analyzer.find_top_rows(column=sort_column, top=top)[return_column]
+
+        return top_rated_movies
+
+    def movies_by_year(self, column: str) -> str:
+        """Count movies by year
+
+        Args:
+            column (str): year column
+
+        Returns:
+            str: Return string representation of dataframe
+        """
+        list_of_count = self._analyzer.movies_by_year(column)#.values.tolist()
+
+        return list_of_count.to_string()
+
+    def movies_by_genre(self, column: str) -> str:
+        """Count movies by genre.
+
+        Args:
+            column (str): genre column.
+
+        Returns:
+            str: Return string representation of dataframe
+        """
+        list_of_count = self._analyzer.movies_by_genre(column)#.values.tolist()
+
+        return list_of_count.to_string()
+
+    def save_as(self, output_type: str, output_path: str):
+        """Save dataframe as file type
+
+        Args:
+            output_type (str): Type of the file to be saved
+            output_path (str): Path of the file to be saved
+        """
+        self._file_handler.save_df_as_file(output_type=output_type, output_path=output_path)
+