diff --git a/.github/workflows/project_feedback.yml b/.github/workflows/project_feedback.yml new file mode 100644 index 0000000000..bfa1ec4f0b --- /dev/null +++ b/.github/workflows/project_feedback.yml @@ -0,0 +1,31 @@ +name: Run Tests +run-name: ${{ github.actor }} is running tests + +on: + push: + branches: + - main + +jobs: + test: + runs-on: ubuntu-20.04 + + steps: + - uses: actions/checkout@v2 + + - name: Set up Python 3.11 + uses: actions/setup-python@v2 + with: + python-version: 3.11 + + - name: Install dependencies + run: | + python -m pip install --upgrade pip + pip install -r requirements.txt + + # project and exercise feedbacks + - name: Make test executable + run: chmod +x /home/runner/work/made-template/made-template/project/tests.sh + + - name: Run project tests + run: /home/runner/work/made-template/made-template/project/tests.sh \ No newline at end of file diff --git a/.gitignore b/.gitignore index d6d425f682..cc52fe5538 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,8 @@ .DS_Store /data/* -!/data/.gitkeep \ No newline at end of file +!/data/.gitkeep +.mypy_cache/ +temp_dir/ +project/__pycache__/ +*.pyc +*.sqlite \ No newline at end of file diff --git a/exercises/exercise1.jv b/exercises/exercise1.jv new file mode 100644 index 0000000000..069d53922b --- /dev/null +++ b/exercises/exercise1.jv @@ -0,0 +1,74 @@ +pipeline FlugHafen{ + + //1. FlugHafen Pipeline connects the blocks via pipes to extract data from a CSV file + // in the web to a SQLite file sink. + FlugHafenHttpExtractor + -> FlugHafenTextFileInterpreter; + + //2. The FlugHafenTextFileInterpreter output is used as input for the FlugHafenCsvFileInterpreter + // block which is then used as input for the FlugHafenDataSelector block. + FlugHafenTextFileInterpreter + -> FlugHafenCsvFileInterpreter + // -> FlugHafenDatabaseWriter + -> FlugHafenDataSelector + -> FlugHafenTableInterpreter + -> FlugHafenLoader; + + //3. The FlugHafenHttpExtractor block is of type HttpExtractor and the URL is specified. + block FlugHafenHttpExtractor oftype HttpExtractor { + // URL of the data source + url: "https://opendata.rhein-kreis-neuss.de/api/explore/v2.1/catalog/datasets/rhein-kreis-neuss-flughafen-weltweit/exports/csv?lang=en&timezone=Europe%2FBerlin&use_labels=true&delimiter=%3B"; + } + + //4. The FlugHafenTextFileInterpreter block is of type TextFileInterpreter. + block FlugHafenTextFileInterpreter oftype TextFileInterpreter { } + + //5. Since we only need a specific range of the data, we use the CellRangeSelector block. + block FlugHafenDataSelector oftype CellRangeSelector { + // The name of the sheet + select: range A1:I*; + } + + //6. The FlugHafenCsvFileInterpreter block is of type CSVInterpreter and the delimiter is specified. + block FlugHafenCsvFileInterpreter oftype CSVInterpreter { + // Specify the separator as a semicolon for the CSV + delimiter: ';'; + } + + // block FlugHafenDatabaseWriter oftype DatabaseWriter { + // // The name of the database + // database: "flughafen.db"; + // // The name of the table + // table: "flughafen"; + // } + + //7. The FlugHafenTableInterpreter block is of type TableInterpreter and the necessary columns are specified. + block FlugHafenTableInterpreter oftype TableInterpreter { + // The first row contains the header + header: true; + // The columns of the table + columns: [ + "Lfd. Nummmer" oftype integer, + "Name des Flughafens" oftype text, + "Ort" oftype text, + "Land" oftype text, + "IATA" oftype text, + "ICAO" oftype text, + "Latitude" oftype decimal, + "Longitude" oftype decimal, + "Altitude" oftype integer, + + ]; + } + + //8. Finally the FlugHafenLoader block is of type SQLiteLoader and the table name and file name are specified. + block FlugHafenLoader oftype SQLiteLoader { + // The name of the table + table: "airports"; + // The name of the file + file: "airports.sqlite"; + } + + +} + diff --git a/exercises/exercise2.jv b/exercises/exercise2.jv new file mode 100644 index 0000000000..f46db1c3c4 --- /dev/null +++ b/exercises/exercise2.jv @@ -0,0 +1,85 @@ +pipeline TreePlanting{ + + //1. TreePlanting Pipeline connects the blocks via pipes to extract data from a CSV file + // in the web to a SQLite file sink. + TreePlantingHttpExtractor + -> TreePlantingTextFileInterpreter; + + //2. The TreePlantingTextFileInterpreter output is used as input for the TreePlantingCsvFileInterpreter + // block which is then used as input for the TreePlantingDataSelector block. + TreePlantingTextFileInterpreter + -> TreePlantingCsvFileInterpreter + // -> TreePlantingDatabaseWriter + -> TreePlantingBaumartDeutschDeleter + -> TreePlantingTableInterpreter + -> TreePlantingLoader; + + //3. The TreePlantingHttpExtractor block is of type HttpExtractor and the URL is specified. + block TreePlantingHttpExtractor oftype HttpExtractor { + // URL of the data source + url: "https://opendata.rhein-kreis-neuss.de/api/v2/catalog/datasets/stadt-neuss-herbstpflanzung-2023/exports/csv"; + } + + //4. The TreePlantingTextFileInterpreter block is of type TextFileInterpreter. + block TreePlantingTextFileInterpreter oftype TextFileInterpreter { } + + //6. The TreePlantingCsvFileInterpreter block is of type CSVInterpreter and the delimiter is specified. + block TreePlantingCsvFileInterpreter oftype CSVInterpreter { + // Specify the separator as a semicolon for the CSV + delimiter: ';'; + } + + //5. The TreePlantingBaumartDeutschDeleter block is of type ColumnDeleter and the column to be deleted is specified. + block TreePlantingBaumartDeutschDeleter oftype ColumnDeleter { + // The name of the column + delete: [column E]; + } + + //7. The TreePlantingTableInterpreter block is of type TableInterpreter and the necessary columns are specified. + block TreePlantingTableInterpreter oftype TableInterpreter { + // The first row contains the header + header: true; + // The columns of the table + columns: [ + "lfd_nr" oftype integer, + "stadtteil" oftype Vogelsang, + "standort" oftype text, + "baumart_botanisch" oftype text, + "id" oftype GeoCoordinate, + "baumfamilie" oftype text, + + ]; + } + + block TreePlantingLoader oftype SQLiteLoader { + // The name of the table + table: "trees"; + // The name of the file + file: "trees.sqlite"; + } + + + valuetype Vogelsang oftype text { + // The value of the column + constraints: [ + // only allow column values that start with "Vogelsang" + VogelsangStadteil + ]; + } + + valuetype GeoCoordinate oftype text { + // The value of the column + constraints: [ + // only allow column values that match the pattern of a geo coordinate + Geopoints + ]; + } + + constraint VogelsangStadteil on text: value matches(/^Vogelsang*/); + //8. Finally the TreePlantingLoader block is of type SQLiteLoader and the table name and file name are specified. + + constraint Geopoints on text: value matches(/^\d{1,3}\.\d+,\s*\d{1,3}\.\d+$/); + + +} + diff --git a/exercises/exercise3.jv b/exercises/exercise3.jv new file mode 100644 index 0000000000..90d4434002 --- /dev/null +++ b/exercises/exercise3.jv @@ -0,0 +1,92 @@ +pipeline WorldBank { + + // 1. Block to extract an XLSX file from the web + block WorldBankHttpExtractor oftype HttpExtractor { + // URL of the source file containing the data + url: "https://thedocs.worldbank.org/en/doc/7d852628d96b9411d43e5d36d5dff941-0050062022/original/Graphs-Chapter-5-02082022.xlsx"; + } + + // 2. Block to interpret the downloaded file as an XLSX workbook + block WorldBankTextXLSXInterpreter oftype XLSXInterpreter { } + + // 3. Block to select the specific sheet "Figure S5.1.2" from the workbook + block DataCellSheetpicker oftype SheetPicker { + sheetName: "Figure S5.1.2"; + } + + // 4. Block to specify the cell range of interest in the selected sheet + block WorldBankRangeSelector oftype CellRangeSelector { + select: range P2:S45; + } + + // 5. Block to rename columns for clarity and standardization + block NameHeaderWriter oftype CellWriter { + at: range A1:D1; + write: ["Country Code", "Economy", "GDP per Capita", "Bond Issuance Share"]; + } + + // 6. Block to interpret and filter the "Bond Issuance Share" column data + block BondIssuanceTableInterpreter oftype TableInterpreter { + columns: [ + "Country Code" oftype CountryCodeAlpha3, + "Bond Issuance Share" oftype BetweenZeroAndOne, + ]; + } + + // 7. Block to interpret and filter the "GDP per Capita" column data + block GDPTableInterpreter oftype TableInterpreter { + columns: [ + "Country Code" oftype CountryCodeAlpha3, + "GDP per Capita" oftype PositiveDecimal, + ]; + } + + // 8. Block to load "Bond Issuance Share" data into a SQLite table + block BondIssuanceTableLoader oftype SQLiteLoader { + table: "bondIssuance"; // Table name in the SQLite database + file: "country-stats.sqlite"; // SQLite database file + } + + // 9. Block to load "GDP per Capita" data into a SQLite table + block GDPTableLoader oftype SQLiteLoader { + table: "gdpPerCapita"; // Table name in the SQLite database + file: "country-stats.sqlite"; // SQLite database file + } + + // 10. Value type to enforce positive decimal values + valuetype PositiveDecimal oftype decimal { + constraints: [ + OnlyPositiveDecimal // Constraint: Values must be > 0 + ]; + } + + // 11. Value type to enforce decimal values between 0 and 1 + valuetype BetweenZeroAndOne oftype decimal { + constraints: [ + BetweenZeroAndOneConstraint // Constraint: 0 <= value <= 1 + ]; + } + + // 12. Constraints definitions + constraint OnlyPositiveDecimal on decimal: value > 0; + constraint BetweenZeroAndOneConstraint on decimal: value >= 0 and value <= 1; + + // Pipeline connections + WorldBankHttpExtractor + -> WorldBankTextXLSXInterpreter; + + WorldBankTextXLSXInterpreter + -> DataCellSheetpicker + -> WorldBankRangeSelector + -> NameHeaderWriter; + + // Bond Issuance pipeline + NameHeaderWriter + -> BondIssuanceTableInterpreter + -> BondIssuanceTableLoader; + + // GDP per Capita pipeline + NameHeaderWriter + -> GDPTableInterpreter + -> GDPTableLoader; +} diff --git a/exercises/exercise4.jv b/exercises/exercise4.jv new file mode 100644 index 0000000000..579294ee73 --- /dev/null +++ b/exercises/exercise4.jv @@ -0,0 +1,111 @@ +pipeline MobiliThek{ + + block DataExtractor oftype HttpExtractor { + url : "https://www.mowesta.com/data/measure/mowesta-dataset-20221107.zip"; + } + + block DataInterpreter oftype ArchiveInterpreter { + archiveType: "zip"; + } + + block FilePicker oftype FilePicker { + path: "/data.csv"; + } + + block TextFileInterpreter oftype TextFileInterpreter { } + + + block CSVInterpreter oftype CSVInterpreter { + delimiter: ';'; + } + + // block CellRangeSelector oftype CellRangeSelector { + // select: range A1:J4873; + // } + + block DeleteSomeColumns oftype ColumnDeleter { + delete: [column F, column G, column H, column I, column K, column L, column M, column N, column O, column P, column Q, + column R, column S, column T, column U, column V, column W, column X, column Y, column Z, + column AA, column AB, column AC, column AD, column AE, column AF, column AG, column AH, column AI, + column AJ, column AK, column AL, column AM, column AN, column AO, column AP, column AQ, column AR, + column AS, column AT, column AU, column AV, column AW, column AX, column AY, column AZ, column BA, + column BB, column BC, column BD, column BE, column BF, column BG, column BH, column BI, column BJ, + column BK, column BL, column BM, column BN, column BO, column BP, column BQ, column BR, column BS, + column BT, column BU, column BV, column BW, column BX, column BY, column BZ, column CA, column CB, + column CC, column CD, column CE, column CF, column CG, column CH, column CI, column CJ, column CK, + column CL, column CM, column CN, column CO, column CP, column CQ, column CR, column CS, column CT, + column CU, column CV, column CW, column CX, column CY, column CZ, column DA, column DB, column DC, + column DD, column DE, column DF, column DG, column DH, column DI, column DJ, column DK, column DL, + column DM, column DN, column DO, column DP, column DQ, column DR, column DS, column DT, column DU, + column DV, column DW, column DX, column DY, column DZ, column EA, column EB, column EC, column ED, + column EE, column EF, column EG, column EH, column EI, column EJ, column EK, column EL, column EM, + column EN, column EO, column EP, column EQ, column ER, column ES, column ET, column EU, column EV, + column EW, column EX, column EY]; + } + + block RenameColumns oftype CellWriter { + at: range A1:F1; + write: ["id", "producer", "model", "month", "temperature", "battery_temperature"]; + } + + block TempMeasurementTableInterpreter oftype TableInterpreter { + header: true; + columns: [ + "id" oftype integer, + "producer" oftype text, + "model" oftype text, + "month" oftype BetweenOneAndTwelve, + "temperature" oftype decimal, + "battery_temperature" oftype decimal, + ]; + } + + block TempMeasurementTransformer oftype TableTransformer { + inputColumns: [ + "temperature", + ]; + outputColumn: "temperature"; + uses: FahrenheitUnit; + } + + block TempMeausurementBatteryTransformer oftype TableTransformer { + inputColumns: [ + "battery_temperature", + ]; + outputColumn: "battery_temperature"; + uses: FahrenheitUnit; + } + + transform FahrenheitUnit { + from Celsius oftype decimal; + to Fahrenheit oftype decimal; + Fahrenheit: Celsius * 9/5 + 32; + } + + valuetype BetweenOneAndTwelve oftype integer { + constraints: [ + BetweenOneAndTwelveConstraint + ]; + } + + constraint BetweenOneAndTwelveConstraint on integer: value >= 1 and value <= 12; + + + block DataLoader oftype SQLiteLoader { + table: "temperatures"; + file: "temperatures.sqlite"; + } + + DataExtractor + -> DataInterpreter + -> FilePicker + -> TextFileInterpreter + -> CSVInterpreter + // -> CommaSeparator + -> DeleteSomeColumns + -> RenameColumns + -> TempMeasurementTableInterpreter + -> TempMeasurementTransformer + -> TempMeausurementBatteryTransformer + -> DataLoader; +} \ No newline at end of file diff --git a/exercises/exercise5.jv b/exercises/exercise5.jv new file mode 100644 index 0000000000..73335fbecf --- /dev/null +++ b/exercises/exercise5.jv @@ -0,0 +1,85 @@ +pipeline GTFS { + + block GTFSDataExtractor oftype HttpExtractor{ + url: "https://gtfs.rhoenenergie-bus.de/GTFS.zip"; + } + + block GTFSDataInterpreter oftype ArchiveInterpreter{ + archiveType: "zip"; + } + + block GTFSFilePicker oftype FilePicker{ + path: "/stops.txt"; + } + + block GTFSTextFileInterpreter oftype TextFileInterpreter{ + encoding: "utf8"; + } + + + block GTFSCSVInterpreter oftype CSVInterpreter{ + enclosing: '"'; + enclosingEscape: '"'; + } + + block GTFSTableInterpreter oftype TableInterpreter{ + header: true; + columns: [ + "stop_id" oftype integer, + "stop_name" oftype text, + "stop_lat" oftype BetweenPlusMinusNinety, + "stop_lon" oftype BetweenPlusMinusNinety, + "zone_id" oftype ValidZone, + ]; + } + + // valuetype GermanUmlauts oftype text{ + // constraints: [ + // GermanUmlautsConstraint + // ]; + // } + // // /^[A-Za-z0-9äöüÄÖÜß\s\-\.(),]*$/; + // // /^(?=.*[äöüÄÖÜß])[A-Za-z0-9äöüÄÖÜß]*$/; + // constraint GermanUmlautsConstraint on text: value matches /^[A-Za-z0-9äöüÄÖÜß\s\-\.(),]*$/; + + valuetype BetweenPlusMinusNinety oftype decimal{ + constraints: [ + BetweenPlusMinusNinetyConstraint + ]; + } + constraint BetweenPlusMinusNinetyConstraint oftype RangeConstraint{ + lowerBound: -90; + lowerBoundInclusive: true; + upperBound: 90; + upperBoundInclusive: true; + } + + + valuetype ValidZone oftype integer{ + constraints: [ + ValidZoneConstraint + ]; + } + + + // constraint ValidZoneConstraint oftype RangeConstraint{ + // lowerBound: 1925; + // // upperBound: 1925; + // } + + constraint ValidZoneConstraint on integer: value == 1925 ; + + block GTFSDataLoader oftype SQLiteLoader{ + table: "stops"; + file: "gtfs.sqlite"; + } + + + GTFSDataExtractor + -> GTFSDataInterpreter + -> GTFSFilePicker + -> GTFSTextFileInterpreter + -> GTFSCSVInterpreter + -> GTFSTableInterpreter + -> GTFSDataLoader; +} \ No newline at end of file diff --git a/project/.__init__.py b/project/.__init__.py new file mode 100644 index 0000000000..e69de29bb2 diff --git a/project/__pycache__/prepare_data.cpython-311.pyc b/project/__pycache__/prepare_data.cpython-311.pyc new file mode 100644 index 0000000000..8b6946d4ca Binary files /dev/null and b/project/__pycache__/prepare_data.cpython-311.pyc differ diff --git a/project/__pycache__/run_tests.cpython-311.pyc b/project/__pycache__/run_tests.cpython-311.pyc new file mode 100644 index 0000000000..1bcdccc417 Binary files /dev/null and b/project/__pycache__/run_tests.cpython-311.pyc differ diff --git a/project/analysis-report.pdf b/project/analysis-report.pdf new file mode 100644 index 0000000000..51811ed81b Binary files /dev/null and b/project/analysis-report.pdf differ diff --git a/project/data-report.pdf b/project/data-report.pdf new file mode 100644 index 0000000000..58a9e5426a Binary files /dev/null and b/project/data-report.pdf differ diff --git a/project/final_report.ipynb b/project/final_report.ipynb new file mode 100644 index 0000000000..5e353f14e5 --- /dev/null +++ b/project/final_report.ipynb @@ -0,0 +1,585 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### A visual inspection of Regional Economic Trends: North America & Latin America " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Introduction\n", + "\n", + "- Renewable Energy Adoption\n", + " - Renewable energy consumption \n", + "- Climate Mitigation Efforts\n", + " - CO2, Methane, NO emissions\n", + " - Greenhouse gas emissions \n", + "- Environmental Impact\n", + " - Fossil fuel energy consumption\n", + " - Forest area (% of land area)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import sqlite3" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def read_sqlite_table(db_path, table_name=None, query=None):\n", + " conn = sqlite3.connect(db_path)\n", + " \n", + " if query:\n", + " df = pd.read_sql_query(query, conn)\n", + " elif table_name:\n", + " df = pd.read_sql_query(f\"SELECT * FROM {table_name}\", conn)\n", + " else:\n", + " raise ValueError(\"Either table_name or query must be provided\")\n", + " \n", + " conn.close()\n", + " return df" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "lcn_df = read_sqlite_table(\"../data/world_data.sqlite\", table_name=\"LCN\")\n", + "lcn_df.to_csv(\"../data/lcn.csv\", index=False)\n", + "nac_df = read_sqlite_table(\"../data/world_data.sqlite\", table_name=\"NAC\")\n", + "nac_df.to_csv(\"../data/nac.csv\", index=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Overview Metrics\n", + "overview_codes = [\n", + " 'EN.GHG.ALL.PC.CE.AR5', # Per capita emissions\n", + " 'EG.USE.ELEC.KH.PC', # Electricity consumption per capita\n", + " 'EG.IMP.CONS.ZS' # Energy imports\n", + "]\n", + "\n", + "\n", + "# Emissions Analysis\n", + "emissions_analysis = {\n", + " 'total_ghg': ['EN.GHG.TOT.ZG.AR5'],\n", + " 'co2': [\n", + " 'EN.GHG.CO2.MT.CE.AR5',\n", + " 'EN.GHG.CO2.ZG.AR5',\n", + " 'EN.GHG.CO2.RT.GDP.KD',\n", + " 'EN.GHG.CO2.RT.GDP.PP.KD'\n", + " ],\n", + " 'methane': [\n", + " 'EN.GHG.CH4.TR.MT.CE.AR5',\n", + " 'EN.GHG.CH4.IC.MT.CE.AR5',\n", + " 'EN.GHG.CH4.WA.MT.CE.AR5'\n", + " ],\n", + " 'n2o': [\n", + " 'EN.GHG.N2O.TR.MT.CE.AR5',\n", + " 'EN.GHG.N2O.IC.MT.CE.AR5',\n", + " 'EN.GHG.N2O.PI.MT.CE.AR5',\n", + " 'EN.GHG.N2O.FE.MT.CE.AR5'\n", + " ]\n", + "}\n", + "\n", + "# Energy Production & Consumption\n", + "energy_analysis = {\n", + " 'renewable': [\n", + " 'EG.FEC.RNEW.ZS',\n", + " 'EG.ELC.RNWX.ZS',\n", + " 'EG.ELC.RNWX.KH',\n", + " 'EG.ELC.HYRO.ZS'\n", + " ],\n", + " 'fossil_fuels': [\n", + " 'EG.ELC.FOSL.ZS',\n", + " 'EG.ELC.COAL.ZS',\n", + " 'EG.ELC.NGAS.ZS',\n", + " 'EG.ELC.PETR.ZS'\n", + " ],\n", + " 'nuclear': ['EG.ELC.NUCL.ZS']\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Overview DataFrames\n", + "overview_lcn = lcn_df[lcn_df['IndicatorCode'].isin(overview_codes)].drop_duplicates()\n", + "overview_nac = nac_df[nac_df['IndicatorCode'].isin(overview_codes)].drop_duplicates()\n", + "\n", + "# Emissions DataFrames\n", + "emissions_lcn = {\n", + " 'total': lcn_df[lcn_df['IndicatorCode'].isin(emissions_analysis['total_ghg'])],\n", + " 'co2': lcn_df[lcn_df['IndicatorCode'].isin(emissions_analysis['co2'])],\n", + " 'methane': lcn_df[lcn_df['IndicatorCode'].isin(emissions_analysis['methane'])],\n", + " 'n2o': lcn_df[lcn_df['IndicatorCode'].isin(emissions_analysis['n2o'])]\n", + "}\n", + "\n", + "emissions_nac = {\n", + " 'total': nac_df[nac_df['IndicatorCode'].isin(emissions_analysis['total_ghg'])],\n", + " 'co2': nac_df[nac_df['IndicatorCode'].isin(emissions_analysis['co2'])],\n", + " 'methane': nac_df[nac_df['IndicatorCode'].isin(emissions_analysis['methane'])],\n", + " 'n2o': nac_df[nac_df['IndicatorCode'].isin(emissions_analysis['n2o'])]\n", + "}\n", + "\n", + "# Energy DataFrames\n", + "energy_lcn = {\n", + " 'renewable': lcn_df[lcn_df['IndicatorCode'].isin(energy_analysis['renewable'])],\n", + " 'fossil': lcn_df[lcn_df['IndicatorCode'].isin(energy_analysis['fossil_fuels'])],\n", + " 'nuclear': lcn_df[lcn_df['IndicatorCode'].isin(energy_analysis['nuclear'])]\n", + "}\n", + "\n", + "energy_nac = {\n", + " 'renewable': nac_df[nac_df['IndicatorCode'].isin(energy_analysis['renewable'])],\n", + " 'fossil': nac_df[nac_df['IndicatorCode'].isin(energy_analysis['fossil_fuels'])],\n", + " 'nuclear': nac_df[nac_df['IndicatorCode'].isin(energy_analysis['nuclear'])]\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def write_source_notes(data, filename=\"../data/source_notes.txt\"):\n", + " \"\"\"Write source notes for each indicator to a file.\"\"\"\n", + " with open(filename, \"w\", encoding=\"utf-8\") as f:\n", + " f.write(\"Source Notes for Indicators\\n\")\n", + " f.write(\"==========================\\n\\n\")\n", + " for idx, row in data.iterrows():\n", + " f.write(f\"Indicator Code: {row['IndicatorCode']}\\n\")\n", + " f.write(f\"Indicator Name: {row['IndicatorName']}\\n\")\n", + " f.write(f\"Source Note: {row['SourceNote']}\\n\")\n", + " f.write(\"-\" * 80 + \"\\n\\n\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Plottings" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "import math\n", + "from itertools import islice\n", + "\n", + "\n", + "def preprocess_emissions_data(emissions_dict):\n", + " \"\"\"\n", + " Remove duplicates from emissions DataFrames.\n", + "\n", + " Args:\n", + " emissions_dict (dict): Dictionary containing emissions DataFrames\n", + "\n", + " Returns:\n", + " dict: Dictionary with cleaned DataFrames\n", + " \"\"\"\n", + " cleaned_dict = {}\n", + " for key, df in emissions_dict.items():\n", + " # Drop duplicates based on all columns\n", + " cleaned_df = df.drop_duplicates()\n", + " # Also drop duplicates based on IndicatorCode and year columns\n", + " year_cols = [col for col in df.columns if str(col).isdigit()]\n", + " subset_cols = [\"IndicatorCode\"] + year_cols\n", + " cleaned_df = cleaned_df.drop_duplicates(subset=subset_cols)\n", + " cleaned_dict[key] = cleaned_df\n", + " return cleaned_dict\n", + "\n", + "\n", + "def plot_emissions_comparison(\n", + " emissions_lcn: dict,\n", + " emissions_nac: dict,\n", + " plot_title: str,\n", + " output_path: str,\n", + " figsize: tuple = (14, 10),\n", + " num_col_graphs: int = 2,\n", + " row_spacing: float = 0.3,\n", + " col_spacing: float = 0.3,\n", + "):\n", + " \"\"\"\n", + " Plot emissions data comparing LCN and NAC datasets.\n", + "\n", + " Args:\n", + " emissions_lcn (dict): Dictionary containing LCN emissions DataFrames\n", + " emissions_nac (dict): Dictionary containing NAC emissions DataFrames\n", + " figsize (tuple): Figure size in inches\n", + " num_col_graphs (int): Number of columns in the subplot grid\n", + " row_spacing (float): Spacing between rows\n", + " col_spacing (float): Spacing between columns\n", + " \"\"\"\n", + " # Clean data first\n", + " emissions_lcn_clean = preprocess_emissions_data(emissions_lcn)\n", + " emissions_nac_clean = preprocess_emissions_data(emissions_nac)\n", + "\n", + " # Calculate number of rows needed\n", + " num_row_graphs = math.ceil(len(emissions_lcn_clean) / num_col_graphs)\n", + "\n", + " # Create subplot grid with tighter layout\n", + " fig = plt.figure(figsize=figsize)\n", + " gs = fig.add_gridspec(\n", + " num_row_graphs, num_col_graphs, hspace=row_spacing, wspace=col_spacing\n", + " )\n", + " axes = [\n", + " fig.add_subplot(gs[i // num_col_graphs, i % num_col_graphs])\n", + " for i in range(num_row_graphs * num_col_graphs)\n", + " ]\n", + "\n", + " # Create color palettes for both datasets\n", + " lcn_palette = sns.color_palette(\"husl\", len(emissions_lcn_clean))\n", + " nac_palette = sns.color_palette(\"Set2\", len(emissions_nac_clean))\n", + "\n", + " # Plot each type of emission\n", + " for idx, (emission_type, lcn_df) in enumerate(emissions_lcn_clean.items()):\n", + " write_source_notes(lcn_df, f'{emission_type}_source_notes.txt')\n", + " nac_df = emissions_nac_clean[emission_type]\n", + "\n", + " # Get numeric columns (years)\n", + " year_cols = [col for col in lcn_df.columns if str(col).isdigit()]\n", + " x_values = [int(year) for year in year_cols]\n", + "\n", + " # Plot LCN data\n", + " for i, row in lcn_df.iterrows():\n", + " indicator_name = row[\"IndicatorName\"]\n", + " y_values = row[year_cols].astype(float)\n", + "\n", + " axes[idx].plot(\n", + " x_values,\n", + " y_values,\n", + " \"_-\",\n", + " linewidth=1.5,\n", + " color=lcn_palette[i % len(lcn_palette)],\n", + " label=f'LCN - {row[\"IndicatorCode\"]}',\n", + " )\n", + "\n", + " # Plot NAC data\n", + " for i, row in nac_df.iterrows():\n", + " y_values = row[year_cols].astype(float)\n", + "\n", + " axes[idx].plot(\n", + " x_values,\n", + " y_values,\n", + " \"--\",\n", + " linewidth=1.5,\n", + " color=nac_palette[i % len(nac_palette)],\n", + " label=f'NAC - {row[\"IndicatorCode\"]}',\n", + " )\n", + "\n", + " # Customize plot with minimal padding\n", + " axes[idx].set_title(\n", + " f\"{emission_type.upper()} {plot_title} \", fontsize=12, pad=3\n", + " ) # Reduced padding between title and plot\n", + " axes[idx].set_xlabel(\"Year\", fontsize=12)\n", + " axes[idx].set_ylabel(f\"{plot_title.split()[0]}\", fontsize=12)\n", + " axes[idx].grid(True, which=\"both\", linestyle=\"--\", linewidth=0.3)\n", + " axes[idx].tick_params(axis=\"both\", labelsize=8)\n", + " axes[idx].legend(loc=\"best\", fontsize=6)\n", + "\n", + " # Hide unused axes\n", + " for j in range(len(emissions_lcn_clean), len(axes)):\n", + " axes[j].axis(\"off\")\n", + "\n", + " fig.suptitle(\n", + " f\"{plot_title}: Latin America & Caribbean vs North America\",\n", + " fontsize=14,\n", + " fontweight=\"bold\",\n", + " y=0.95,\n", + " )\n", + " plt.tight_layout()\n", + " plt.savefig(output_path, format=\"pdf\", bbox_inches=\"tight\", pad_inches=0.5)\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Overview " + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_overview_comparison(\n", + " overview_lcn: pd.DataFrame,\n", + " overview_nac: pd.DataFrame,\n", + " output_path: str,\n", + " figsize: tuple = (12, 8),\n", + " row_spacing: float = 0.4,\n", + " col_spacing: float = 0.3,\n", + "):\n", + " \"\"\"\n", + " Plot overview data comparing LCN and NAC datasets.\n", + "\n", + " Args:\n", + " overview_lcn (pd.DataFrame): DataFrame containing LCN overview data\n", + " overview_nac (pd.DataFrame): DataFrame containing NAC overview data\n", + " figsize (tuple): Figure size in inches\n", + " row_spacing (float): Spacing between rows\n", + " col_spacing (float): Spacing between columns\n", + " \"\"\"\n", + " write_source_notes(overview_lcn, 'overview_source_notes.txt')\n", + " # Create figure\n", + " fig = plt.figure(figsize=figsize)\n", + " gs = fig.add_gridspec(1, 1, hspace=row_spacing, wspace=col_spacing)\n", + " ax = fig.add_subplot(gs[0])\n", + "\n", + " # Get year columns\n", + " year_cols = [col for col in overview_lcn.columns if str(col).isdigit()]\n", + " x_values = [int(year) for year in year_cols]\n", + "\n", + " # Create color palettes\n", + " lcn_palette = sns.color_palette(\"husl\", len(overview_lcn))\n", + " nac_palette = sns.color_palette(\"Set2\", len(overview_nac))\n", + "\n", + " # Plot LCN data\n", + " for i, row in overview_lcn.iterrows():\n", + " y_values = row[year_cols].astype(float)\n", + " ax.plot(\n", + " x_values,\n", + " y_values,\n", + " \"_-\",\n", + " linewidth=1.5,\n", + " color=lcn_palette[i % len(lcn_palette)],\n", + " label=f'LCN - {row[\"IndicatorName\"]}',\n", + " )\n", + "\n", + " # Plot NAC data\n", + " for i, row in overview_nac.iterrows():\n", + " y_values = row[year_cols].astype(float)\n", + " ax.plot(\n", + " x_values,\n", + " y_values,\n", + " \"--\",\n", + " linewidth=1.5,\n", + " color=nac_palette[i % len(nac_palette)],\n", + " label=f'NAC - {row[\"IndicatorName\"]}',\n", + " )\n", + "\n", + " # Customize plot\n", + " ax.set_title(\"Overview Metrics Comparison: Latin America & Caribbean vs North America\", fontsize=14, pad=5)\n", + " ax.set_xlabel(\"Year\", fontsize=16)\n", + " ax.set_ylabel(\"Value\", fontsize=12)\n", + " ax.grid(True, which=\"both\", linestyle=\"--\", linewidth=0.5)\n", + " ax.tick_params(axis=\"both\", labelsize=10)\n", + " ax.legend(loc=\"center left\", bbox_to_anchor=(1, 0.5), fontsize=12)\n", + "\n", + " \n", + " # Save plot as PDF\n", + " plt.savefig(output_path, format='pdf', bbox_inches='tight', pad_inches=0.1)\n", + " # plt.savefig(\"overview_comparison.png\", dpi=300, bbox_inches=\"tight\", pad_inches=0.1)\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot overview comparison\n", + "plot_overview_comparison(overview_lcn, overview_nac, output_path=\"../data/overview_comparison.pdf\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Emission Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Unique indicators saved to ../data/emissions_lcn.csv\n", + "Unique indicators saved to ../data/emissions_nac.csv\n", + "Unique indicators saved to ../data/energy_lcn.csv\n", + "Unique indicators saved to ../data/energy_nac.csv\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "\n", + "def save_unique_indicators_to_csv(data_dict, output_file):\n", + " # Combine all DataFrames in the dictionary into a single DataFrame\n", + " combined_df = pd.concat(data_dict.values(), ignore_index=True)\n", + "\n", + " # Extract unique IndicatorCode and IndicatorName pairs\n", + " unique_indicators = combined_df[['IndicatorCode', 'IndicatorName', 'SourceNote']].drop_duplicates()\n", + "\n", + " # Save the unique pairs to a CSV file\n", + " unique_indicators.to_csv(output_file, index=False)\n", + " print(f\"Unique indicators saved to {output_file}\")\n", + "\n", + "save_unique_indicators_to_csv(emissions_lcn, \"../data/emissions_lcn.csv\")\n", + "save_unique_indicators_to_csv(emissions_nac, \"../data/emissions_nac.csv\")\n", + "save_unique_indicators_to_csv(energy_lcn, \"../data/energy_lcn.csv\")\n", + "save_unique_indicators_to_csv(energy_nac, \"../data/energy_nac.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_21985/1297014419.py:128: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_emissions_comparison(\n", + " emissions_lcn,\n", + " emissions_nac,\n", + " plot_title=\"Emissions Analysis\",\n", + " row_spacing=0.2,\n", + " col_spacing=0.15,\n", + " output_path=\"../data/emissions_comparison.pdf\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Energy Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_21985/1297014419.py:128: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_emissions_comparison(\n", + " energy_lcn,\n", + " energy_nac,\n", + " plot_title=\"Energy Analysis\",\n", + " row_spacing=0.2,\n", + " col_spacing=0.1,\n", + " output_path=\"../data/energy_comparison.pdf\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/project/pipeline.sh b/project/pipeline.sh new file mode 100755 index 0000000000..02b31d3efe --- /dev/null +++ b/project/pipeline.sh @@ -0,0 +1,2 @@ +#!/bin/bash +python3 ./project/prepare_data.py diff --git a/project/prepare_data.py b/project/prepare_data.py new file mode 100644 index 0000000000..9339ed6f26 --- /dev/null +++ b/project/prepare_data.py @@ -0,0 +1,184 @@ +import os +import io +import pandas as pd +import requests +import shutil +import zipfile +from sqlalchemy import create_engine, Table, Column, String, Integer, Float, MetaData + + + +def create_temp_directory(path="project/temp_dir"): + """Creates a temporary directory for storing extracted files.""" + os.makedirs(path, mode=0o777, exist_ok=True) + return path + + +def create_database_engine(db_path="data/world_data.sqlite"): + """Creates and returns an SQLAlchemy engine.""" + return create_engine(f"sqlite:///{db_path}") + + +def create_tables(metadata, year_columns): + """Defines and returns the table structures.""" + tables = { + "LCN": Table( + "LCN", + metadata, + Column("CountryName", String), + Column("CountryCode", String), + Column("IndicatorName", String), + Column("IndicatorCode", String), + Column("SourceNote", String), + Column("SourceOrganization", String), + *[Column(year, Float) for year in year_columns], + ), + "NAC": Table( + "NAC", + metadata, + Column("CountryName", String), + Column("CountryCode", String), + Column("IndicatorName", String), + Column("IndicatorCode", String), + Column("SourceNote", String), + Column("SourceOrganization", String), + *[Column(year, Float) for year in year_columns], + ), + } + return tables + + +def download_and_extract_data(urls, temp_dir): + """Downloads and extracts CSV files from the given URLs.""" + for region, url in urls.items(): + response = requests.get(url) + with zipfile.ZipFile(io.BytesIO(response.content)) as zip_ref: + zip_ref.extractall(temp_dir) + print(f"Downloaded and extracted data for {region}") + + +def load_main_and_metadata_files(temp_dir): + """Loads main and metadata files from the temporary directory.""" + main_files = [ + f for f in os.listdir(temp_dir) if f.startswith("API") and f.endswith(".csv") + ] + metadata_files = [ + f + for f in os.listdir(temp_dir) + if f.startswith("Metadata_Indicator") and f.endswith(".csv") + ] + metadata_files = list(reversed(metadata_files)) + return main_files, metadata_files + + +def clean_and_merge_data(main_file, metadata_file, temp_dir, year_columns): + """Cleans and merges the main data with metadata.""" + # Load main data + main_df = pd.read_csv( + os.path.join(temp_dir, main_file), encoding="utf-8-sig", skiprows=4 + ) + main_df.fillna(0, inplace=True) + main_df = main_df.loc[:, ~main_df.columns.str.contains("^Unnamed")] + + # Load metadata + metadata_df = pd.read_csv( + os.path.join(temp_dir, metadata_file), encoding="utf-8-sig" + ) + metadata_df = metadata_df.loc[:, ~metadata_df.columns.str.contains("^Unnamed")] + metadata_df.rename(columns={"INDICATOR_CODE": "Indicator Code"}, inplace=True) + metadata_df = metadata_df.drop(columns=["INDICATOR_NAME"]) + + # Merge data and metadata on 'Indicator Code' + merged_df = main_df.merge(metadata_df, on="Indicator Code", how="outer") + + # Rename columns to match the database table schema + merged_df.rename( + columns={ + "Country Name": "CountryName", + "Country Code": "CountryCode", + "Indicator Name": "IndicatorName", + "Indicator Code": "IndicatorCode", + "SOURCE_NOTE": "SourceNote", + "SOURCE_ORGANIZATION": "SourceOrganization", + }, + inplace=True, + ) + + # Rearrange columns + merged_df = merged_df[ + [ + "CountryName", + "CountryCode", + "IndicatorName", + "IndicatorCode", + "SourceNote", + "SourceOrganization", + *year_columns, + ] + ] + + return merged_df + + +def save_to_database(merged_df, table_name, tables, engine): + """Saves the merged data to the appropriate SQLite table.""" + if table_name in tables: + merged_df.to_sql(table_name, engine, if_exists="append", index=False) + print(f"Merged data and metadata stored in SQLite table '{table_name}'") + else: + print(f"Table '{table_name}' not found in the database") + + +def clean_up(temp_dir): + """Removes the temporary directory.""" + shutil.rmtree(temp_dir) + print("Cleaned up temporary directory.") + + +def main(): + """Main function that orchestrates the entire process.""" + urls = { + "north_america": "https://api.worldbank.org/v2/en/country/NAC?downloadformat=csv", + "latin_america_caribbean": "https://api.worldbank.org/v2/en/country/LCN?downloadformat=csv", + } + + # Create the temp directory and database engine + temp_dir = create_temp_directory() + engine = create_database_engine() + print("Created temporary directory and database engine.") + + # Define year columns (1960 to 2023) + year_columns = [str(year) for year in range(1960, 2024)] + + # Create tables if they don't exist + metadata = MetaData() + tables = create_tables(metadata, year_columns) + metadata.create_all(engine) + + # Download and extract data + download_and_extract_data(urls, temp_dir) + + # Load main and metadata files + main_files, metadata_files = load_main_and_metadata_files(temp_dir) + + # Process each file pair + for main_file, metadata_file in zip(main_files, metadata_files): + merged_df = clean_and_merge_data( + main_file, metadata_file, temp_dir, year_columns + ) + + # Determine the table name based on the region + # table_name = main_file.split("_")[1].split(".")[0].title().replace(" ", "_") + # table_name = region.replace("_", " ").title().replace(" ", "_") + # Determine the region and map to table name + region = main_file.split("_")[1].split(".")[0] + + # Save the merged data to the database + save_to_database(merged_df, region, tables, engine) + + # Clean up the temporary directory + clean_up(temp_dir) + + +if __name__ == "__main__": + main() diff --git a/project/project-plan-example.md b/project/project-plan-example.md new file mode 100644 index 0000000000..109487d1e5 --- /dev/null +++ b/project/project-plan-example.md @@ -0,0 +1,50 @@ +# Project Plan + +## A visual inspection of Regional Economic Trends: North America & Latin America Analysis + +This analysis utilizes the International Renewable Energy Agency (IRENA) dataset to carry out a comprehensive visual inspection of the energy deployment across the Americas. Some of the key aspects that will be covered are: Costs, Energy Transition, Capacity and Generation and Investment trends. + +## Main Question + + +* How have economic indicators (such as GDP, poverty rate, or education level) evolved over time across different countries in North America and Latin America & the Caribbean, and what trends or patterns can be identified in their development? + + + +## Description + + +For this project, I am working on integrating and analyzing global economic and development indicators from the World Bank for different regions. The goal is to clean, merge, and store these indicators in an SQLite database to facilitate future analysis. The project begins by downloading raw CSV files containing economic data as well as many indicators for North America and Latin America & the Caribbean. These files are then extracted from compressed archives, cleaned by removing unnecessary columns, and merged with metadata that provides descriptions for each indicator. The data is then transformed to match a predefined schema with columns for country names, indicator codes, and values for each year from 1960 to 2023 and stored in two tables 'LCN' and 'NAC' of the world_data.sqlite database. + +## Datasources + + + +#### Datasource 1: North America Economic Data [World Bank](https://data.worldbank.org/region/north-america?view=chart) +This dataset contains various economic and development indicators for countries in North America, including the United States, Canada, and Mexico. It includes data on GDP, poverty rates, education, healthcare, and other socio-economic indicators over time (from 1960 to 2023). The data is provided by the World Bank in CSV format and will be used to examine the economic development and trends in the North American region. The source is available for download through a World Bank API, which delivers the data in a zip file. + +#### Datasource 2: Latin America & Caribbean Economic Data [World Bank]( https://data.worldbank.org/region/latin-america-and-caribbean?view=chart) +Similar to the North American dataset, this dataset provides economic and development indicators for countries in Latin America and the Caribbean. It includes a wide range of data on economic growth, social development, and health metrics. The dataset spans the years 1960 to 2023 and will be used to analyze trends in economic and social development for the Latin American and Caribbean region. The data is also provided in CSV format and can be accessed through the World Bank API in a compressed zip file. [World bank Website](https://data.worldbank.org/) + +### Datasource: World Bank Dataset +* Metadata URL: https://data.worldbank.org/country +* Data source 1: https://data.worldbank.org/region/north-america?view=chart +* Data source 2: https://data.worldbank.org/region/latin-america-and-caribbean?view=chart +* Data Type: csv + +### License +[Creative Commons Attribution 4.0 International License (CC BY 4.0)](https://www.worldbank.org/en/about/legal/terms-of-use-for-datasets) + + + +## Work Packages + + + +- [x] Data Collection and Cleaning [#1][i1] +- [] Exploratory Data Analysis [#2][i1] +- [] Visualization Development [#3][i1] +- [] Comparision of Investment Trends [#4][i1] +- [] Final Report and Presentation [#5][i1] + +[i1]: https://github.com/jvalue/made-template/issues/1 diff --git a/project/run_tests.py b/project/run_tests.py new file mode 100644 index 0000000000..8ac2c1828f --- /dev/null +++ b/project/run_tests.py @@ -0,0 +1,75 @@ +import unittest +from unittest.mock import patch, MagicMock +import os +import pandas as pd +from prepare_data import ( + create_temp_directory, + create_database_engine, + create_tables, + download_and_extract_data, + load_main_and_metadata_files, + save_to_database, + clean_up, +) + + +class TestDataProcessing(unittest.TestCase): + + @patch("os.makedirs") + def test_create_temp_directory(self, mock_makedirs): + path = create_temp_directory() + self.assertTrue(mock_makedirs.called) + self.assertEqual(path, "project/temp_dir") + + @patch("prepare_data.create_engine") + def test_create_database_engine(self, mock_create_engine): + db_path = "data/world_data.sqlite" + engine = create_database_engine() + mock_create_engine.assert_called_with(f"sqlite:///{db_path}") + self.assertIsNotNone(engine) + + @patch("requests.get") + @patch("zipfile.ZipFile") + def test_download_and_extract_data(self, mock_zipfile, mock_requests): + mock_response = MagicMock() + mock_response.content = b"dummy content" + mock_requests.return_value = mock_response + + urls = { + "north_america": "https://api.worldbank.org/v2/en/country/NAC?downloadformat=csv", + "latin_america_caribbean": "https://api.worldbank.org/v2/en/country/LCN?downloadformat=csv", + } + temp_dir = "temp_dir" + + download_and_extract_data(urls, temp_dir) + self.assertTrue(mock_zipfile.called) + + @patch("os.listdir") + @patch("pandas.read_csv") + def test_load_main_and_metadata_files(self, mock_read_csv, mock_listdir): + mock_listdir.return_value = ["API_data.csv", "Metadata_Indicator.csv"] + main_files, metadata_files = load_main_and_metadata_files("temp_dir") + + self.assertEqual(main_files, ["API_data.csv"]) + self.assertEqual(metadata_files, ["Metadata_Indicator.csv"]) + + @patch("pandas.DataFrame.to_sql") + def test_save_to_database(self, mock_to_sql): + merged_df = pd.DataFrame() + tables = { + "NAC": MagicMock(), # Mock for North America table + "LCN": MagicMock(), # Mock for Latin America/Caribbean table + } + + save_to_database(merged_df, "NAC", tables, None) + self.assertTrue(mock_to_sql.called) + + + @patch("shutil.rmtree") + def test_clean_up(self, mock_rmtree): + clean_up("temp_dir") + self.assertTrue(mock_rmtree.called) + + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/project/tests.sh b/project/tests.sh new file mode 100755 index 0000000000..d059f15464 --- /dev/null +++ b/project/tests.sh @@ -0,0 +1 @@ +python3 ./project/run_tests.py \ No newline at end of file diff --git a/project/version_check.py b/project/version_check.py new file mode 100644 index 0000000000..723123ea59 --- /dev/null +++ b/project/version_check.py @@ -0,0 +1,11 @@ +import pkg_resources + +def check_versions(package_list): + installed_packages = {pkg.key: pkg.version for pkg in pkg_resources.working_set} + for package in package_list: + version = installed_packages.get(package.lower(), "Not installed") + print(f"{package}: {version}") + +# Replace these with the package names you want to check +selected_packages = ["zipfile", "shutil", "numpy", "pandas", "scikit-learn", "matplotlib", "sqlalchemy"] +check_versions(selected_packages) diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000..b36213ddf2 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +numpy==1.26.4 +pandas==1.5.3 +scikit-learn==1.2.2 +matplotlib==3.8.0 +sqlalchemy==2.0.25 +seaborn +pytest +requests \ No newline at end of file