import unittest
import user_code
import ast
import re   
import importlib
import csv
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import geopandas as gpd
import numpy as np

class TestTask(unittest.TestCase):
    def setUp(self):
        from shapely.geometry import Polygon
        poly1 = Polygon([(0,0),(1,0),(1,1),(0,1)])
        poly2 = Polygon([(2,2),(3,2),(3,3),(2,3)])
        self.gdf1 = gpd.GeoDataFrame({'attr':[10, 20], 'geometry':[poly1, poly2]})
        self.gdf2 = gpd.GeoDataFrame({'attr':[30, 40], 'geometry':[poly1, poly2]})
        self.attribute = 'attr'
        self.title1 = 'Test1'
        self.title2 = 'Test2'

    def test_two_subplots_in_grid(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        figs = list(map(plt.figure, plt.get_fignums()))
        _dynamic_test(
            self,
            len(figs) > 0,
            'At least one figure is created.',
            'No figure was created.'
        )
        fig = figs[-1]
        axes = fig.get_axes()
        
        # The first two axes created are always the main geographic subplots
        main_axes = axes[:2]
        _dynamic_test(
            self,
            len(main_axes) == 2,
            'Figure has two subplots (axes) as required.',
            f'Expected 2 main subplots, got {len(main_axes)}.'
        )

    def test_each_subplot_visualizes_attribute(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        main_axes = axes[:2]
        
        for ax in main_axes:
            found = False
            for c in ax.collections:
                if hasattr(c, 'cmap'):
                    found = True
            _dynamic_test(
                self,
                found,
                'Each subplot visualizes the attribute with a colored collection.',
                'No colored collection found on subplot.'
            )

    def test_same_colormap_and_legend(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        
        main_axes = axes[:2]
        cmaps = [c.cmap.name for ax in main_axes for c in ax.collections if hasattr(c, 'cmap')]
        _dynamic_test(
            self,
            len(cmaps) >= 2 and cmaps[0] == cmaps[1],
            'Both subplots use the same color map.',
            f'Colormaps used: {cmaps}'
        )
        
        # When legend=True, GeoPandas appends extra colorbar axes to the figure container
        colorbar_found = len(axes) > 2
        _dynamic_test(
            self,
            colorbar_found,
            'At least one legend (colorbar) is present.',
            'No legend (colorbar) found.'
        )

    def test_axes_removed(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        
        # Only check the main map axes for visibility removal (colorbars require visible ticks)
        main_axes = axes[:2]
        for ax in main_axes:
            _dynamic_test(
                self,
                not ax.axison or (not ax.get_xaxis().get_visible() and not ax.get_yaxis().get_visible()),
                'Axes are removed from subplot.',
                'Axes are visible on subplot.'
            )

    def test_titles_present(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        fig = plt.gcf()
        axes = fig.get_axes()
        titles = [ax.get_title() for ax in axes]
        _dynamic_test(
            self,
            self.title1 in titles and self.title2 in titles,
            'Each subplot is labeled with the provided title.',
            f'Titles found: {titles}'
        )

    def test_color_scale_consistency(self):
        import user_code
        importlib.reload(user_code)
        plt.close('all')
        min1 = self.gdf1[self.attribute].min()
        max1 = self.gdf1[self.attribute].max()
        min2 = self.gdf2[self.attribute].min()
        max2 = self.gdf2[self.attribute].max()
        vmin = min(min1, min2)
        vmax = max(max1, max2)
        
        # Patch the absolute base rendering function of the geopandas library
        import geopandas.plotting as gplotting
        orig_plot_dataframe = gplotting.plot_dataframe
        vmin_used = []
        vmax_used = []
        
        def patched_plot_dataframe(df, *args, **kwargs):
            vmin_used.append(kwargs.get('vmin', None))
            vmax_used.append(kwargs.get('vmax', None))
            return orig_plot_dataframe(df, *args, **kwargs)
            
        gplotting.plot_dataframe = patched_plot_dataframe
        try:
            user_code.plot_comparison_grid(self.gdf1, self.gdf2, self.attribute, self.title1, self.title2)
        finally:
            gplotting.plot_dataframe = orig_plot_dataframe
            
        _dynamic_test(
            self,
            len(vmin_used) == 2 and len(vmax_used) == 2 and all(v == vmin for v in vmin_used) and all(v == vmax for v in vmax_used),
            'Both plots use the same color scale (vmin/vmax) for the attribute.',
            f'vmin used: {vmin_used}, vmax used: {vmax_used}, expected vmin={vmin}, vmax={vmax}'
        )

def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

if __name__ == "__main__":
    unittest.main()

test_main.py

Plongez dans les fondamentaux de l'analyse de données géospatiales avec Python. Ce cours intermédiaire vous présente les concepts clés et les applications pratiques de l'analyse géospatiale, en mettant l'accent sur des jeux de données réels et des projets pratiques. Vous apprendrez à manipuler, visualiser et analyser des données spatiales avec Python et des bibliothèques populaires, en mettant particulièrement l'accent sur geopandas. Le cours est conçu pour être engageant, avec des grilles interactives, des vidéos et des quiz pour renforcer votre apprentissage.

Explorez les bases des données géospatiales, des systèmes de coordonnées et des outils essentiels pour l'analyse spatiale en Python. Cette section pose les bases du travail avec des ensembles de données spatiales et présente en détail geopandas, y compris ses structures de données principales, ses capacités de lecture/écriture et son intégration avec pandas et matplotlib.

Explorez les techniques fondamentales d'analyse spatiale, y compris les jointures spatiales, les superpositions et les agrégations, en utilisant geopandas et des bibliothèques de visualisation. Cette section couvre des méthodes avancées de geopandas pour combiner, comparer et résumer des ensembles de données spatiales, ainsi que les meilleures pratiques pour la visualisation des données spatiales.

Acquérir une compréhension approfondie des ensembles de données géospatiales réels et des scénarios, en mettant l'accent sur les défis pratiques d'analyse et de visualisation. Cette section met l'accent sur l'apprentissage par projet et la synthèse des techniques d'analyse géospatiale.

Défi : Visualisation des Données Spatiales avec des Grilles

Solution